Comment retourner sous-type de méthode de remplacement de la sous-classe en C#?

J'ai une sous-classe avec un dessus en proie à la méthode que je sais retourne toujours un sous-type particulier de le type de retour déclaré dans la classe de base. Si j'écris le code de cette façon, il ne compile pas. Depuis que, probablement, n'a pas de sens, permettez-moi de donner un exemple de code:

class BaseReturnType { }
class DerivedReturnType : BaseReturnType { }

abstract class BaseClass {
    public abstract BaseReturnType PolymorphicMethod();
}

class DerivedClass : BaseClass {
    //Compile Error: return type must be 'BaseReturnType' to match 
    //overridden member 'BaseClass.PolymorphicMethod()'
    public override DerivedReturnType PolymorphicMethod() { 
        return new DerivedReturnType(); 
    }
}

Est-il un moyen pour accomplir cette en C#? Si non, quelle est la meilleure façon d'obtenir quelque chose de similaire? Et pourquoi n'est-il pas permis? Il ne semble pas permettre à toute incohérence logique, puisque tout objet retourné à partir de la plus en proie à la méthode encore is BaseReturnType. Peut-être il ya quelque chose que je n'avais pas considéré comme bien. Ou peut-être la raison est technique ou historique.

Que fait le compilateur dire?
J'ai compris l'erreur de compilation que de l'observation.

InformationsquelleAutor recursive | 2009-01-07

c#inheritance

18

Malheureusement non, covariante des types de retour ne sont pas pris en charge en C# pour la redéfinition de méthode. (Idem contravariant types de paramètres.)

Si vous êtes à la mise en œuvre d'une interface, vous pouvez la mettre en œuvre de manière explicite à la "faiblesse" de la version et également fournir une version avec les plus contrat. Pour la simple annulation d'une classe parent, vous n'avez pas ce luxe, j'ai peur 🙁

(EDIT: Marc a solution raisonnable - même si c'est assez laid, et la méthode de masquage est généralement une mauvaise chose pour des raisons de lisibilité. Aucune infraction signifiait, Marc 😉

Je croire c'est en fait un CLR restriction, non seulement une langue, mais je pourrais très bien être faux.

(Comme une question d'histoire, de Java (le langage) avait la même restriction jusqu'à 1,5 - mais il a acquis de la covariance en même temps que des médicaments génériques.)
- Ne vous en faites pas ;-p Remarque, cependant, que c'est exactement le modèle utilisé par un grand nombre de la .NET BCL - par exemple DbConnection a CreateCommand, qui les cales à travers le "protégés abstrait" CreateDbCommand.
- Voir ce commentaire par Eric Lippert au sujet de pourquoi C# ne prennent pas en charge, stackoverflow.com/questions/1319663/...
InformationsquelleAutor Jon Skeet

Vous pourriez faire la classe générique si cela ne vous dérange:

    class BaseReturnType { }
    class DerivedReturnType : BaseReturnType { }

    abstract class BaseClass<T> where T : BaseReturnType
    {
        public abstract T PolymorphicMethod();
    }

    class DerivedClass : BaseClass<DerivedReturnType>
    {
        //Error: return type must be 'BaseReturnType' to match 
        //overridden member 'BaseClass.PolymorphicMethod()'
        public override DerivedReturnType PolymorphicMethod()
        {
            return new DerivedReturnType();
        }
    }

InformationsquelleAutor Stormenet

Vous pouvez le faire si vous introduisez une méthode supplémentaire pour remplacer (puisque vous ne pouvez pas override et new une méthode avec le même nom dans le même type):

abstract class BaseClass
{
    public BaseReturnType PolymorphicMethod()
    { return PolymorphicMethodCore();}

    protected abstract BaseReturnType PolymorphicMethodCore();
}

class DerivedClass : BaseClass
{
    protected override BaseReturnType PolymorphicMethodCore()
    { return PolymorphicMethod(); }

    public new DerivedReturnType PolymorphicMethod()
    { return new DerivedReturnType(); }
}

Maintenant, vous avez un PolymorphicMethod méthode à chaque niveau avec le type correct.

InformationsquelleAutor Marc Gravell

2

Les génériques ne sont pas nécessairement la voie à suivre. En particulier, le type(de Dérivée) n'est pas considéré comme un type(de Base).

Tout d'abord, ajoutez une nouvelle méthode de votre classe dérivée qui permet de renvoyer la valeur avec le type correct. Deuxièmement, la marque de la méthode de remplacement non-substituables et l'ont délégué à votre nouvelle méthode.

Que c'est. Vous avez résolu votre problème. Les classes enfant ne sera pas en mesure de re-développer le type parce qu'ils doivent remplacer votre nouvelle méthode.

Je m'excuse si le code n'est pas tout à fait raison; je suis habitué à VB.net.
```
abstract class C1 {
    public abstract IEnumerable<Byte> F1();
}
class C2 : C1 {
    public sealed override IEnumerable<Byte> F1() {
        Return F2();
    }
    public overridable IList<Byte> F2() {
        Return {1, 2, 3, 4};
    }
}
```
InformationsquelleAutor Craig Gidney
1
```
class BaseReturnType { }
class DerivedReturnType : BaseReturnType { }

abstract class BaseClass {
    public abstract BaseReturnType PolymorphicMethod();
}

class DerivedClass : BaseClass {
    //Error: return type must be 'BaseReturnType' to match 
    //overridden member 'BaseClass.PolymorphicMethod()'
    public override BaseReturnType PolymorphicMethod() { 
        return new DerivedReturnType(); 
    }
}
```
cela devrait fonctionner
- Je pense que l'OP veut la méthode déclarée comme DerivedReturnType, non seulement pour retrouver un.
- Je sais que c'est possible, mais il vous oblige à cast (nouveau DerivedClass()).PolymorphicMethod() si vous voulez l'utiliser comme un DerivedReturnType. Qui peut être ce que je fais, mais je n'aime pas le casting si je peux l'éviter.
- il ne peut lancer la returnval où son besoin en tant que Dérivé
- merde j'ai taper trop lent 😛
- Oui, mais que c'est douloureux, ainsi que de faire un contrôle nécessaire au moment de l'exécution, alors que nous devrions être en mesure d'expliquer que c'est valable au moment de la compilation.
InformationsquelleAutor anand

Changer votre méthode de signature sur la classe Dérivée:

 public override BaseReturnType PolymorphicMethod() 
 {
    return new DerivedReturnType();     
 }

C# ne prend pas en charge la variante de type de retour. Vous pouvez consulter ce post pour un moyen de faire cela en utilisant les Génériques...http://srtsolutions.com/blogs/billwagner/archive/2005/06/17/covaraint-return-types-in-c.aspx

Voici un exemple de l'utilisation de Génériques dans votre modèle:

public class BaseReturnType
{
}
public class DerivedReturnType : BaseReturnType
{
}

public abstract class BaseClass<T> where T : BaseReturnType
{
    public abstract T PolymorphicMethod();

}

public class DerviedClass : BaseClass<DerivedReturnType>
{
    public override DerivedReturnType PolymorphicMethod()
    {
        throw new NotImplementedException();
    }
}

InformationsquelleAutor JoshBerke

0

Il me semble que vous devez être au retour d'une interface, pas une classe de base.
- Tout d'abord ce n'est pas toujours applicable, et d'autre part il ne peut pas aider de toute façon - vous pourriez vouloir indiquer que vous êtes de retour d'une mise en œuvre de ISpecificInterface où la classe de base déclare qu'il sera de retour IGeneralInterface.
InformationsquelleAutor Greg Hurlman

Vous devez vous connecter pour publier un commentaire.