如何生成简单的契约类

我有一个c#应用程序，它为合约公开了一个API(通过WebAPI或WCF)和一个单独的dll。契约dll由NuGet公开，以便调用者在调用应用程序时可以使用契约对象。

然而，契约类是用自定义验证属性装饰的，其中许多属性依赖于存储库dll等，我不想将其包含在契约NuGet中。我基本上想发布一个简化形式的合约，我可以接收它，并将其反序列化到原始合约对象中(如果需要，使用valueinjector)。

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

Edit:感谢您的反馈。目前，我编写的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'{{0}}'{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();
        }
    }
    #>