C # - en utilisant des méthodes d'extension pour fournir une implémentation d'interface par défaut

Je suis en train d'apprendre le C# les méthodes d'extension, et je me demandais si je peux utiliser pour fournir une implémentation par défaut d'une interface.

Dire:

public interface Animal {
    string MakeSound();
}

public static string MakeSound(this Animal) {
    return "";
}

Puis

public class Dog : Animal {
    string MakeSound() {
        return "Bark";
    }
}

public class Porcupine : Animal {
}

Et dernier:

Animal dog = new Dog();
Animal porcupine = new Porcupine();

Print(dog.MakeSound());
Print(porcupine.MakeSound());

J'aimerais le porc-épic et tous les autres animaux qui n'ont pas explicitement mis en œuvre MakeSound utiliser l'extension par défaut méthode qui renvoie une chaîne vide, mais le chien et tout animal qui possède une mise en œuvre explicite de retour de sa propre mise en œuvre tels que "l'Écorce".

Donc mes questions:
1. Est-ce faisable?
2. Si non, est-il un autre moyen pour mettre en œuvre le comportement par défaut d'une interface?

Classe abstraite au lieu de l'interface n'est pas une option parce que le C# ne supporte pas l'héritage multiple et de mes classes héritent d'comportement d'une autre classe.

source d'informationauteur tbkn23

  1. 11

    J'avais recommandent généralement d'une classe de base, cependant, si vous pouvez faire quelque chose comme ceci:

    public interface IAnimal { }

public interface INoisyAnimal : IAnimal {
    string MakeSound();
}

public static class AnimalExtensions { 
    public static string MakeSound(this IAnimal someAnimal) {
        if (someAnimal is INoisyAnimal) {
            return (someAnimal as INoisyAnimal).MakeSound();
        }
        else {
            return "Unknown Noise";
        }
    }
}

public class Dog : INoisyAnimal {
    public string MakeSound() {
        return "Bark";
    }
}

public class Porcupine : IAnimal { }

    Cela rend chaque IAnimal look comme un INoisyAnimal même si elle n'est pas vraiment un. Par exemple:

    IAnimal dog = new Dog();
IAnimal porcupine = new Porcupine();

Console.WriteLine(dog.MakeSound());            //bark
Console.WriteLine(porcupine.MakeSound());      //Unknown Noise

    Cependant, ce n'est toujours pas une réelle mise en œuvre de l'interface. Notez que malgré les apparences

    Console.WriteLine(porcupine is INoisyAnimal);  //false

    Une autre option pourrait être de créer un wrapper pour étendre votre classe de base lorsqu'une nouvelle fonctionnalité est nécessaire:

    public class NoisyAnimalWrapper : INoisyAnimal {
    private readonly IAnimal animal;
    public NoisyAnimalWrapper(IAnimal animal) {
        this.animal = animal;
    }

    public string MakeSound() {
        return "Unknown Noise";
    }
}

public static class AnimalExtensions { 
    public static INoisyAnimal Noisy(this IAnimal someAnimal) {
        return someAnimal as INoisyAnimal ?? 
                new NoisyAnimalWrapper(someAnimal);
    }
}

    Ensuite, vous pouvez créer un INoisyAnimal de toute IAnimal quand vous en avez besoin:

    INoisyAnimal dog = new Dog();
INoisyAnimal porcupine = new Porcupine().Noisy();

Console.WriteLine(dog.MakeSound());            //bark
Console.WriteLine(porcupine.MakeSound());      //Unknown Noise

    Vous pouvez aussi faire le wrapper générique (par exemple,NoisyAnimal<T> where T : IAnimal, new) et de se débarrasser de la méthode d'extension tout à fait. En fonction de votre utilisation réelle le cas, il peut être préférable à l'option précédente.

  2. 2

    Je ne sais pas exactement ce qui est votre cas réel ou si vous êtes juste à expérimenter, mais, si seuls certains animaux sont bruyants, alors il pourrait une bonne affaire pour Interface segregation.

    Par exemple:

    public class Dog : IAnimal, INoisy
{
    public string MakeSound()
    {
        return "Bark";
    }
}

public class Porcupine : IAnimal
{
}

    Ensuite, vous pouvez seulement appeler MakeSound ou des objets qui sont effectivement bruyant.

  3. 0

    Comment quelque chose comme cela? Il vous permet de vous éviter d'avoir une classe de base, et vous pouvez faire ce que vous aviez à l'esprit, non?

    public interface Animal
{
    //Fields
    string voice { get; }
}

public static class AnimalHelper
{
    //Called for any Animal
    public static string MakeSound(this Animal animal)
    {
        //Common code for all of them, value based on their voice
        return animal.voice;
    }
}

public class Dog : Animal
{
    public string voice { get { return "Woof!"; } }
}

public class Purcupine : Animal
{
    public string voice { get { return ""; } }
}