Interface avec le paramètre générique vs Interface avec les méthodes génériques

Disons que j'ai une telle interface et la mise en œuvre concrète

public interface IMyInterface<T>
{
    T My();
}

public class MyConcrete : IMyInterface<string>
{
    public string My()
    {
        return string.Empty;
    }
}

J'ai donc créer MyConcrete mise en œuvre pour strings, je peux en avoir un de plus concret à la mise en œuvre de int. Et c'est ok. Mais disons, que je veux faire la même chose, mais avec des méthodes génériques, j'ai donc

public interface IMyInterface2
{
    T My<T>();
}

public class MyConcrete2 : IMyInterface2
{
    public string My<string>()
    {
        throw new NotImplementedException();
    }
}

Donc, j'ai le même IMyInterface2, mais qui définit le comportement générique par le biais de T My<T>(). Dans ma classe de béton je veux mettre en œuvre My comportement, mais pour le béton de type de données string. Mais le C# ne m'autorise pas à le faire.

Ma question est: pourquoi je ne peut pas le faire?
En d'autres termes, si je peux créer une mise en œuvre concrète de MyInterface<T> comme MyClass : MyInterface<string> et arrêter le caractère générique à ce point, pourquoi je ne peux pas le faire avec la méthode générique - T My<T>()?

  • Vous ne pouvez pas réduire les capacités lorsque vous héritez, vous pouvez uniquement ajouter à eux.
InformationsquelleAutor Jevgenij Nekrasov | 2013-07-11
  1. 34

    Votre méthode générique de la mise en œuvre doit être générique, donc il doit être:

    public class MyConcrete2 : IMyInterface2
{
    public T My<T>()
    {
        throw new NotImplementedException();
    }
}

    Pourquoi vous ne pouvez pas faire My<string>() ici? Parce que l'interface de contrat a besoin d'une méthode, qui peut être appelée à n'importe quel type de paramètre T et que vous avez à remplir ce contrat.

    Pourquoi vous ne pouvez pas arrêter le caractère générique de ce point de? Parce que ce serait provoquer des situations comme suit:

    Déclarations de classe:

    public interface IMyInterface2
{
    T My<T>(t value);
}

public class MyClass21 : IMyInterface2
{
    public string My<string>(string value) { return value; }
}

public class MyClass22 : IMyInterface2
{
    public int My<int>(int value) { return value; }
}

    Utilisation:

    var item1 = new MyClass21();
var item2 = new MyClass22();

//they both implement IMyInterface2, so we can put them into list
var list = new List<IMyInterface2>();
list.Add(item1);
list.Add(item2);

//iterate the list and call My method
foreach(IMyInterface2 item in list)
{
    //item is IMyInterface2, so we have My<T>() method. Choose T to be int and call with value 2:
    item.My<int>(2);

    //how would it work with item1, which has My<string> implemented?
}
    • Il doit être public T My<T>()
    • si je peux créer une mise en œuvre concrète de MyInterface<T> MyClass : MyInterface<string>, et arrêter le caractère générique de ce point, pourquoi je ne peux pas le faire avec la méthode générique - T Ma<T>()?
    • Vérifier ma mise à jour. J'ai montré une situation où votre My<string> mise en œuvre serait un échec.
    • d'accord. mais en fait, il peut utiliser de type réel dans ce cas et appel concrètes de mise en œuvre à l'aide de comportement polymorphique de l'objet.
    • Comment aimeriez-vous faire cela?
    InformationsquelleAutor MarcinJuraszek
  2. 3

    lorsque vous écrivez la Méthode Générique de la Définition est pour le maintien de l'emplacement réservé. Type réel entre en image lorsque vous appelez la méthode. donc, au lieu de cela, vous devez écrire

    public T My<T>()
{
    throw new NotImplementedException();
}

    et lorsque vous appelez la méthode, vous pouvez utiliser la chaîne de caractères qui existe.

    • Je veux arrêter de generecness que je peux faire avec interface générique, par exemple Maclasse : MyInterface<string>
    InformationsquelleAutor Rakesh
  3. 3

    Parce que votre interface déclare une méthode générique T My<T>(), mais vous la mise en œuvre ne permet pas de mettre en œuvre une fonction avec cette signature.

    À réaliser ce que vous voulez, vous devez fournir les T paramètre générique de l'interface au lieu de cela, dans votre premier exemple:

    public interface IMyInterface2<T>
{
        T My();
}

public class MyConcrete2 : IMyInterface2<string>
{
    public string My()
    {
        throw new NotImplementedException();
    }
}
    • Je sais comment obtenir ce que je veux, je veux savoir pourquoi je ne peut pas arrêter le caractère générique que je peux faire avec les interfaces
    InformationsquelleAutor Christoffer Mansfield
  4. 1

    Votre solution ne fonctionne pas pour deux raisons.

    Tout d'abord, une interface est un contrat. Lorsque vous implémentez IMyInterface2 vous garantir que vous allez mettre en œuvre une fonction nommée My qui prend un paramètre de type générique et renvoie ce type. MyConcrete2 ne pas faire cela.

    Deuxième, C# génériques ne permettent pas de tout type de paramètre de type de spécialisation. (Je ne souhaite C# appuyé.) C'est une chose commune dans les modèles C++ où votre exemple serait de compiler, mais toutes les utilisations de MyConcrete2 de ne pas compiler si ils ne le font pas appel My avec un string.

    InformationsquelleAutor IngisKahn