Plusieurs classes qui mettent en œuvre une interface générique dans un seul tableau

Question

que j'ai une interface générique qui stocke une valeur qui est tapé par le paramètre générique:

public interface IFoo<TValue> 
{ 
    TValue SomeValue { get; set; } 
} 

Puis j'ai deux classes, StringFoo et DoubleFoo dont SomeValues sont string s et double s respectivement:

public class StringFoo : IFoo<string> 
{ 
    string SomeValue { get; set; } 
} 

public class DoubleFoo : IFoo<double> 
{ 
    double SomeValue { get; set; } 
} 

je décide maintenant que je veux un tableau qui peut contenir les deux StringFoo s et DoubleFoo s:

var foos = IFoo<object>[] { 
    new StringFoo { SomeValue = "a value" }, 
    new DoubleFoo { SomeValue = 123456789 } 
} 

Je pense que, puisque les deux string et double sont sous-classes de object, ils seraient tous deux autorisés dans ce tableau. Cependant, je pensais mal.

Alors, j'ai essayé d'utiliser covariance:

public interface IFoo<out TValue> 

Mais, puisque l'interface contient les deux setters et getters, je ne peux pas le faire.

Donc, peut deux classes qui implémentent une interface générique dans un tableau?

Answer 1

Le problème peut être résolu de la manière dont la classe Bar est implémentée (mauvais exemple fourni). Le problème est que chaque fois que l'on essaie d'utiliser une interface générique ou une classe, l'implémentation d'un code d'interface générique peut compiler (fournir des distributions droites) mais le code lancera InvalidCastException pendant l'exécution.

public interface IFoo<TValue> 
{ 
    TValue SomeValue { get; set; } 
} 

public class StringFoo : IFoo<string> 
{ 
    public string SomeValue { get; set; } 
} 

public class DoubleFoo : IFoo<double> 
{ 
    public double SomeValue { get; set; } 
} 

public class Foo<TValue> : IFoo<TValue> 
{ 
    public TValue SomeValue { get; set; } 
} 

public abstract class Bar 
{ 

} 

public class Bar<TValue> : Bar, IFoo<TValue> 
{ 
    public TValue SomeValue { get; set; } 
} 

public static class Verify 
{ 
    public static void QuestionArray() 
    { 
     var foos = new IFoo<object>[] 
     { 
      (IFoo<object>) new StringFoo { SomeValue = "a value" }, 
      (IFoo<object>) new DoubleFoo { SomeValue = 123456789 } 
     }; 
    } 

    public static void BadAnswerArray() 
    { 
     var foo = new IFoo<object>[] 
     { 
      (IFoo<object>) new Foo<string>(), 
      new Foo<object>(), 
     }; 
    } 

    public static void GoodAnswer() 
    { 
     var foo = new Bar[] 
     { 
      new Bar<string>(), 
      new Bar<object>(), 
      new Bar<double>() 
     }; 
    } 
} 

Et pour vérifier la solution, on peut exécuter des tests où seul GoodAnswerTest passera:

public class GenericsInArrayTests 
{ 
    [Fact] 
    public void QuestionArrayTest() 
    { 
     Verify.QuestionArray(); 
    } 

    [Fact] 
    public void BadAnswerTest() 
    { 
     Verify.BadAnswerArray(); 
    } 

    [Fact] 
    public void GoodAnswerTest() 
    { 
     Verify.GoodAnswer(); 
    } 
}