Question

我刚学习C＃扩展方法，并想知道我是否可以使用它来为接口提供默认实现。

说：

public interface Animal {
    string MakeSound();
}

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

然后

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

public class Porcupine : Animal {
}

最后：

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

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

我希望豪猪和其他未明确实现MakeSound的动物使用返回空字符串的默认扩展方法，但是狗和任何具有显式实现的动物都会返回自己的实现比如“巴克”。

所以我的问题：这可行吗？ 2.如果没有，是否有其他方法可以实现接口的默认行为？

抽象类而不是接口不是一个选项，因为C＃不支持多重继承，而我的类继承了另一个类的行为。

Answer 1

我通常会推荐一个基类，但是，如果这样做了，你可以这样做：

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 { }

即使不是IAnimal，这也会使每个INoisyAnimal 看起来像<{1}}。例如：

IAnimal dog = new Dog(); IAnimal porcupine = new Porcupine(); Console.WriteLine(dog.MakeSound()); // bark Console.WriteLine(porcupine.MakeSound()); // Unknown Noise

但是，这仍然不是界面的实际实现。请注意，尽管出现了

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

另一个选择可能是在需要新功能时创建一个包装来扩展基类：

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); } }

然后，您可以根据需要从任何INoisyAnimal创建IAnimal：

INoisyAnimal dog = new Dog(); INoisyAnimal porcupine = new Porcupine().Noisy(); Console.WriteLine(dog.MakeSound()); // bark Console.WriteLine(porcupine.MakeSound()); // Unknown Noise

你也可以使包装器通用（例如NoisyAnimal<T> where T : IAnimal, new）并完全摆脱扩展方法。根据您的实际使用情况，这可能比以前的选项更好。

Answer 2

我不确切地知道你的实际情况是什么，或者你只是在试验，但如果只有一些动物吵闹，那么Interface segregation可能是个好例子。

例如：

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

public class Porcupine : IAnimal
{
}

然后，您只会调用MakeSound或实际上有噪音的对象。

Answer 3

这样的事情怎么样？它允许你避免使用基类，你可以做你想到的，对吧？

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 ""; } }
}

C＃ - 使用扩展方法提供默认接口实现

3 个答案: