types spécifiques dans la mise en œuvre de classe lors de l'utilisation d'une interface

Question

Prenons l'exemple de code suivant:

interface IData { 
    int Count(); 
} 

interface IOperations { 
    IData Foo(); 
    double Bar(IData a); 
} 

class Data1 : IData { 
    public int Count() { return 37; } 
    public double SomethingElse { get; set; } 
} 

class Ops1 : IOperations 
{ 
    public Data1 Foo() { return new Data1(); } // want to return specific type here 
    public double Bar(Data1 x) { ... } // want to get specific type here 
            // and not use operator as everywhere 
} 

// more definitions of classes Data2, Ops2, Data3, Ops3, ... 

// some code: 
Ops1 a = new Ops1(); 
Data1 data = a.Foo(); // want Data1 here not IData! 
double x = a.Bar(data); 

je pouvais bien sûr il suffit d'utiliser public IData Foo() { return new Data1(); }:

// some code 
Ops1 a = new Ops1(); 
Data1 data = a.Foo() as Data1; 

mais avec as partout, le code devient rapidement déroutant.

Je me demande s'il y a un bon modèle de conception pour y parvenir d'une manière claire et forte?

Edit: Est est important, que Ops et données partagent une classe de base commune:

List<IOperations> ops = ...; 
List<IData> data = ...; 
List<double> result = ...; 
for(int i=0; i<ops.Count; i++) 
    result[i] = ops[i].Bar(data[i]); 

Donc, pour le cas avec le type de retour, je me demande que cela est interdit, parce que je satisfaire à l'exigence de l'interface. Dans le cas des paramètres, il existe probablement une couche supplémentaire (modèle) nécessaire.

Answer 1

Vous pouvez utiliser les médicaments génériques:

interface IOperations<T> where T: IData 
{ 
    T Foo(); 
    double Bar(T a); 
} 

class Ops1 : IOperations<Data1> 
{ 
    public Data1 Foo() { return new Data1(); } 
    public double Bar(Data1 x) { /* ... */ } 
}