C# interface instance-like... help me understand

Question

Possible Duplicate:
Interfaces: Why can't I seem to grasp them?

to work with a library I just found I need to implement a few interfaces first. But some methods seem to be asking for objects that have the type of some interfaces... And if I have an interface called MyInterface I can write things like :

    MyInterface shoe;

It does not really make sense to me. Can somebody teach me this concept ? I read this : http://www.dotnetperls.com/interface but it did not really help, I think this concept is a bit more complex than what is presented here.

Thanks !

edit :

For those who wonder, I am not new to Interfaces but it is the first time I ran into such a use of them. And for those downgrading my question, I did search but was unlucky apparently.

Answer 1

A simple explanation: A class is like a company. If it claims to be a sales company, it has to provide sales services. It it claims to be a train factory, it has to be able to make trains. If the national railroads wants to buy trains, it can use any company that can produce trains.

An interface describes what a class has to be able to do. It is like a contract. Each class that wants to have an interface has to fulfill that contract and be able to do what the contract says it has to do. Class instances can perform actions through class methods.

However, the contract doesn't say how the class should do it. So a class can implement the functionality however it wants, or in other words, implement the interface.

public Train
{
    private price;
    public Train(float price) { this.price = price; }
}

public IMyInterface
{
   Train MakeTrain();
}

public ExpensiveTrainFactory : ITrainProducer
{
    // make a luxury, expensive train
    public Train MakeTrain() { return new Train(4000.0); }
}

public CheapTrainFactory : ITrainProducer
{
    // make a cheap train
    public Train MakeTrain() { return new Train(500.0); }
}

public NationalRailways
{
    List<Train> trains;
    public NationalRailways()
    {
        this.trains = new List<Train>();
    }
    public Train BuyTrain(ITrainProducer factory)
    {
        // you can call MakeTrain() because the ITrainProducer guarantees that it can make trains
        trains.Add(factory.MakeTrain());
    }
}

and then in your code:

NationalRailways railway = new NationalRailways();
ExpensiveTrainFactory expFactory = new ExpensiveTrainFactory();
CheapTrainFactory cheapFactory = new CheapTrainFactory();

// expFactory implements ITrainProducer, so I can use it from BuyTrain(ITrainProducer)
railways.BuyTrain(expFactory);
// cheapFactory implements ITrainProducer, so I can use it from BuyTrain(ITrainProducer)  as well
railways.BuyTrain(cheapFactory);

Answer 2

You can declare an Interface, like in your example. However you can not instantiate one.

MyInterface shoe = new MyInterface ();

The above is not legal code. Since an Interface just describes a contract, it has no implementation details, this is left to the client code (you). Therefore it makes no sense to be able to create actual instances of MyInterface.

What you can do, is have a class SomeClass, implement the MyInterface contract:

SomeClass: MyInterface
{
  //implement the methods of MyInterface. All of them, to fulfill the contract.
}

Then you can do things like:

MyInterface shoe = new SomeClass();

Since SomeClass implements the MyInterface contract, the above is legal. You can create an instance of SomeClass because it contains implementation details.

Then you can build on this and create more classes which implement MyInterface.

The beauty of this is that you can have a method for example:

void someMethod (MyInterface test)
{

}

You can pass this method the SomeClass object or any other class you created which implements MyInterface.

Then inside this method, you can call methods that the contract contains without knowing the exact object which has been passed to you. This makes writing future code easier. You can create new objects and so long as they implement MyInterface, it is valid to pass this object to someMethod without changing the declaration of the method.

Answer 3

You are correct, you can't directly create an instance of an interface. However, you can create an instance of some type that implements that interface.

Say I have an interface

public IMyInterface
{
   void DoSomething();
}

(note: usually you start the name of an interface with "I")

Plus I have a class

public MyClass: IMyInterface
{
    public void DoSomething() { ... }
}

Then I can do

IMyInterface something = new MyClass();

although you often call some (factory) method to return some class that implements that interface instead of directly doing a new.

By using the interface as the type of your variable, you specify that you are only interested in the methods and properties specified there.

Answer 4

In C#, each value has two different types: apparent type and actual type. The apparent type is the type of the variable holding the value, and the actual type comes from the constructor used to create the value. Let's say we have the following class:

class MyClass : BaseClass, IMyInterface {
    /* ... */
}

Then all the following declarations are valid:

object obj1 = new MyClass();
IMyInterface obj2 = new MyClass();
BaseClass obj3 = new MyClass();
MyClass obj4 = new MyClass();

The apparent and actual types are as follows:

object obj1 = new MyClass(); /* apparent: object, actual: MyClass */
IMyInterface obj2 = new MyClass(); /* apparent: IMyInterface, actual: MyClass */
BaseClass obj3 = new MyClass(); /* apparent: BaseClass, actual: MyClass */
MyClass obj4 = new MyClass(); /* apparent: MyClass, actual: MyClass */

When you manipulate an object (call its methods, etc), you do it assuming the object has its apparent type - you can't call any class-specific methods of an object. The apparent type dictates the interface of the object visible outside the object.

What actually happens under the hood is done according to the object's actual type - for example, if you override the ToString method of your class, the overridden method is called in the following code:

object obj = new MyClass();
Console.WriteLine(obj.ToString());

The actual type dictates how the object's functionality is implemented.

Answer 5

Interfaces establish a contract between a class and the code that calls it. They also allow you to have similar classes that implement the same interface but do different actions or events and not have to know which you are actually working with. This might make more sense as an example so let me use same example as per your link with bit of modification:

using System;

interface IPerl
{
    void Read();
}

class Test : IPerl
{
    public void Read()
    {
    Console.WriteLine("Read Test");
    }
}

class Test1 : IPerl
{
    public void Read()
    {
    Console.WriteLine("Read Test1");
    }
}

class Program
{
    static void Main()
    {
    IPerl perl = new Test(); // Create instance of Test.
    perl.Read(); // Call method on interface output will be different then Test1.

        perl = new Test1(); // Create instance of Test1.
    perl.Read(); // Call method on interface output will be different then Test.

    }
}

Output:

1. "Read Test"
2. "Read Test1"

I hope this would help.

Thanks Ankur

Answer 6

What Interfaces Are

Interfaces basically define a blueprint for a class or a struct. The programmed definition of an interface looks very similar to a class, but nothing is implemented. Interfaces define the properties, methods, events, and indexers, but the interface does not define the implementation of any of these. It just declares their existence. Interfaces will not actually define any functionality. They just define ways in which interactions with a class takes place.

What Interfaces Are Not

Interfaces should not be confused with inheritance. They are two very different things. Inheritance will define a lot of the implementation and is used for code reuse. Interfaces are merely a definition for how communication with the implementing classes must take place. It is like a written contract. A class "signing" the contract will agree to perform certain specified actions in any way it wishes, but it must perform the specified actions.

When to Use Interfaces

Interfaces allow us to create nice layouts for what a class is going to implement. Because of the guarantee the interface gives us, when many components use the same interface it allows us to easily interchange one component for another which is using the same interface. Dynamic programs begin to form easily from this.

For more information visit this post about Understanding_Interfaces_in_C#