Remplacer la méthode de la mise en œuvre déclarées dans une interface

J'ai une interface avec plusieurs méthodes.

interface IMyInterface
{
    //...
    void OnItemClicked()
    //...
}

Et une mise en œuvre

class MyClass : IMyInterface
{
    //Other methods
    public void OnItemClicked(){ /*...*/ } 
}

Maintenant, je veux avoir une classe qui se comporte comme MyClass à l'exception de OnItemClicked(), je veux quelques modifications pour cette méthode.

J'ai pensé à hériter d'un remplacement mais je ne veux pas changer de MyClass (comme: public virtual vide OnItemClicked()...) parce que ce n'est pas ma mise en œuvre,

Je ne veux pas mettre en œuvre IMyInterface à nouveau, car le OnItemClicked() est la seule partie de MyClass à modifier.

Ai-je une autre façon de faire?

Créer une classe intermédiaire entre ces deux.

OriginalL'auteur Miklós Balogh | 2012-09-07

c#inheritance interface

Puisque vous êtes à la mise en œuvre d'une interface, le polymorphisme est probablement quelque chose que vous souhaitez conserver. Il est impossible de remplacer la méthode sans portées la classe de base avec un virtuel, de sorte que vous devez utiliser de nouveau au lieu de virtuel comme Tigran écrit.

Cela signifie que le fait d'écrire ce genre de code, mais seulement la version de base de la méthode doit être exécutée:

List<MyClass> aList = new List<MyClass>();
aList.Add(new MyClass());
aList.Add(new MyNewClass());
foreach (MyClass anItem in aList)
    anItem.OnItemClicked();

Pour exécuter le bon code, vous devez écrire laid code comme ceci:

List<MyClass> aList = new List<MyClass>();
aList.Add(new MyClass());
aList.Add(new MyNewClass());
foreach (MyClass anItem in aList)
{
    MyNewClass castItem = anItem as MyNewClass;
    if (castItem != null)
        castItem.OnItemClicked();
    else
        anItem.OnItemClicked();
}

De toute façon il y a un moyen d'avoir de vos cours d'exécution de la méthode lorsqu'ils sont affectés à des variables déclarées comme IMyInterface. Le chemin à parcourir est explicitement de mettre en œuvre la partie de l'interface que vous souhaitez remplacer, dans votre cas, la OnItemClicked méthode. Le code est le suivant:

public class MyNewClass : MyClass, IMyInterface //you MUST explicitly say that your class implements the interface, even if it's derived from MyClass
{
    public new void OnItemClicked() //NEW keyword here you have the overridden stuff
    { 
        /*...*/ 
    } 

    void IMyInterface.OnItemClicked() //No need for public here (all interfaces's methods must be public)
    { 
        this.OnItemClicked(); 
    } 
}

De cette façon:

 MyClass cl = new MyNewClass(); 
 cl.OnItemClicked();

exécute la méthode de base

 MyNewClass cl = new MyNewClass(); 
 cl.OnItemClicked();

exécute la méthode de la classe dérivée

 IMyInterface cl = new MyNewClass(); 
 cl.OnItemClicked();

exécute la méthode de la classe dérivée et est lié à l'exécution. Cela signifie que vous pouvez écrire le code de mon premier exemple de ce genre et ont le droit de méthodes d'exécution:

List<IMyInterface> aList = new List<IMyInterface>();
aList.Add(new MyClass());
aList.Add(new MyNewClass());
foreach (IMyInterface anItem in aList)
    anItem.OnItemClicked();

OriginalL'auteur Francesco Baruchelli

5

que vous pouvez tirer d' MyClass
```
public class MyNewClass : MyClass
{
    public new void OnItemClicked(){ /*...*/ } //NEW keyword
}
```
La seule chose, faites attention à ce que vous n'avez pas supprot polymorphisme.

Pour être plus clair:
```
     MyClass cl = new MyNewClass(); 
     cl. MyMethod();
```
cela appel MyClass méthode, même si la réel type d'objet est MyNewType.
Pour être en mesure d'appeler ce que nous voulons, nous devons esplicitly définir le type
```
     MyNewClass cl = new MyNewClass(); 
     cl. MyMethod(); //WILL CALL METHOD WE WANT
```
Il a mentionné dans son post: j'ai pensé à hériter d'un remplacement mais je ne veux pas changer de MyClass (comme: public virtual void OnItemClicked()...) parce que ce n'est pas ma mise en œuvre,
enfait il n'a pas. Où voyez-vous le code qui modifie MyClass mise en œuvre ?
Mon mauvais Tigran. J'ai jeté un coup d'oeil sur le code et pensé que vous aviez "remplacer" au lieu de "nouveau". Question: quand MyNewClass est utilisé comme un exemple de "IMyInterface", la méthode qui sera appelée?
Regarde dans mon post exemple. Il n'y a pas de polymorphisme le support de cette fonctionnalité.
Je suppose que les interfaces sont polymorphisme. Du sens. Je suppose que ça dépend de son utilisation maintenant.

OriginalL'auteur Tigran

La façon la plus simple est de créer une nouvelle classe qui imite "est-un" à l'aide "a-un":

public interface IMyInterface
{
    void OnItemClicked();
    void OnItemHover();
    void OnItemDoubleClicked();
}

public class MyNewClass : IMyInterface
{
    private IMyInterface _target;

    public MyNewClass(IMyInterface target)
    {
        _target = target;
    }

    public void OnItemClicked()
    {
        //custom functionality
    }

    public void OnItemHover()
    {
        _target.OnItemHover();
    }

    public void OnItemDoubleClicked()
    {
        _target.OnItemDoubleClicked();
    }
}

OK, mais vous ne pouvez pas assigner à une variable MyClass
Oui, mais dans la réponse, où vous pouvez l'affecter à un MyClass variable et vous avez appelé OnItemClicked (), à l'exécution de la mauvaise fonction. J'ai été en supposant que l'interface est la partie importante, sinon ce ne serait pas fonctionner correctement, mais ni l'autre réponse.
Vous avez raison, en fait, je préfère votre réponse à l'autre, j'étais simplement en indiquant pourquoi je préfère ma réponse à la vôtre 🙂

OriginalL'auteur armen.shimoon

1

profil d'emploi pont http://en.wikipedia.org/wiki/Bridge_pattern

liens disparaissent. Garder ce genre de réponses que les commentaires, merci

OriginalL'auteur burning_LEGION

Vous devez vous connecter pour publier un commentaire.