Dekorierermuster und Generika

Question

Regular-Schnittstelle:

public interface IComputation 
{ 
    void Reset(); 
    float GetValue1(); 
    float GetValue2(); 
} 

Generisches Interface:

public interface IComputation<T> : IComputation where T : IComputation 
{ 
    T Proxy { get; set; } 
} 

Jetzt für die Klassen:

public abstract class Computation<T> : IComputation<T> where T : IComputation 
{ 
    public T Proxy { get; set; }  
} 

Class 'ComputationCache' ist eine ‚eingerichtet“ Berechnung:

Um die dekorierten Berechnung zu initialisieren, habe ich versucht, die folgenden:

public ComputationCache(IComputation<T> proxy) 
{ 
    Proxy = (T) proxy; 
    proxy.Proxy = this; 
} 

..., die den folgenden Fehler "gibt:

Cannot convert source type 'ComputationCache' to target type 'T'.

Kann jemand sagen, ob es besser ist, zu verwenden:

ComputationCache<T> : IComputation where T : IComputation 

vs

ComputationCache<T> : IComputation<T> where T : IComputation 

Answer 1

Zunächst sollten Sie verwenden:

ComputationCache<T> : IComputation<T> where T : IComputation 

Wenn Sie Ihren Cache als IComputation<T> verwenden möchten, und Zugriff auf seine Proxy Eigenschaft.

Zweitens, für Ihre Fehler:

Cannot convert source type 'ComputationCache' to target type 'T'.

dies nur tun:

proxy.Proxy = (T)(IComputation)this; 

(ich weiß nicht, warum dieser Fehler gibt es seit ComputationCache ein IComputation ist, wie T.. ..)

---

EDIT: Gut Ich fand etwas, das meine Lösung falsch macht:

new ComputationCache<Computation<IComputation>>(new Computation<Computation<IComputation>>()); 

Dieser Beitrag half diesen Fehler zu Generics variance

T wird Computation<IComputation> zu finden, die nicht gleich der ComputationCache Typ ist.

Sie werden wahrscheinlich einige Probleme haben, Ihre Proxy Eigenschaft zu machen, wie Sie es geschrieben haben.

Vielleicht möchten Sie etwas wie das tun, dann:

public interface IComputation 
{ 
    IComputation Proxy { get; set; } 
    // Other stuff 
} 

public interface IComputation<T> : IComputation where T : IComputation 
{ 
    new T Proxy { get; set; } 
    // Other stuff 
} 

Aber Sie werden die beiden Eigenschaften Proxy verwalten müssen.

Ich weiß nicht, was Sie erreichen wollen, aber es ist ein Anfang.