Em C #, alguém pode fazer:

MyClass myInstance        = new MyClass();
dynamic mydynamicInstance = myInstance;

E então, invoque um método, como:

//This method takes a MyClass argument and does something.
Caller.InvokeMethod(myDynamicInstance);

Agora, isso levará à determinação do tipo myInstance no tempo de execução e, se for válido, oCaller.InvokeMethod será chamado normalmente.

Agora, minha pergunta é se isso é considerado uma má prática para usardynamic, especialmente nos seguintes casos:

1)InvokeMethod instancia outra instância do tipo myDynamicInstance, usando reflexão dentro.

2) Existe uma classe base abstrataMyBaseClass e várias subclasses dele, incluindoMyBaseClass. Se tivermos vários métodos sobrecarregados deInvokeMethod para todas essas classes derivadas, poderíamos usá-lo para permitir em tempo de execução a determinação do tipo e, em seguida, a chamada adequada via sobrecarga de método (ou ligação tardia na chamada de um método dessa classe) ?:

public abstract class MyBaseClass         {/*...*/}
public class MyClass        : MyBaseClass {/*...*/}
public class MyAnotherClass : MyBaseClass {/*...*/}

MyBaseClass myBaseClassRef = new MyClass();
dynamic myDynamicInstance  = myBaseClassRef;

Caller.InvokeMethod(myDynamicInstance);