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

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

（我不是专家），但在第一种情况下，您可以访问Foo类中的所有内容。在第二种情况下，您只能访问IFoo会员。因此，如果Foo具有其他方法（不属于界面的一部分），则可以在第一种情况下访问它们，但不能在第二种情况下访问它们。

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

Answer 2

永远不会有任何区别。

请记住，一个接口是合同。通过从IFoo推导Foo，您正在实施合同。

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

当然，如何 Foo实现该合同是任何机构的猜测。但是通过界面的签名也符合合同。

Answer 3

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

是的，是有区别的，如果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 5

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

在这里看到一个类似的问题：

Inheritance from multiple interfaces with the same method name

Answer 6

你可以在美孚的明确实现的接口。

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 7

，如果你明确实现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 8

我认为它可能会有所不同。如果有人使用了不好的编程风格，例如：

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