Question

说我有以下代码：

class Foo: IFoo {
    public string fooProp { get; set; }
}

interface IFoo {
    string fooProp {get; set; }
}

是否可能存在以下不同的行为：

Foo x = new Foo();
someMethod(x);

和

IFoo x = new Foo();
someMethod(x);

Answer 1

我认为可能有所不同。如果某人使用了糟糕的编程风格，即：

public void someMethod(IFoo f)
{
    if (f is Foo)
    {
        Foo f1 = (Foo)f;
        //Do smth with unique Foo members
    }
    //Do anything with IFoo members
}

Answer 2

是的，如果someMethod对IFoo和Foo有不同的重载，则会有所不同。

public void someMethod(Foo f)
{
    // Overload 1
}

public void someMethod(IFoo f)
{
    // Overload 2
}

Foo x = new Foo();
someMethod(x); // Matches overload 1
IFoo x = new Foo();
someMethod(x); // Matches overload 2

Answer 3

（我没有专家）但是在你的第一个场景中，你可以访问Class Foo中的所有内容。在第二种情况下，您只能访问IFoo成员。因此，如果Foo有其他方法（不是界面的一部分），您将能够在第一个场景中访问它们而不是第二个场景。

我认为使用接口名称而不是类名只是封装数据的另一种方式，只提供对接口成员的访问。例如，你可以让Foo和Bar都实现IFoo。您可以将它们添加到List中。

Answer 4

永远不会有任何区别。

请记住，界面是合同。通过从Foo派生IFoo，您正在实施合同。

在这两种情况下，由于Foo 是IFoo并且遵守合同，因此行为将始终相同。

当然，如何 Foo实现合同是任何人的猜测。但是通过界面的签名也遵守了合同。

Answer 5

不同的行为可以，但在someMethod内。

说你有

class Foo: IFoo {
    public fooProp { get; set; }
}

interface IFoo {
    fooProp {get; set; }
    myCustomProp {get;set}
}

如果你有

public void someMethod(Foo _foo){
     _foo.myCustomProp; //CAN DO THIS, AS YOUR TYPE IS _FOO_
}

如果方法的参数定义为。

，则无法做到这一点

public void someMethod(IFoo _foo){
     _foo.myCustomProp; //NO SUCH METHOD INFO
}

除非你不投。所以区别在于去除IFoo，去除通用访问参数，但在数据访问方面获得的“潜力”更小，但在体系结构中的类型中获得巨大的潜力。

所以区别仅在于架构和程序工作流程。

Answer 6

如果你有两个接口，并且每个接口都有一个共同的方法名，那么实现类可以以不同的方式实现相同的方法。它取决于方法的调用方式 - 通过接口与否以及通过哪个接口。

请点击此处查看类似问题：

Inheritance from multiple interfaces with the same method name

Answer 7

你可以在Foo中有一个显式实现的接口。

class Foo: IFoo {
    private string _fooprop;
    private string _ifooprop;

    public string fooProp       
    {
        get {return "IFoo";}
        set {_fooprop=value;}
    }
    string IFoo.fooProp 
    {
        get {return "Foo";}
        set {_ifooprop=value;}
    }
}

interface IFoo {
    string fooProp {get; set; }
}

有了这个，你将拥有：

IFoo foo1=new Foo();
Foo foo2=new Foo();

Console.WriteLine(foo1.fooProp); // Foo
Console.WriteLine(foo2.fooProp); // iFoo

Answer 8

如果您明确实施IFoo：

，则可以

public class Foo : IFoo
{
    public string Prop
    {
        get { return "Hello Foo"; }
    }

    string IFoo.Prop
    {
        get { return "Hello IFoo"; }
    }
}

public static void SomeMethod<T>(T foo) where T : IFoo
{
    var prop = typeof(T).GetProperty("Prop");
    Console.WriteLine(prop.GetValue(foo));
}

接口是否有任何方式可以导致不同的行为？

8 个答案: