Utilizzare DLR per eseguire il codice generato con CompileAssemblyFromSource?

Question

Seguendo questo excellent answer, mi chiedo se il DLR che utilizza la parola chiave dynamic possa consentire un modo meno dettagliato di scrivere il codice per l'assembly generato.

per esempio, può codice del citato risposta:

using (Microsoft.CSharp.CSharpCodeProvider foo = 
      new Microsoft.CSharp.CSharpCodeProvider()) 
{ 
    var res = foo.CompileAssemblyFromSource(
     new System.CodeDom.Compiler.CompilerParameters() { 
      GenerateInMemory = true 
     }, 
     "public class FooClass { public string Execute() { return \"output!\";}}" 
    ); 

    var type = res.CompiledAssembly.GetType("FooClass"); 
    var obj = Activator.CreateInstance(type); 
    var output = type.GetMethod("Execute").Invoke(obj, new object[] { }); 
} 

diventare qualcosa di simile:

using (Microsoft.CSharp.CSharpCodeProvider foo = 
      new Microsoft.CSharp.CSharpCodeProvider()) 
{ 
    var res = foo.CompileAssemblyFromSource(
     new System.CodeDom.Compiler.CompilerParameters() { 
      GenerateInMemory = true 
     }, 
     "public class FooClass { public string Execute() { return \"output!\";}}" 
    ); 

    var type = res.CompiledAssembly.GetType("FooClass"); 
    dynamic obj = Activator.CreateDynamicInstance(type); 
    var output = obj.Execute(); 
} 

Answer 1

Sì, lo puoi fare e funziona bene. Tuttavia, mentre l'uso della parola chiave dinamica è più conveniente, utilizza l'associazione tardiva ed è ancora altrettanto pericoloso, in questo senso, poiché utilizza in modo esplicito la riflessione. Se il tuo design lo consente, è ancora meglio utilizzare un'interfaccia condivisa o una classe base per l'associazione anticipata. È possibile farlo creando un tipo pubblico nell'assieme o in un terzo assembly condiviso, quindi aggiungere un riferimento a quell'assieme dal nuovo che si sta compilando in modo dinamico. Quindi, nel codice generato, puoi ereditare da quel tipo condiviso nell'assembly referenziato. Ad esempio, creare un'interfaccia:

public interface IFoo 
{ 
    string Execute(); 
} 

quindi compilare in modo dinamico l'assemblea in questo modo:

using (Microsoft.CSharp.CSharpCodeProvider foo = new Microsoft.CSharp.CSharpCodeProvider()) 
{ 
    var params = new System.CodeDom.Compiler.CompilerParameters(); 
    params.GenerateInMemory = true; 

    // Add the reference to the current assembly which defines IFoo 
    params.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location); 

    // Implement the IFoo interface in the dynamic code 
    var res = foo.CompileAssemblyFromSource(params, "public class FooClass : IFoo { public string Execute() { return \"output!\";}}"); 
    var type = res.CompiledAssembly.GetType("FooClass"); 

    // Cast the created object to IFoo 
    IFoo obj = (IFoo)Activator.CreateInstance(type); 

    // Use the object through the IFoo interface 
    obj.Execute(); 
} 

A seconda di quanto il controllo si hanno a disposizione il codice dinamico, questo può o non può essere possibile, ma quando lo è, è bello avere il controllo del tipo in fase di compilazione. Per esempio, se si è tentato di eseguire:

IFoo obj = (IFoo)Activator.CreateInstance(type); 
obj.Execcute(); 

Quella seconda linea avrebbe immediatamente non riuscire a compilare perché è scritta male, mentre con la parola chiave dinamico o riflessione, che la linea sarebbe compilare correttamente ma causerebbe un run-time eccezione. Ad esempio, il seguente errore non verrà visualizzato in fase di compilazione:

dynamic obj = Activator.CreateDynamicInstance(type); 
obj.Execcute(); 

Answer 2

Questo è uno degli scenari che la DLR è stato progettato per. È possibile utilizzarlo in questo modo per invocare membri di un tipo caricato dinamicamente evitando tutti i tipi di digitazione aggiuntivi da chiamare manualmente .GetMethod() e .Invoke().