what is the difference between IShell shell = new... and Shell shell = new....

Question

I'm working through the Composite Application Guidance and often come across instantiation of an object of type interface e.g.:

IShell shell = new Shell();

instead of type class:

Shell shell = new Shell();

• What are the differences between these two?
• Why is the first way used at all (since the second shell object can be used anywhere an IShell interface is specified, right?)

Answer 1

The obvious difference is that the first allows you to use shell as an IShell only, the second allows you to use all the features of Shell which happen to also include those of IShell.

Perhaps you could take the view off a maintainer.

The first is saying what we need is an instance of something supporting IShell, and we can change it to some other object if we like.

The second is saying we must have specifically a Shell object for some feature it provides.

Answer 2

You might want to do that if the class has an explicit implementation of an interface method. Consider this example:

public interface ISomething { void Action(); }
public interface ISomethingElse {void Action(); }
public class Something : ISomething
{
    public void Action()
    {
    }
    void ISomething.Action()
    {
    }
}
public class Something2 : ISomething, ISomethingElse
{
    void ISomething.Action()
    {
    }
    void ISomethingElse.Action()
    {
    }
}

If you want ISomething.Action to be called on Something, then you use have to call it through an ISomething variable. Even in Something2, the Action method is hidden if you don't do it through the interface.

That said, you usually want to avoid having implementations like that. I doubt a framework class would force you into that, but that would be the scenario to declare it with the interface.

Update 1: To clear it up a bit, some extra code on how to get to the methods:

Something some = new Something();
some.Action(); //calls the regular Action
ISomething isome = some;
isome.Action(); //calls the ISomething.Action
((ISomething)some).Action(); //again, calls ISomething.Action

Something2 some2 = new Something2();
some2.Action();//compile error
((ISomething)some2).Action(); //calls ISomething.Action
((IsomethingElse)some2).Action(); // calls ISomethingElse.Action

Answer 3

With your first example, you can only use the functionality specified in IShell within your sourcecode, with the second example, you can also use additional functionality of a Shell object that is not defined in the interface.

The first solution offers more flexibility if you need to replace the Shell object with a different object ShellEx, that has the same functionality, but a different implementation. For this you would only need to change

IShell shell = new Shell();

to

IShell shell = new ShellEx();

The rest of your code does not need to be changed.

The second solution enables you to use the complete functionality of the Shell object.

You will have to decide on a case by case base, which solution is preferrable in the current situation.