Question

我有一个c＃应用程序，它公开了一个API（通过WebAPI或WCF）和一个单独的合同dll。合同dll由NuGet公开，以便调用者可以在调用应用程序时使用合同对象。

但是，合同类使用自定义验证属性进行修饰，其中许多属性依赖于存储库dll等，我不希望在合同NuGet中包含这些属性。我本质上希望发布一个合同的简化形式，我可以接收它并反序列化到原始合同对象中（如果需要，使用ValueInjecter）。

我无法找到开箱即用的解决方案，因此我开始编写一个t4转换文件来运行合同程序集并创建新的简化类，而不需要所有验证属性。这变得相当乏味，我希望那里的人有更好的解决方案。我发现很难相信我是第一个遇到这个问题的人。

修改：感谢您的反馈。现在，我写的T4运行得很好，只生成我需要的简单类。好的是，虽然调用者正在发送简化类，但它被反序列化为原始类。

我已经在下面列出了基本.ttinclude文件的代码：

<#@ assembly name="System.Core" #>
<#@ assembly name="System.Runtime.Serialization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" #>
<#@ assembly name="System.Xml" #>
<#@ import namespace="Microsoft.VisualStudio.TextTemplating" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Text"#>
<#@ include file="EF.Utility.CS.ttinclude"#>

<#+
    private class DtoGenerator
    {
        private static readonly Lazy<System.Resources.ResourceManager> ResourceManager =
            new Lazy<System.Resources.ResourceManager>(
                () => new System.Resources.ResourceManager("System.Data.Entity.Design", typeof(MetadataItemCollectionFactory).Assembly), isThreadSafe: true);

        private readonly TextTransformation textTransform;
        private readonly EntityFrameworkTemplateFileManager fileManager;
        private readonly ITextTemplatingEngineHost Host;

        public DtoGenerator(object textTransform, ITextTemplatingEngineHost host)
        {
            this.textTransform = textTransform as TextTransformation;
            this.fileManager = EntityFrameworkTemplateFileManager.Create(textTransform);
            this.Host = host;
        }
        public void Write(string text)
        {
            this.textTransform.Write(text);
        }

        public void Generate(string folderName, string assemblyName)
        {
            var inputAssembly = GetAssembly(folderName, assemblyName);

            if (inputAssembly == null)
            {
                Write("// No assembly found");
                return;
            }

            var classes = new Dictionary<Type, string>();
            var types = inputAssembly.GetTypes()
                .Where(type => type.GetCustomAttributes(false).Any(o => o.GetType().Name == "GenerateDtoAttribute")) //This is a custom attribute that marks classes to be generated
                .ToList();

            if (!types.Any())
            {
                Write("// No types found");
                return;
            }
            foreach (var type in types)
            {
                var baseExtension = "";
                var baseClass = type.BaseType;
                if (baseClass != null && baseClass != typeof(object))
                {
                    baseExtension = @" : " + baseClass;
                }

                var currentClass = string.Concat(@"
namespace ", type.Namespace, @"
{
    public class ", type.Name, baseExtension, @"
    {
", WritePublicProperties(type), @"
    }
}");
                classes.Add(type, currentClass);
            }

            foreach (var @class in classes)
            {
                fileManager.StartNewFile(@class.Key.Name + ".cs");
                Write(GetHeader());
                Write(@class.Value);
            }

            fileManager.Process();
        }

        private Assembly GetAssembly(string folderName, string assemblyName)
        {
            var relativePathTemplate = string.Format(@"..\{0}\bin\\{1}.dll", folderName, assemblyName);
            string debugPath,
                releasePath,
                debugRelativePath = string.Format(relativePathTemplate, "debug"),
                releaseRelativePath = string.Format(relativePathTemplate, "release");

            try
            {
                debugPath = Path.GetFullPath(Host.ResolvePath(debugRelativePath));
            }
            catch (FileNotFoundException)
            {
                debugPath = null;
            }
            try
            {
                releasePath = Path.GetFullPath(Host.ResolvePath(releaseRelativePath));
            }
            catch (FileNotFoundException)
            {
                releasePath = null;
            }

            if (debugPath == null && releasePath == null)
            {
                return null;
            }

            var debugDllDate = debugPath == null ? DateTime.MinValue : File.GetLastWriteTime(debugPath);
            var releaseDllDate = releasePath == null ? DateTime.MinValue : File.GetLastWriteTime(releasePath);

            var assemblyDllPath = debugDllDate > releaseDllDate ? debugPath : releasePath;
            if (assemblyDllPath == null) return null;
            var assembly = Assembly.LoadFrom(assemblyDllPath);

            return assembly;
        }

        private string GetHeader()
        {
            var header = string.Format(
                @"//------------------------------------------------------------------------------
// <auto-generated>
// {0}
//
// {1}
// {2}
// </auto-generated>
//------------------------------------------------------------------------------",
                ResourceManager.Value.GetString("Template_GeneratedCodeCommentLine1", null),
                ResourceManager.Value.GetString("Template_GeneratedCodeCommentLine2", null),
                ResourceManager.Value.GetString("Template_GeneratedCodeCommentLine3", null));

            return header;
        }

        private string WritePublicProperties(Type type)
        {
            var properties =
                type.GetProperties()
                    .Where(
                        info => info.DeclaringType == type
                            && info.GetMethod != null && info.GetMethod.IsPublic
                            && info.SetMethod != null && info.SetMethod.IsPublic)
                    .ToList();

            var propertyStrings = (from propertyInfo in properties
                let typeString = GetTypeName(propertyInfo.PropertyType)
                select string.Concat(@"      public ", typeString, " ", propertyInfo.Name, @" { get; set; }")).ToList();

            return string.Join("\r\n", propertyStrings);
        }

        private string GetTypeName(Type type)
        {
            if (type.IsGenericType)
                return type.ToString().Split('`')[0] + "<" + string.Join(", ", type.GetGenericArguments().Select(GetTypeName).ToArray()) + ">";

            return type.ToString();
        }
    }

    #>

Answer 1

我有类似的情况，我有模型，我从后台，通过服务总线，到前台和网站发送该模型。我所做的是，在3个不同的命名空间中有3个几乎相同的POCO类。

现在，前台的模型具有来自JSON.NET命名空间的属性，这些属性决定了它是如何（de）序列化的。 servicebus命名空间中的模型可能具有一些其他属性，如iscached或其他。类似地，后端模型具有用于在持久性[Required]和事物上进行验证的属性。

显然，我不想在我保存在数据库或servicebus中的模型上使用JSON.NET属性。我也不想在前端或servicebus中使用System.ComponentModel.DataAnnotation属性。因此，我将每个图层的模型映射到下一个图层的名称空间（取决于数据流的方向）。

使用AutoMapper在每一层上完成映射 - 如果模型非常相似，则可以是单行。因此，来自JSON的传入消息被反序列化为FrontOffice模型，然后转换为放置在总线上的ServiceBus模型。 BackOffice反序列化ServiceBus模型并将其映射到BackOffice模型......无论如何 - 你得到它。

您可以进行相同类型的设置 - 您的NuGet库是非常干净的POCO库，几乎没有依赖关系。您后面有一个高度类似的模型层，您可以在其中映射传入的消息。然后在其上执行您想要执行的丰富验证。

这似乎是重复，但对我来说它很有效，因为我们已经解耦了模型。这将 - 例如 - 也将BackOffice的ALM与FrontOffice分离（只要映射仍然有效）。如果您采用T4方法 - 您的API模型与其他模型紧密耦合，这可能会成为未来的问题。

如何生成简单的合同类

1 个答案: