Is there any way an interface can cause different behavior?

Question

Say I have the following code:

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

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

Is it at all possible for there to be different behavior between:

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

and:

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

?

Answer 1

I think it may differ. If somebody's used bad style of programming, i.e.:

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

Yes, there is a difference if someMethod has different overloads for IFoo and 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

(I'm no expert) but in your first scenario, you would get access to everything in Class Foo. In the second scenario, you would only be able to access the IFoo members. So if Foo has additional methods (that aren't part of the interface), you will be able to access them in your first scenario but not the second.

I believe using the interface name instead of the class name is just another way to encapsulate data and only provide access to the interface members. For instance you could have Foo and Bar which both implements IFoo. You could add both of them to, say, a List.

Answer 4

There would never be any difference.

Remember, an interface is a contract. By deriving Foo from IFoo, you are implementing that contract.

In both cases, because Foo is an IFoo and adheres to the contract, the behaviour will always be the same.

Of course, how Foo implements that contract is anybodies guess. But the contract is adhered too by the signature of the interface.

Answer 5

Different bahavior can be, but inside someMethod.

Say you have

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

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

if you have

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

Which will not be possible to do in case when the parameter of the method is defined like.

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

unless you don't cast. So the difference is that decaring IFoo, to decalre generic access parameter, but get less "potential" in terms of data access, but get a huge potential in abstraction over types in your architecture.

So the difference will be only in regard of architecture and program workflow.

Answer 6

If you have two interfaces and there is a common method name in each of them then the implementing class can implement the same method differently. The it depends how the method is called - via interface or not and via which interface.

See here for a similar question:

Inheritance from multiple interfaces with the same method name

Answer 7

You could have an explicitly implemented interface in 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; }
}

with this, you will have:

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

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

Answer 8

It's possible if you explicitly implement 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));
}