Qual è il modo migliore per attuare un proxy dinamico in C #?

Question

Ho una necessità di creare un proxy dinamico in C #. Voglio questa classe per avvolgere un'altra classe, e assumere interfaccia pubblica di essa la, l'inoltro delle chiamate per quelle funzioni:

class MyRootClass
{
    public virtual void Foo()
    {
        Console.Out.WriteLine("Foo!");
    }

}

interface ISecondaryInterface
{
    void Bar();
}

class Wrapper<T> : ISecondaryInterface where T: MyRootClass
{
    public Wrapper(T otherObj)
    {
    }

    public void Bar()
    {
        Console.Out.WriteLine("Bar!");
    }
}

Ecco come voglio usarlo:

Wrapper<MyRootClass> wrappedObj = new Wrapper<MyRootClass>(new MyRootClass());
wrappedObj.Bar();
wrappedObj.Foo();

produrre:

Bar!
Foo!

Tutte le idee?

Qual è il modo più semplice per farlo?

Qual è il modo migliore per fare questo?

Grazie mille.

Aggiorna

Ho provato dopo la raccomandazione di Wernight e implementare questo utilizzando C # 4.0 proxy dinamici. Purtroppo, sono ancora bloccati. Il punto di delega è di mimare l'altra interfaccia che è (normalmente, di solito) previsto. Utilizzando DynamicObject mi impone di cambiare tutti i clienti di questo di usare 'dinamica' invece di 'ISecondaryInterface'.

C'è un modo per ottenere un oggetto proxy, in modo tale che quando si avvolge una A, si pubblicizza (staticamente?) Che supporta l'interfaccia di A; e quando si avvolge un B, si pubblicizza che è l'interfaccia supporti di B?

UPDATE 2

Ad esempio:

class MySecretProxy : DynamicObject, ISecondaryInterface
{
    public override void TryInvokeMember(...) { .. }

    // no declaration of Bar -- let it be handled by TryInvokeMember
 }

Answer 1

.NET 4 DynamicObject può aiutare a raggiungere questa meta.

In precedenza framework .NET può utilizzare:

• Aspect #
• Encase AOP
• Spring.NET
• Aspect.NET
• AspectDNG
• Dinamico Proxy
• Componi *
• Loom.NET
• PostSharp

Ognuno di questi quadri fanno uso di un numero Tecniche per l'iniezione di codice sia prima che dopo l'esecuzione di un metodo. Questi rientrano generalmente in 4 categorie.

• iniezione MSIL - Qui abbiamo iniettare codice MSIL nel corpo del metodo essendo eseguito. (Post sharp)
• iniezione dinamica Runtime - Utilizzando tecniche quale la riflessione di noi richiamare i metodi in modo dinamico.
• Tipo iniezione costruttore - Relativo a iniezione runtime, creiamo un tipo sulla base di il tipo che vogliamo richieste proxy e poi maresciallo attraverso questo tipo. (Dynamic Proxy)
• iniezione Container - Richieste passano attraverso un contenitore che invoca il codice prima e dopo il nostro metodo in esecuzione.

Vedere la articolo completo .

So che Castello Progetto 's Dinamico Proxy è spesso usato (come in Moq solo per citarne un grande progetto).

---

Rispondi AGGIORNAMENTO

Quello che hai scritto non verrà compilato. Dinamico i proxy sono runtime codice generato, quindi dovrete creare un'istanza concreta della classe si sta proxying un modo o nell'altro. Può essere che si sta cercando di fare AOP (orientata agli aspetti di programmazione).

class MySecretProxy<T> : DynamicObject, T where T : new()
{
    private T _instance = new T();

    public override void TryInvokeMember(...) { ... }
}

MySecretProxy<Bar> bar;

Answer 2

Hai guardato DynamicProxy del progetto Castle? Esso può fornire quello che stai in ultima analisi, cercando di raggiungere. Vedere http://www.castleproject.org/dynamicproxy/index.html

E 'anche open source in modo si potrebbe anche sborsare se necessario.

Answer 3

È possibile farlo con RealProxy se il tipo di destinazione è un interfaccia o deriva da MarshalByRefObject.

Answer 4

Si consiglia di guardare a Linfu che contiene un meccanismo dinamico proxy.

Answer 5

So che i proxy che utilizzato da NHibernate per caricamento pigro

Castello

Linfu

Primavera ByteCode