C# 如何在两个接口之间创建通用方法

在哪里实现MyMethod（）最好？我有两个接口使用不同的方法实现相同的方法。所以我想了想，似乎我只能在那个课堂程序中使用静态方法来让大家开心。有什么建议或更好的解决方案吗

添加另一个接口作为这两个接口的基本接口

class Program
{
    interface I1
    {
        void F1();
    }

    interface I2
    {
        void F2();
    } //2 interfaces

    abstract class b1 : I1
    {
        abstract public void F1();
    }

    private class d1 : b1
    {
        public override void F1()
        {
            Console.Write("Inside D1:b1.F1");

            //I want to call my method() here
            MyMethod();
        }
    }

    private class d2 : b1
    {
        public override void F1()
        {
            Console.Write("Inside d2:b1.F1");

            //I want to call my method() here
            MyMethod();
        }
    }

   private class ImeplementI2_1 : I2
    {
        public void F2()
        {
            //Implementation
            Console.Write("Inside b_1:b_1.F2");

            //I want to call my method() here
            MyMethod();
        }
    }

   private class ImeplementI2_2 : I2
   {
       public void F2()
       {
           //Implementation
           Console.Write("Inside b_1:b_1.F2");

           //I want to call my method() here
           MyMethod();
       }
   }

    void MyMethod()
    {
        Console.WriteLine("Printmenow");
    }

    static void Main(string[] args)
    {
        I1 interface1;

        if (args.Length > 0)
        {
            interface1 = new d1();

        }
        else
        {
            interface1 = new d2();
        }

        interface1.F1();
        //I want to call my method() here
        MyMethod();

    }

}

如果您想访问程序类的MyMethod，可以做两件事：

1） 只需将其声明为静态

---

2） 将其作为委托传递并在类中调用

添加另一个接口作为这两个类的基本接口

class Program
{
    interface I1
    {
        void F1();
    }

    interface I2
    {
        void F2();
    } //2 interfaces

    abstract class b1 : I1
    {
        abstract public void F1();
    }

    private class d1 : b1
    {
        public override void F1()
        {
            Console.Write("Inside D1:b1.F1");

            //I want to call my method() here
            MyMethod();
        }
    }

    private class d2 : b1
    {
        public override void F1()
        {
            Console.Write("Inside d2:b1.F1");

            //I want to call my method() here
            MyMethod();
        }
    }

   private class ImeplementI2_1 : I2
    {
        public void F2()
        {
            //Implementation
            Console.Write("Inside b_1:b_1.F2");

            //I want to call my method() here
            MyMethod();
        }
    }

   private class ImeplementI2_2 : I2
   {
       public void F2()
       {
           //Implementation
           Console.Write("Inside b_1:b_1.F2");

           //I want to call my method() here
           MyMethod();
       }
   }

    void MyMethod()
    {
        Console.WriteLine("Printmenow");
    }

    static void Main(string[] args)
    {
        I1 interface1;

        if (args.Length > 0)
        {
            interface1 = new d1();

        }
        else
        {
            interface1 = new d2();
        }

        interface1.F1();
        //I want to call my method() here
        MyMethod();

    }

}

如果您想访问程序类的MyMethod，可以做两件事：

1） 只需将其声明为静态

---

2） 将其作为委托传递并在类中调用

我是否正确理解，在方法d1.F1中，您希望调用名为MyMethod（）的方法，在d2.F1中，您还希望调用名为MyMethod（）的相同方法

您没有指定MyMethod（）属于哪个类，但显然它是d1和d2都可以调用的。此外，它们调用相同的MyMethod。我想你应该把MyMethod放在d1和d2的公共超类中，在你的例子中是b1

你能说：“每个b1都有相同的MyMethod（）？那么它肯定属于b1

考虑类形状和子类，如矩形、椭圆形和子类，如正方形和圆形

如果你说每个形状都有一个点，我们称之为形状的位置，那么GetPosition肯定是形状的函数

---

但是，尽管每个形状都有一个面积，但计算矩形面积的方法与计算圆形面积的方法非常不同是放置在接口中的函数的典型示例，或者可能作为形状的抽象函数。

我是否正确理解，在方法d1.F1中，您希望调用名为MyMethod（）的方法，在d2.F1中，您还希望调用名为MyMethod（）的相同方法

您没有指定MyMethod（）属于哪个类，但显然这是d1和d2都可以调用的。此外，它们调用相同的MyMethod。我想您应该将MyMethod放在d1和d2的公共超类中，在您的情况下，这两个类都是b1

你能说：“每个b1都有相同的MyMethod（）？那么它肯定属于b1

考虑类形状和子类，如矩形、椭圆形和子类，如正方形和圆形

如果你说每个形状都有一个点，我们称之为形状的位置，那么GetPosition肯定是形状的函数

---

然而，尽管每个形状都有一个面积，但计算矩形面积的方法与计算圆形面积的方法大不相同。GetArea（）是一个典型的函数示例，可以放置在接口中，或者可以作为形状的抽象函数。

如果您有一个您已经编写的特定方法，您希望从任何给定的类可以访问，并且不需要任何对象实例来存储任何状态，那么您需要一个

公共静态

方法，这是非常正确的。在您的示例中，将其放在

程序

中是可行的，尽管在任何非玩具示例中，我强烈建议您不要将所有这些嵌套在

程序

类中。所有这些类型都应该是顶级类型，而且

MyMethod

应该是一种新类型的静态方法，表示执行这种操作的责任。

如果您编写了一个特定的方法，您希望从任何给定的类访问，并且不需要任何对象实例来存储任何状态，那么您就完全正确了需要一个

公共静态

方法。在您的示例中，将其放在

程序

中是可行的，尽管在任何非玩具示例中，我强烈建议您不要将所有这些嵌套在

程序

类中。所有这些类型都应该是顶级类型，

MyMethod

应该是某种新类型的静态方法，表示执行此类操作的责任。

或者使用基本类型：

interface IMyMethodable
{
    void MyMethod(); 
}

interface I1 : IMyMethodable
{
    void F1();
}

interface I2 : IMyMethodable
{
    void F2();
} //2 interfaces

或静态方法（可能是静态类的）：

或进行某种服务，并将此服务用作依赖项（可以考虑使用依赖注入）：

或者使用基本类型：

interface IMyMethodable
{
    void MyMethod(); 
}

interface I1 : IMyMethodable
{
    void F1();
}

interface I2 : IMyMethodable
{
    void F2();
} //2 interfaces

或静态方法（可能是静态类的）：

或进行某种服务，并将此服务用作依赖项（可以考虑使用依赖注入）：

---

“我有两个接口，smae方法的实现方式不同”为什么？听起来你需要一个抽象类。你到底为什么需要这个？请提供更多关于您的问题的详细信息，因为现在很难说什么您只需要使用“我有两个接口，smae方法实现不同”为什么？听起来您需要一个抽象类。为什么您需要这个？请提供更多关于您的问题的详细信息，因为现在很难说您只需要在哪里使用它？我不想实现MyMethod（）的两倍功能，因为它会消耗一些外部库调用？他不需要两个接口来公开

MyMethod

，他需要任一接口的所有实现来访问该方法。您将在哪里实现它？我不想实现MyMethod（）的两倍功能，因为它会消耗一些外部库调用？他不需要两个接口来公开

MyMethod

，他需要两个接口的所有实现来访问该方法。谢谢，MyMethod（）是一个全新的接口，我必须编写它来调用其他库调用。事实上，我必须实现我的三种方法。因此，我可以创建一个新类或在其中定义。但是想知道这里的最佳/最佳解决方案是什么谢谢，MyMethod（）是全新的，我必须写下它

interface IMyService
{
    void MyMethod();
}

class MyService : IMyService
{
    public void MyMethod() {}
}

class A : Base, IA 
{
    private readonly IMyService service;

    public A(IMyService service)
    {
        this.service = service;
    }

    // IA implementation
}

class B : Base, IB 
{
    private readonly IMyService service;

    public B(IMyService service)
    {
        this.service = service;
    }

    // IB implementation
}