使用codedom自动生成代码

刚刚接触自动代码生成，便小试牛刀，解决了项目中的一些问题。

问题：我们的项目分成很多层次，当增加一个方法的时候，会显得异常繁琐，但每个层次之间的调用大同小异，所以尝试使用代码生成。现在假设有Engine， EngineBase，LocalEngine， RemoteEngine，Host等几个类，其定义和关系如下：

     public class EngineFacade
     {
         private EngineBase engine = null;
         public EngineFacade(bool isLocalEngine = true)
         {
             if (isLocalEngine)
             {
                 engine = new LocalEngine();
             }
             else
             {
                 engine = new RemoteEngine();
             }
         }

         public bool GetCurrentStatus()
         {
             return true;
         }
     }

     public abstract class EngineBase
     {
         public abstract bool GetCurrentStatus();
     }

     public class LocalEngine : EngineBase
     {
         public override bool GetCurrentStatus()
         {
             return true;
         }
     }

     public class RemoteEngine : EngineBase
     {
         private IHost host = null;

         public RemoteEngine()
         {
             host = new Host();
         }

         public override bool GetCurrentStatus()
         {
             return host.GetCurerntStatus();
         }
     }

     public interface IHost
     {
         bool GetCurerntStatus();
     }

     public class Host : IHost
     {
         public bool GetCurerntStatus()
         {
             return true;
         }
     }

层次关系定义

上诉定义的类会被SampleClient调用：

    public class SampleClient
    {
        public void Test()
        {
            var engine = new EngineFacade(false);
            Console.WriteLine(engine.GetCurrentStatus());
        }
    }

SampleClient

如果我们需要增加一个新的方法SetStatus，如何避免额外的体力劳动呢？

解决方案：使用CodeDom进行动态代码生成。

 class CodeGenerator
     {
         private CodeCompileUnit targetUnit = new CodeCompileUnit();
         private CodeTypeDeclaration targetClass = new CodeTypeDeclaration("Test");
         private static readonly string targetInstance = "engineInstance";

         public CodeGenerator()
         {
             CodeNamespace sample = new CodeNamespace("CodeDomTest");
             sample.Imports.Add(new CodeNamespaceImport("System"));
             targetClass.IsClass = true;
             targetClass.TypeAttributes = TypeAttributes.Public;
             sample.Types.Add(targetClass);
             targetUnit.Namespaces.Add(sample);
         }

         public void AddMethod(string name, Type returnType, string comments, CodeExpression codeExpression)
         {
             CodeMemberMethod method = new CodeMemberMethod();
             method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
             method.Name = name;
             method.ReturnType = new CodeTypeReference(returnType);
             method.Comments.Add(new CodeCommentStatement(comments));
             CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement();
             returnStatement.Expression = codeExpression;
             method.Statements.Add(returnStatement);
             targetClass.Members.Add(method);
         }

         public void AddMethod(string name, Type returnType, string comments, CodeExpression codeExpression, string paraName, Type paraType)
         {
             CodeMemberMethod method = new CodeMemberMethod();
             method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
             method.Name = name;
             method.ReturnType = new CodeTypeReference(returnType);
             method.Comments.Add(new CodeCommentStatement(comments));
             method.Parameters.Add(new CodeParameterDeclarationExpression(paraType, paraName));
             CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement();
             returnStatement.Expression = codeExpression;
             method.Statements.Add(returnStatement);
             targetClass.Members.Add(method);
         }

         public void AddMethod(string name, Type returnType, string comments, CodeExpression codeExpression, List<CodeParameterDeclarationExpression> parameters)
         {
             CodeMemberMethod method = new CodeMemberMethod();
             method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
             method.Name = name;
             method.ReturnType = new CodeTypeReference(returnType);
             method.Comments.Add(new CodeCommentStatement(comments));
             method.Parameters.AddRange(parameters.ToArray());
             CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement();
             returnStatement.Expression = codeExpression;
             method.Statements.Add(returnStatement);
             targetClass.Members.Add(method);
         }

         public void AddAbstractMethod(string name, Type returnType, string comments)
         {
             CodeMemberMethod method = new CodeMemberMethod();
             method.Attributes = MemberAttributes.Abstract | MemberAttributes.Public;
             method.Name = name;
             method.ReturnType = new CodeTypeReference(returnType);
             method.Comments.Add(new CodeCommentStatement(comments));
             targetClass.Members.Add(method);
         }

         public void AddAbstractMethod(string name, Type returnType, string comments, string paraName, Type paraType)
         {
             CodeMemberMethod method = new CodeMemberMethod();
             method.Attributes = MemberAttributes.Abstract | MemberAttributes.Public;
             method.Name = name;
             method.ReturnType = new CodeTypeReference(returnType);
             method.Parameters.Add(new CodeParameterDeclarationExpression(paraType, paraName));
             method.Comments.Add(new CodeCommentStatement(comments));
             targetClass.Members.Add(method);
         }

         public void AddField(string name, Type fieldType)
         {
             CodeMemberField member = new CodeMemberField();
             member.Attributes = MemberAttributes.Private;
             member.Name = name;
             member.Type = new CodeTypeReference(fieldType);
             targetClass.Members.Add(member);
         }

         public void GenerateCode()
         {
             CodeDomProvider provider = new CSharpCodeProvider();
             CodeGeneratorOptions options = new CodeGeneratorOptions();
             options.BracingStyle = "C";
             using (StreamWriter streamWriter = new StreamWriter("SampleReactorCode.cs"))
             {
                 provider.GenerateCodeFromCompileUnit(targetUnit, streamWriter, options);
             }
         }

         public static void Start()
         {
             CodeGenerator sample = new CodeGenerator();
             Test(sample);
             sample.GenerateCode();
         }

         private static void Test(CodeGenerator sample)
         {
             var methodToAdd = "Test";
             var returnType = typeof(Dictionary<string, object>);
             var paraname = "key";
             var paraType = typeof(string);
             var parTypes = new Dictionary<string, Type>() { { "no", typeof(int) }, { paraname, paraType } };

             var parameters = GenerateParameters(parTypes);
             var parArguments = GenerateParametersArguments(parTypes).ToArray();

             sample.AddMethod(methodToAdd, returnType, "This is for engine facade",
                 new CodeMethodInvokeExpression(
                     new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), targetInstance),
                     methodToAdd, parArguments), parameters);
             sample.AddAbstractMethod(methodToAdd, returnType, "This is for engine base", paraname, paraType);
             sample.AddMethod(methodToAdd, returnType, "This is for local engine",
                 new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "scenario"),
                     methodToAdd, parArguments), parameters);
             sample.AddMethod(methodToAdd, returnType, "This is for remote engine",
                 new CodeMethodInvokeExpression(
                     new CodeTypeReferenceExpression(new CodeTypeReference("HostProxy")), methodToAdd,
                     parArguments), parameters);

             var dump = parArguments.ToList();
             parameters.Insert(, new CodeParameterDeclarationExpression(typeof(string), "engineKey"));
             dump.Insert(, new CodeArgumentReferenceExpression("engineKey"));
             parArguments = dump.ToArray();

             sample.AddMethod(methodToAdd, returnType, "This is for host",
                 new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("InstanceManager"), methodToAdd, parArguments),
                 parameters);

             dump.Insert(, new CodePrimitiveExpression(methodToAdd));
             dump.Insert(, new CodeArgumentReferenceExpression("host_name"));
             parArguments = dump.ToArray();
             sample.AddMethod(methodToAdd, returnType, "This is for host",
                 new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("host"), string.Format("Invoke<{0}>", returnType.ToString())
                     , parArguments), parameters);
         }

         private static List<CodeParameterDeclarationExpression> GenerateParameters(Dictionary<string, Type> parameterTypes)
         {
             return parameterTypes.Select(parameterType => new CodeParameterDeclarationExpression(parameterType.Value, parameterType.Key)).ToList();
         }
         private static List<CodeExpression> GenerateParametersArguments(Dictionary<string, Type> parameterTypes)
         {
             return parameterTypes.Select(parameterType => (CodeExpression)new CodeArgumentReferenceExpression(parameterType.Key)).ToList();
         }
     }

CodeGenerator

如何使用CodeDom，请参考动态源代码生成和编译。