1

假设我有以下代码：

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);

?

4

8 回答 8

4

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

public void someMethod(IFoo f)
{
    if (f is Foo)
    {
        Foo f1 = (Foo)f;
        //Do smth with unique Foo members
    }
    //Do anything with IFoo members
}
于 2012-12-05T21:20:51.050 回答
3

是的，如果和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
于 2012-12-05T20:38:47.467 回答
1

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

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

于 2012-12-05T20:36:00.807 回答
1

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

有关类似问题，请参见此处：

从具有相同方法名称的多个接口继承

于 2012-12-05T20:47:52.947 回答
1

永远不会有任何区别。

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

在这两种情况下，因为Foo 是一个IFoo并且遵守合同，所以行为总是相同的。

当然，任何人都猜测 Foo 是如何实现该合同的。但是接口的签名也遵守了合同。

于 2012-12-05T20:38:15.023 回答
1

不同的行为可以，但在里面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 通用访问参数，但在数据访问方面获得的“潜力”较少，但在架构中的类型抽象方面具有巨大潜力。

因此，差异仅在于架构和程序工作流程。

于 2012-12-05T20:38:18.293 回答
1

你可以在 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
于 2012-12-05T20:55:57.047 回答
0

如果您明确实施，则有可能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));
}
于 2012-12-05T21:03:18.463 回答