如何在C#中将外部.cs文件转换为Type对象以调用Type.GetMethods()？

Hey there! Let's break down how to solve this problem. Reading a standalone .cs file as text and turning it into a usable Type object (so you can call GetMethods() and other reflection methods) requires dynamic compilation—since the .cs file is just source code, not compiled IL. Here's a step-by-step solution:

Why Your Previous Approach Failed #

TypeDescriptor isn't meant for this job. It's designed to handle component metadata and type conversion for existing types/objects, not to compile raw source code into a usable Type. You need to compile the source code first, then load the resulting assembly to access the type.

Step-by-Step Solution #

You can use the CSharpCodeProvider (or Roslyn for more advanced scenarios) to compile the source code in-memory, then retrieve the Type from the compiled assembly.

1. Required Dependencies #

• For .NET Framework: The necessary namespaces are built-in (System.CodeDom.Compiler, Microsoft.CSharp, System.Reflection).
• For .NET Core/.NET 5+: Install the Microsoft.CodeDom.Providers.DotNetCompilerPlatform NuGet package first.

2. Full Code Example #

using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Reflection;
using Microsoft.CSharp;

public class CsToTypeConverter
{
    public Type ConvertCsFileToType(string csFilePath, string fullTypeName)
    {
        // Read the raw source code from the .cs file
        string sourceCode = File.ReadAllText(csFilePath);

        // Configure compilation settings
        var compilerParams = new CompilerParameters
        {
            GenerateInMemory = true, // Compile directly into memory (no physical DLL)
            TreatWarningsAsErrors = false // Optional: Set to true for stricter checks
        };

        // Add references to assemblies your .cs file depends on
        compilerParams.ReferencedAssemblies.AddRange(new[]
        {
            "System.dll",
            "System.Core.dll",
            "Microsoft.CSharp.dll"
            // Add any other assemblies your code uses (e.g., "Newtonsoft.Json.dll")
        });

        // Compile the source code
        using (var codeProvider = new CSharpCodeProvider())
        {
            CompilerResults compileResults = codeProvider.CompileAssemblyFromSource(compilerParams, sourceCode);

            // Handle compilation errors
            if (compileResults.Errors.HasErrors)
            {
                var errorMessages = new System.Text.StringBuilder();
                foreach (CompilerError error in compileResults.Errors)
                {
                    errorMessages.AppendLine($"Compilation Error: {error.ErrorText} (Line {error.Line})");
                }
                throw new InvalidOperationException($"Failed to compile code:\n{errorMessages}");
            }

            // Retrieve the compiled assembly and get the target Type
            Assembly compiledAssembly = compileResults.CompiledAssembly;
            Type targetType = compiledAssembly.GetType(fullTypeName);

            if (targetType == null)
            {
                throw new ArgumentException($"Could not find type '{fullTypeName}' in the compiled assembly.");
            }

            return targetType;
        }
    }
}

// Usage:
// var converter = new CsToTypeConverter();
// Type externalType = converter.ConvertCsFileToType(@"C:\YourPath\ExternalClass.cs", "YourNamespace.ExternalClass");
// MethodInfo[] methods = externalType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
// // Now you can inspect or invoke the methods

3. Key Notes #

• Full Qualified Type Name: When calling GetType(), you must use the full type name (namespace + class name) from the .cs file. If the class isn't in a namespace, just use the class name.
• Referenced Assemblies: Make sure to add all assemblies that the external .cs file references. If your code uses third-party libraries, include their DLL paths in ReferencedAssemblies.
• In-Memory Compilation: Setting GenerateInMemory = true avoids creating physical DLL files, which is ideal for this use case.

Advanced Option: Using Roslyn #

If you need more control over the compilation process (like supporting newer C# features), you can use the Roslyn API (NuGet package Microsoft.CodeAnalysis.CSharp). Here's a quick snippet:

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using System.IO;
using System.Reflection;

public static Type CompileWithRoslyn(string csFilePath, string fullTypeName)
{
    string sourceCode = File.ReadAllText(csFilePath);

    // Create syntax tree from source code
    SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(sourceCode);

    // Set up compilation options
    var compilation = CSharpCompilation.Create(
        "DynamicAssembly",
        syntaxTrees: new[] { syntaxTree },
        references: new[]
        {
            MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
            MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location)
            // Add other necessary references
        },
        options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));

    // Compile into memory
    using (var ms = new System.IO.MemoryStream())
    {
        EmitResult result = compilation.Emit(ms);

        if (!result.Success)
        {
            var errors = result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error);
            throw new InvalidOperationException($"Compilation failed: {string.Join("\n", errors.Select(e => e.GetMessage()))}");
        }

        ms.Seek(0, System.IO.SeekOrigin.Begin);
        Assembly assembly = Assembly.Load(ms.ToArray());
        return assembly.GetType(fullTypeName);
    }
}

内容的提问来源于stack exchange，提问作者Kevin Jensen Petersen