反射和自动生成类型

Question

我有一个使用“yield”return语句的单一方法。嵌套类型自动创建。使用反射和绑定标志设置为BindingFlags.DeclaredOnly，我得到这个输出：

//我的班的公共成员。
Test.FileSystemObject..ctor
Test.FileSystemObject.GetFiles（DirectoryInfo的目录）
Test.FileSystemObject.GetFiles（字符串路径）

// Auto generated nested class. 
Test.FileSystemObject+<GetFiles>d__4..ctor 
Test.FileSystemObject+<GetFiles>d__4.<>3__directory 
Test.FileSystemObject+<GetFiles>d__4.<>4__this 
Test.FileSystemObject+<GetFiles>d__4.<directories>5__7 
Test.FileSystemObject+<GetFiles>d__4.<files>5__8 
Test.FileSystemObject+<GetFiles>d__4.<FSO>5__6 
Test.FileSystemObject+<GetFiles>d__4.<i>5__9 
Test.FileSystemObject+<GetFiles>d__4.<unprocessed>5__5 
Test.FileSystemObject+<GetFiles>d__4.directory 

如何确定通过assembly.GetTypes(BindingsFlags)返回的类型是否为这样的自动生成类型？我正在寻找一种简单的方法来排除这些。

Answer 1

您可以测试，如果该类型有[CompilerGenerated]属性：

if (type.GetCustomAttribute(typeof(CompilerGeneratedAttribute), true) != null) 
{ 
    ... 
} 

或者，你可以检查，如果名称中包含的字符，不会在用户代码有效。

Answer 2

您可以在运行时编写代码，使用CSharpCodeProvider().CompileAssemblyFromSource()进行编译并在当前程序集域中注册您的类型。 只要域存在，它就会驻留在那里。从结果中调用'get'访问器会自动从编译后的程序集中调用'Load'方法到当前的应用程序域中。

您也可以使用Reflection.Emit.TypeBuilder.CreateType()来创建您的类型。此外，您可以强制将属性标志显示为编译器生成的或此处的其他属性。

var infoConstructor = typeof(CompilerGeneratedAttribute).GetConstructor(Type.EmptyTypes); 

typeBuilder.SetCustomAttribute(infoConstructor, new byte[] { }); 

这就是我今天工作​​的例子。它的目的更多是为了视觉目的，作为一个自动生成的所有类代码逆向工程的实体集合。似乎比使用文件I/O w/T4和XML输出转储更好。虽然，这可能是一个可行的选择，然后X-Doc/oxygen会自动生成HTML维基页面，并且可以在下一版本的PDB中使用和编译代码。不是英国媒体报的粉丝，留在反思。

/// <summary> 
    /// CreateType 
    /// </summary> 
    /// <param name="obj"></param> 
    /// <param name="name"></param> 
    /// <param name="properties"></param> 
    /// <param name="accessor"></param> 
    /// <param name="hasSubTypes"></param> 
    /// <returns>The newly created type of the object.</returns> 
    internal static Type CreateType(this Mirror obj, string name, IEnumerable<string> properties, string accessor = "", bool hasSubTypes = false) { 
     Type subTypeRef = null; 

     // Tested Regex @ http://regex101.com 
     const string subTypes = @"(?:<|(?:\$))([a-zA-Z_]+[0-9`]*)(?:>([a-zA-Z_]+[0-9`]*))"; 
     var match = Regex.Match(name, subTypes); 

     if (match.Success) { 
     var refType = match.Groups[1].Value; // Class reference type. 
     if (match.Groups[2].Success && !string.IsNullOrEmpty(match.Groups[2].Value)) 
      accessor = match.Groups[2].Value; // Class accessor. 

     // ReSharper disable once TailRecursiveCall 
     var enumerable = properties as IList<string> ?? properties.ToList(); 
     subTypeRef = CreateType(obj, refType, enumerable, accessor, true); 

     // Tokenize this for the actual derived class name. 
     name = name.Substring(0, name.IndexOf('+')); 
     } 

     // Check if formating of the class name matches traditional valid syntax. 
     // Assume at least 3 levels deep. 
     var toks = name.Split(new[] { '+' }, StringSplitOptions.RemoveEmptyEntries); 
     Type type = null; 

     foreach (var tok in toks.Reverse()) { 
     var o = obj.RefTypes.FirstOrDefault(t => t.Value.Name == tok); 
     if (!o.Equals(default(KeyValuePair<string, Type>))) 
      continue; 

     // Not exists. 
     var sb = new StringBuilder(); 
     sb.Append(@" 
using System; 
using System.Runtime.CompilerServices; 
using System.Collections.Generic; 
using System.Linq; 

namespace HearthMirror.TypeBuilder { 
    [CompilerGenerated] 
    public class ").Append(tok).AppendLine(@" {"); 

     if (subTypeRef != null) 
      sb.AppendLine($" public {subTypeRef.Name} {accessor}").AppendLine(" { get; set; }"); 

     sb.Append(" }\n}"); 

     var asm = RuntimeCodeCompiler.CompileCode(sb.ToString()); 
     type = asm.GetType($"{MethodBase.GetCurrentMethod().ReflectedType?.Namespace}.{tok}"); // => generated 

     // Register our type for reference. This container will handle collisions and throw if encountered. 
     obj.RefTypes.Add(tok, type); 
     } 

     return type; 
    } 

/// <summary> 
/// CompileCode 
/// </summary> 
/// <param name="code"></param> 
/// <returns></returns> 
public static Assembly CompileCode(string code) { 
    var provider = new CSharpCodeProvider(); 
    var compilerparams = new CompilerParameters { GenerateExecutable = false, GenerateInMemory = true, IncludeDebugInformation = true }; 

    foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { 
    try { 
     var location = assembly.Location; 
     if (!string.IsNullOrEmpty(location)) 
     compilerparams.ReferencedAssemblies.Add(location); 
    } catch (NotSupportedException) { 
     // this happens for dynamic assemblies, so just ignore it. 
    } 
    } 

    var results = provider.CompileAssemblyFromSource(compilerparams, code); 
    if (results.Errors.HasErrors) { 
    var errors = new StringBuilder("Compiler Errors :\r\n"); 
    foreach (CompilerError error in results.Errors) 
     errors.AppendFormat("Line {0},{1}\t: {2}\n", error.Line, error.Column, error.ErrorText); 
    throw new Exception(errors.ToString()); 
    } 
    AppDomain.CurrentDomain.Load(results.CompiledAssembly.GetName()); 
    return results.CompiledAssembly; 
}