Modifier la signature de retour par héritage - Juste Polymorphisme

Question

demande s'il y a un moyen de faire ce qui suit:

public Interface IDataField 
{ 
    object GetValue(); 
} 

public Interface IComplexDataField : IDataField 
{ 
    object GetDefaultValue(); 
} 

public class MyBase 
{ 
    private IDataField _DataField; 

    public MyBase() 
    { 
     this._DataField = this.CreateDataField(); 
    } 

    public virtual IDataField CreateDataField() 
    { 
     return new DataField(); //Implements IDataField 
    } 

    **public virtual IDataField GetDataField()** 
    { 
     return this._DataField; 
    } 

    public void SomeMethod() 
    { 
     this.GetDataField().GetValue(); 
    } 
} 


public class MyComplexBase : MyBase 
{ 
    public override IDataField CreateDataField() 
    { 
     return new ComplexDataField(); //Implements IComplexDataField which Implements IDataField 
    } 

    **public override IComplexDataField GetDataField()** 
    { 
     return (IComplexDataField)base.GetDataField(); 
    } 

    public void SomeComplexSpecificMethod() 
    { 
     this.GetDataField().GetValue(); 
     this.GetDataField().GetDefaultValue(); 
    } 
} 

Vive Anthony

Answer 1

Ce que vous voulez est covariance des types de retour. Cela n'existe pas en C#.

Pourriez-vous faire peut-être MyBase générique:

public class MyBase<T> where T : IDataField 
{ 
    public virtual T CreateDataField() 
    { 
     ... etc ... 
    } 
} 

Vous pouvez redéclarer la méthode avec « nouvelle » et l'ombre de la méthode de classe de base. Ni est particulièrement attrayante ...

Answer 2

Le plus proche que vous pouvez obtenir en C# 3.0 est d'avoir une méthode virtual séparée (comme votre méthode CreateDataField) qui fait le travail réel et peut être débrayé, puis utilisez new déclarer à nouveau la méthode publique. à-dire dans la base:

public IDataField GetDataField() 
{ 
    return GetDataFieldImpl(); 
} 
protected virtual IDataField GetDataFieldImpl() 
{ 
    // return a basic version 
} 

et dans la sous-classe:

protected override IDataField GetDataFieldImpl() 
{ 
    // do something more fun 
} 
public new IComplexDataField GetDataField() 
{ 
    return (IComplexDataField)GetDataFieldImpl(); 
} 

Answer 3

Qu'est-ce que vous essayez de faire est appelé types de retour covariants. Ils n'existent pas dans la version actuelle C#, mais on parle de l'introduire pour la prochaine version.

Votre meilleure approche expliquée ici: covariant return types

public class MyBase<T> where T : IDataField, new() 
{ 
    public virtual T CreateDataField() 
    { 
     return new T(); 
    } 

    public virtual T GetDataField() 
    { 
     return this._DataField; 
    } 

} 

public class MyComplexBase : MyBase<ComplexDataField> 
{ 
    ... 
}