Question

interface parentInterface
{
   public String methodA(/*define parameters name and dataType*/);
}

和

public class childA : parentInterface
{
  public String methodA(String a, int b, String c, long d){}
}

public class childB : parentInterface
{
   public String methodA(int e, String f, String g){}
}

我想定义接口方法的参数名称和数据类型

Answer 1

制作新参数

通常可以使用class或struct作为单个参数而不是内置类型来解决此问题。

界面

您知道class在实施熟悉的interface时会发生什么。我们知道实现IEnumerable接口的所有类都可以在foreach循环中使用。按照惯例，界面名称为“I”，后跟能力描述。典型的名称以后缀“-able”结尾。

-able   后缀形成形容词含义：
     1 - 可以[计算]。
     2 - 具有[舒适]的质量。

  Oxford English Dictionary

让我们重命名parentInterface和MethodA()，以明确说明这通常是如何运作的（并避免负面制裁）：

public interface ITreatable
{
    Treatment GetTreatment();
}

好吧，即使object代表一种可治疗的疾病，找到治疗方法可能并不那么容易。以下是一些例子：

public class TheFlu : ITreatable
{
    public Treatment GetTreatment(int year)
    {
        // return some object, Treatment, based on the flu season.
    }
}

public class Hangover : ITreatable
{
    public Treatment GetTreatment()
    {
        return Treatment.Empty; // no parameters necessary.
    }
}

public class Insomnia : ITreatable
{
    public Treatment GetTreatment(FamilyHistory occurances, LabResult lab)
    {
        // return Some Treatment object that can be different based on the
        // calculated risk from the arguments.
    }
}

我们真正错过的是

我不知道生物学，但概念仍然是一样的。您有一组需要ITreatable方法的GetTreatment()病症对象;但是，他们使用不同的标准进行计算。我们需要Symptoms。

public class Symptoms
{
    public FamilyHistory History;
    public DateTime Time;
    public LabResult Lab;
    public BloodTest BloodTest;
    public TimeSpan SymptomTime;
    public IsCritical IsCritical;
}

现在，对象可以用自己的方法解析症状，我们的界面将如下所示：

public interface ITreatable
{
    Treatment GetTreatment(Symptoms symptoms);
}

Answer 2

您有两种不同的方法

public String methodA(String a, int b, String c, long d){}

和

public String methodA(int e, String f, String g){}

分别代表与childA和childB的两个不同的合同。您无法定义具有适合两种定义的单个methodA的接口。你不想做什么。

请注意，您可以在接口中定义两个重载，但是实现该接口的每个类都必须实现两个重载。

Answer 3

具有不同参数的方法不能同时实现相同的接口方法声明。如果您的方法签名与接口的签名不匹配，则表示您没有实现该接口。

你可以实现这一点，但它不是一个好的设计，因为界面没有告诉你任何有关方法的信息：

interface parentInterface
{
    string methodA(params object[] asd);
}


public class childA : parentInterface
{
    public string methodA(params object[] p)
    {
        string a = p[0] as string;
        int b = (int)p[1];
        string c = p[2] as string;
        long d = (long)p[3];
        return string.Empty;
    }
}

public class childB : parentInterface
{
    public string methodA(params object[] p)
    {
        int e = (int)p[0];
        string f = p[1] as string;
        string g = p[2] as string;
        return string.Empty;
    }
}

Answer 4

您可以使用带有params关键字的可变数量参数的接口方法。但是，您需要将每个参数转换为适当的类型，这有点容易出错。

public interface IFoo
{
    void DoWork(params object [] arguments);
}

public class Foo : IFoo
{
    public void DoWork(params object [] arguments)
    {
        string a = (string)arguments[0];
        int b = (int)arguments[1];
        string c = (string)arguments[2];
        long d = (long)arguments[3];

        Console.WriteLine("a={0}, b={1}, c={2}, d={3}", a,b,c,d);
    }
}

public class AnotherFoo : IFoo
{
    public void DoWork(params object [] arguments)
    {       
        int e = (int)arguments[0];
        string f = (string)arguments[1];
        string g = (string)arguments[2];

        Console.WriteLine("e={0}, f={1}, g={2}", e,f,g);
    }
}

void Main()
{
    var foo = new Foo();    
    foo.DoWork("a",1, "c",2L);

    var foo1 = new AnotherFoo();    
    foo1.DoWork(1,"f", "g");
}

用C＃中的不同参数定义接口方法

4 个答案: