C# 接口方法的默认实现？

Question

是否可以在 C# 中定义具有默认实现的接口？ （这样我们就可以定义一个实现该接口的类，而无需实现该特定的默认方法）。

我知道扩展方法（例如在this link 中解释）。但这不是我的答案，因为具有如下的方法扩展，编译器仍然抱怨在 MyClass 中实现 MyMethod：

public interface IMyInterface
{
    string MyMethod();
}

public static class IMyInterfaceExtens
{
    public static string MyMethod(this IMyInterface someObj)
    {
        return "Default method!";
    }
}

public class MyClass: IMyInterface
{
// I want to have a default implementation of "MyMethod" 
// so that I can skip implementing it here
}

我问这个是因为（至少据我所知）在 Java 中可以做到这一点（参见here）。

PS：有一个带有某种方法的抽象基类也是不是我的答案，因为我们在C#中没有多重继承，它不同于拥有一个接口的默认实现（如果可能！）。

Answer 1

C# v8 及更高版本也允许在接口中实现具体方法。这将使您的具体实现类在您将来更改正在实现的接口时不会中断。

所以现在这样的事情是可能的：

interface IA
{
    void NotImplementedMethod();
    void M() { WriteLine("IA.M"); } //method definition present in the interface
}

请参考这个 GitHub issue # 288。此外，Mads Torgersen 在this 第 9 频道视频中详细讨论了此功能。

MS Docs - https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/default-interface-methods

Answer 2

在 C# 8.0 中是可能的。您可以添加具有默认实现的方法。您必须将目标框架版本更改为最新版本才能使用此功能。

Answer 3

简答：

不，你不能在接口中编写方法的实现。

说明：

接口就像契约一样，所以从它继承的类型必须定义实现，如果你有一个场景你需要一个默认实现的方法，那么你可以让你的类abstract并定义默认实现对于你想要的方法。

例如：

public abstract class MyType
{
    public string MyMethod()
    {
      // some implementation
    }

    public abstract string SomeMethodWhichDerivedTypeWillImplement();
}

现在在 Dervied 类中：

public class DerivedType : MyType
{
  // now use the default implemented method here
}

更新（C# 8 将对此提供支持）：

C# 8 will allow to have default implementation in interfaces

Answer 4

作为一个新的 C# 程序员，我正在阅读这个主题并想知道下面的代码示例是否有帮助（我什至不知道这是否是正确的方法）。对我来说，它允许我在接口后面编写默认行为。请注意，我使用泛型类型规范来定义（抽象）类。

namespace InterfaceExample
{
    public interface IDef
    {
        void FDef();
    }

    public interface IImp
    {
        void FImp();
    }

    public class AbstractImplementation<T> where T : IImp
    {
        // This class implements default behavior for interface IDef
        public void FAbs(IImp implementation)
        {
            implementation.FImp();
        }
    }

    public class MyImplementation : AbstractImplementation<MyImplementation>, IImp, IDef
    {
        public void FDef()
        {
            FAbs(this);
        }
        public void FImp()
        {
            // Called by AbstractImplementation
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyImplementation MyInstance = new MyImplementation();

           MyInstance.FDef();
        }
    }
}

Answer 5

不是直接的，但是你可以为一个接口定义一个扩展方法，然后像这样实现它

public interface ITestUser
{
    int id { get; set; }
    string firstName { get; set; }
    string lastName { get; set; }

    string FormattedName();
}

static class ITestUserHelpers
{
    public static string FormattedNameDefault(this ITestUser user)
    {
        return user.lastName + ", " + user.firstName;
    }
}

public class TestUser : ITestUser
{
    public int id { get; set; }
    public string firstName { get; set; }
    public string lastName { get; set; }

    public string FormattedName()
    {
        return this.FormattedNameDefault();
    }
}

编辑* 扩展方法和您正在实现的方法的名称必须不同，这一点很重要，否则您可能会遇到 stackoverflow。

Answer 6

我开发游戏，所以我经常希望接口的所有实现都具有通用功能，但同时允许每个实现做自己的事情，就像子类的虚拟/覆盖方法会起作用一样。

这就是我的做法：

public class Example
{
    void Start()
    {
        WallE wallE = new WallE();
        Robocop robocop = new Robocop();

        // Calling Move() (from IRobotHelper)
        // First it will execute the shared functionality, as specified in IRobotHelper
        // Then it will execute any implementation-specific functionality,
        // depending on which class called it. In this case, WallE's OnMove().
        wallE.Move(1);

        // Now if we call the same Move function on a different implementation of IRobot
        // It will again begin by executing the shared functionality, as specified in IRobotHlper's Move function
        // And then it will proceed to executing Robocop's OnMove(), for Robocop-specific functionality.
        robocop.Move(1);

        // The whole concept is similar to inheritence, but for interfaces.
        // This structure offers an - admittedly dirty - way of having some of the benefits of a multiple inheritence scheme in C#, using interfaces.
    }

}

public interface IRobot
{
    // Fields
    float speed { get; }
    float position { get; set; }

    // Implementation specific functions.
    // Similar to an override function.
    void OnMove(float direction);
}

public static class IRobotHelper
{
    // Common code for all IRobot implementations. 
    // Similar to the body of a virtual function, only it always gets called.
    public static void Move(this IRobot iRobot, float direction)
    {
        // All robots move based on their speed.
        iRobot.position += iRobot.speed * direction;

        // Call the ImplementationSpecific function
        iRobot.OnMove(direction);
    }
}

// Pro-Guns robot.
public class Robocop : IRobot
{
    public float position { get; set; }

    public float speed { get; set;}

    private void Shoot(float direction) { }

    // Robocop also shoots when he moves
    public void OnMove(float direction)
    {
        Shoot(direction);
    }
}

// Hippie robot.
public class WallE : IRobot
{
    public float position { get; set; }

    public float speed { get; set; }

    // Wall-E is happy just moving around
    public void OnMove(float direction) { }
}