接口有什么方法可以导致不同的行为？

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

如果你明确地实现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));
}

Answer 3

您可以在 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 4

不同的行为可以是，但在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
}

除非你不施放。所以不同之处在于 decaring IFoo，decalre 通用访问参数，但在数据访问方面获得的“潜力”较少，但在架构中的类型抽象方面获得巨大潜力。

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

Answer 5

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

类似问题请看这里：

Inheritance from multiple interfaces with the same method name

Answer 6

是的，如果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 7

永远不会有任何区别。

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

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

当然， Foo 是如何实现该合约的，谁都猜不透。但是接口的签名也遵守了合同。

Answer 8

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

我相信使用接口名称而不是类名称只是封装数据的另一种方式，并且只提供对接口成员的访问。例如，您可以拥有 Foo 和 Bar，它们都实现了 IFoo。您可以将它们都添加到一个列表中。