C# CSharpCodeProvider.GenerateCodeFromType方法代码示例

        public static string CreatePublicApiForAssembly(Assembly assembly)
        {
            var publicApiBuilder = new StringBuilder();
            var cgo = new CodeGeneratorOptions
            {
                BracingStyle = "C",
                BlankLinesBetweenMembers = false
            };

            using (var provider = new CSharpCodeProvider())
            {
                var publicTypes = assembly.GetTypes()
                    .Where(t => t.IsPublic && t.Name != "GeneratedInternalTypeHelper") //GeneratedInternalTypeHelper seems to be a r# runner side effect
                    .OrderBy(t => t.FullName);
                foreach (var publicType in publicTypes)
                {
                    var writer = new StringWriter();
                    var genClass = CreateClassDeclaration(publicType);
                    foreach (var memberInfo in publicType.GetMembers().Where(m => !IsDotNetTypeMember(m)).OrderBy(m => m.Name))
                    {
                        AddMemberToClassDefinition(genClass, memberInfo);
                    }
                    provider.GenerateCodeFromType(genClass, writer, cgo);
                    var gennedClass = GenerateClassCode(writer);
                    publicApiBuilder.AppendLine(gennedClass);
                }
            }
            var publicApi = publicApiBuilder.ToString();
            return publicApi.Trim();
        }

        static void Main(string[] args)
        {
            CodeTypeDeclaration MyClass = Class("MyClass");
            MyClass.Add(Method("StrLen", Type(typeof(int))));
            TheMethod.Add(Parameter(typeof(string), "str"));
            TheMethod.Return(Expression("str.Length"));

            CSharpCodeProvider Provider = new CSharpCodeProvider();
            Provider.GenerateCodeFromType(MyClass, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions());
            Console.ReadKey();
        }

 // Litee: This method is used for additional sorting of custom attributes when multiple values are allowed
 private static object ConvertAttrbuteToCode(Func<CodeTypeReference, CodeTypeReference> codeTypeModifier, CustomAttribute customAttribute)
 {
     using (var provider = new CSharpCodeProvider())
     {
         var cgo = new CodeGeneratorOptions
         {
             BracingStyle = "C",
             BlankLinesBetweenMembers = false,
             VerbatimOrder = false
         };
         var attribute = GenerateCodeAttributeDeclaration(codeTypeModifier, customAttribute);
         var declaration = new CodeTypeDeclaration("DummyClass")
         {
             CustomAttributes = new CodeAttributeDeclarationCollection(new[] { attribute }),
         };
         using (var writer = new StringWriter())
         {
             provider.GenerateCodeFromType(declaration, writer, cgo);
             return writer.ToString();
         }
     }
 }

 /// <summary>
 /// Generates CSharp text from a type declaration and writes it to a text writer with the given options.
 /// </summary>
 /// <param name="typeDeclaration">The type declaration to generate text from.</param>
 /// <param name="writer">The text writer to write to.</param>
 /// <param name="options">The generation options.</param>
 public static void GenerateCSharpTo(this CodeTypeDeclaration typeDeclaration, TextWriter writer, CodeGeneratorOptions options)
 {
     using (var provider = new CSharpCodeProvider())
     {
         provider.GenerateCodeFromType(typeDeclaration, writer, options);
     }
 }

        private static string DeclToString(CodeTypeDeclaration decl)
        {
            var provider = new CSharpCodeProvider();
            var opts = new CodeGeneratorOptions { IndentString = "    ", BracingStyle = "C" };

            var writer = new StringWriter();
            provider.GenerateCodeFromType(decl, writer, opts);
            return writer.GetStringBuilder().ToString();
        }

//.........这里部分代码省略.........
     {
      if(((MethodInfo)mi).IsSpecialName)
       break;
      CodeMemberMethod cc = new CodeMemberMethod();
      if(((MethodInfo)mi).Name.Contains("."))
       cc.Attributes = (cc.Attributes & ~MemberAttributes.AccessMask);
      else if(((MethodInfo)mi).IsPrivate)
       cc.Attributes = (cc.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private;
      else if(((MethodInfo)mi).IsPublic)
       cc.Attributes = (cc.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
      if(((MethodInfo)mi).IsStatic)
       cc.Attributes |= MemberAttributes.Static;
      cc.Name = ((MethodInfo)mi).Name;
      foreach(ParameterInfo i in ((MethodInfo)mi).GetParameters())
      {
       CodeParameterDeclarationExpression par = new CodeParameterDeclarationExpression(i.ParameterType, i.Name);
       if(i.IsOut)
        par.Direction = FieldDirection.Out;
       if(i.IsRetval)
        par.Direction = FieldDirection.Ref;
       if(i.IsIn)
        par.Direction = FieldDirection.In;
       if(i.ParameterType.IsByRef)
       {
        par.Type = new CodeTypeReference(i.ParameterType.FullName.Replace("&", ""));
        cc.Statements.Add(new CodeSnippetExpression(
         String.Format("{0} = default({1})", i.Name, par.Type.BaseType)));
       }
       cc.Parameters.Add(par);
      }
      foreach(Type p in ((MethodInfo)mi).GetGenericArguments())
       cc.TypeParameters.Add(p.Name);
      cc.ReturnType = new CodeTypeReference(((MethodInfo)mi).ReturnType);
      if(((MethodInfo)mi).ReturnType != typeof(void))
       cc.Statements.Add(new CodeMethodReturnStatement(new CodeDefaultValueExpression(cc.ReturnType)));
      ctd.Members.Add(cc);
     }
     break;
     case MemberTypes.Property:
     {
      #region ...
      CodeMemberProperty cc = new CodeMemberProperty();
      cc.Name = ((PropertyInfo)mi).Name;
      foreach(ParameterInfo i in ((PropertyInfo)mi).GetIndexParameters())
       cc.Parameters.Add(new CodeParameterDeclarationExpression(i.ParameterType, i.Name));
      cc.Type = new CodeTypeReference(((PropertyInfo)mi).PropertyType);
      cc.HasGet = ((PropertyInfo)mi).CanRead;
      cc.HasSet = ((PropertyInfo)mi).CanWrite;
      cc.GetStatements.Add(new CodeMethodReturnStatement(new CodeDefaultValueExpression(cc.Type)));

      MethodInfo[] mis = ((PropertyInfo)mi).GetAccessors();
      if(((PropertyInfo)mi).Name.Contains("."))
       cc.Attributes = (cc.Attributes & ~MemberAttributes.AccessMask);
      else if(mis.Length > 0)
       cc.Attributes = (cc.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
      else
       cc.Attributes = (cc.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private;
      ctd.Members.Add(cc);
      #endregion ...
     }
     break;

    }

   CodeMemberMethod dm = new CodeMemberMethod();
   dm.Attributes = (dm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private;
   dm.Name = "DynamicMethod";
   dm.ReturnType = new CodeTypeReference(typeof(object));
   if(String.IsNullOrWhiteSpace(dynMethodBody))
    dm.Statements.Add(new CodeSnippetStatement("\r\n  //Dynamic Method Body\r\n\r\n\r\n   return null;"));
   dm.Statements.Add(new CodeSnippetStatement(dynMethodBody));
   ctd.Members.Add(dm);

   string s;
   using(CSharpCodeProvider cp = new CSharpCodeProvider())
    using(System.IO.TextWriter tw = new System.IO.StringWriter())
    {
     CodeGeneratorOptions cgo = new CodeGeneratorOptions();
     cgo.BracingStyle = "C";
     cgo.IndentString = " ";
     cgo.BlankLinesBetweenMembers = false;
     cp.GenerateCodeFromType(ctd, tw, cgo);
     s = tw.ToString();
    }
   s = s.Insert(0, "using System;\r\nusing System.Collections;\r\nusing System.Collections.Generic;\r\n" +
                   "\r\nusing Pulsar;\r\nusing Pulsar.Shared;\r\n");
   s = s.Replace(" {\r\n", " { ");
   s = s.Replace("\r\n {", " {");
   s = s.Replace("\r\n  {", " {");
   s = s.Replace("\r\n   {", " {");
   s = s.Replace("\r\n }", " }");
   s = s.Replace("\r\n  }", " }");
   s = s.Replace("\r\n   }", " }");
   s = s.Replace("  ", " ");
   s = s.Replace("  ", " ");
   s = s.Replace("DynamicMethod() {", "DynamicMethod()\r\n {");
   s = s.Replace("\r\n set {", "set {");
   s = s.Replace("\r\n return ", " return ");
   return s;
  }

        public void Test()
        {
            string[] Names = Enum.GetNames(typeof(Voldemort.AdminRequestType));

            CodeTypeDeclaration implementation = new CodeTypeDeclaration("VoldemortAdminClient");
            implementation.IsClass = true;
            implementation.Attributes = MemberAttributes.Public;
            CodeTypeDeclaration interfaceType = new CodeTypeDeclaration("IVoldemortAdminClient");
            interfaceType.IsInterface = true;
            interfaceType.Attributes = MemberAttributes.Public;

            foreach (string Name in Names)
            {
                string[] parts = Name.Split(new string[] { "_" }, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < parts.Length; i++)
                    parts[i] = System.Globalization.CultureInfo.CurrentUICulture.TextInfo.ToTitleCase(parts[i].ToLower());
                CodeMemberMethod method = new CodeMemberMethod();
                method.Name = string.Concat(parts);
                interfaceType.Members.Add(method);

                string typeName = string.Format("Voldemort.{0}Request, Voldemort", method.Name);


                Type type = Type.GetType(typeName);

                if (null == type)
                    continue;

                PropertyInfo[] properties = type.GetProperties();

                foreach (PropertyInfo property in properties)
                {
                    CodeParameterDeclarationExpression methodParameter = new CodeParameterDeclarationExpression(property.PropertyType, property.Name);
                    method.Parameters.Add(methodParameter);
                }
            }

            CodeGeneratorOptions options = new CodeGeneratorOptions();
            options.BracingStyle = "C";
            options.BlankLinesBetweenMembers = false;

            CSharpCodeProvider csp = new CSharpCodeProvider();
            csp.GenerateCodeFromType(interfaceType, Console.Out, options);
        }