What are Interfaces and Delegates in c#?

Question

Since i am new to c#, would like to know about Interfaces and Delegates in c#, the difference between them and scenarios both these to be used. Please don't provide any links, i would like an explanation in simple words.

Answer 1

An interface is a contract - it defines methods and properties that any implementing class has to have and as such any consumer of the interface will know they exist and can use them.

A delegate is a call back site - it defines a method signature that can invoke any method that has the same signature.

See delegates and interfaces on the C# programming guide.

An example of an interface is the IEnumerable interface. It only has one member defined - GetEnumerator. Any object that implements this interface will have this method and any code using such an object can call this method.

An example of a delegate is the Predicate<T> delegate. It is a generic delegate that is defines as following:

public delegate bool Predicate<in T>(T obj);

This means that it takes in any type T and returns a bool. Any method that takes a single type parameter and returns a bool is a match for this delegate and can be used with it.

Since delegates are also objects, they can be passed in to functions. So, any function that has a Predicate<T> delegate can pass in any mathod that matches it. Many of the Linq operators have delegates as parameters. See examples here.

Answer 2

A quote from C# in Nutshell.

A problem that can be solved with a delegate can also be solved with an interface. For instance, the following explains how to solve our filter problem using an ITransformer interface:

public interface ITransformer
{
   int Transform (int x);
}
public class Util
{
   public static void TransformAll (int[] values, ITransformer t)
   {
      for (int i = 0; i < values.Length; i++)
         values[i] = t.Transform (values[i]);
   }
}

class Squarer : ITransformer
{
   public int Transform (int x) { return x * x; }
}

...
static void Main()
{
   int[] values = { 1, 2, 3 };
   Util.TransformAll (values, new Squarer());
   foreach (int i in values)
      Console.WriteLine (i);
}

A delegate design may be a better choice than an interface design if one or more of these conditions are true:

• The interface defines only a single method.
• Multicast capability is needed.
• The subscriber needs to implement the interface multiple times.

In the ITransformer example, we don’t need to multicast. However, the interface defines only a single method. Furthermore, our subscriber may need to implement ITransformer multiple times, to support different transforms, such as square or cube. With interfaces, we’re forced into writing a separate type per transform, since Test can implement ITransformer only once. This is quite cumbersome:

class Squarer : ITransformer
{
   public int Transform (int x) { return x * x; }
}
class Cuber : ITransformer
{
   public int Transform (int x) {return x * x * x; }
}
...
static void Main()
{
   int[] values = { 1, 2, 3 };
   Util.TransformAll (values, new Cuber());
   foreach (int i in values)
   Console.WriteLine (i);
}

And here is the code with delegate

public delegate int Transformer (int x);
class Util
{
   public static void Transform (int[] values, Transformer t)
   {
      for (int i = 0; i < values.Length; i++)
      values[i] = t (values[i]);
   }
}
class Test
{
   static void Main()
   {
      int[] values = { 1, 2, 3 };
      Util.Transform (values, Square); // Dynamically hook in Square
      foreach (int i in values)
         Console.Write (i + " "); // 1 4 9
   }
   static int Square (int x) { return x * x; }
}

Answer 3

An interface can be thought of as a functional definition (or contract). In the real world, many objects have well known interfaces that make them largely (but not completely) interchangable.

For example, take a car. Once you learn how to drive a car, you learn the "Car Driving Interface". You know there will be an Accelerate() function, and a Stop() function, and typically a ShiftGears() function (even if it's just taking it out of park and putting into drive). There is also a Steer() function, and a SignalTurn() function.

There is no guarantee that any given implementation will do something the same way. For instance, a Toyota may have a "Stop()" method in it's CarDriving interface that actually calls Accelerate().

The car may support additional intefaces, such as the SeatBelt inteface, or the Radio interface. While each implementation of these objects may differ, there is always a core set of functionality that is common among all types of these objects. This allows them to be used largely interchangably without having to relearn a different interface.

Interfaces in C# are similar. Different object implementations may contain the same interface implementation, and what they do may be different, but you can treat one object that implements a specific interface the same way you treat another object that implements the same interface.

If you understand what inheritence is, then another way to think of interfaces is that they are the same as a class, but they have no implementation. So when a class inherits from another class, it inherits both that classes "inteface" and it's "implementation". If a class inherts only an interface, then it lacks an implementation and the new class must create that implementation itself.

A delegate, is completely different. A delegate is (among other things) a function pointer that is object aware. A function pointer is a variable, similar to other variables but it's type is "delegate" rather than "int" or "string". And, instead of holding data, it holds a pointer to a method (along with some state information) so that you can call different functions dynamically at run time.

In the following code, the call to "foo" is fixed. You cannot, at runtime, decide you want to call "bar" instead:

DoSometing()
{
     foo();
}

If, instead you did something like the following, you can then pass different methods as arguments to your method and have it call them dynically:

DoSomething(MyFunction func)
{
    MyFunction myfunc = func;
    myfunc();
}

Delegats can do more than that, but that's a basic way to think of them.

Answer 4

OK, I can talk to you in English. You are human. I can talk to any human in English; I don't need to know all humans on earth to speak to them in English; all I care about is that they speak English.

OK, so a human is an object. English is the interface.

A lot of Humans implement the interface IEnglish!

Now apply that in a classical engineering sense. I have a car and a car battery. The car doesn't care about what type of battery, where it was made, or what shape it is. The battery doesn't care about the car. They are functionally abstract from each other.

The battery gives power and implements the interface IBattery. The car will ONLY accept objects which implement IBattery (i.e. physical objects which are car batteries!!)

Semantically, interfaces and delegates are largely equivalent. An interface defines what an object does (methods and properties)... and a delegate defines what a particular method does. Delegates state the parameters of a function or method.... they are type safe function pointers. I'll need to have more of a think to come up with a real life example for this.

Answer 5

An interface is a collection of methods bound to a single object. (Side note: Objects may expose multiple interfaces, thus enabling them to exhibit multiple "personalities").

A delegate is an abstraction of a single method call. Calling a delegate has the effect of calling some other piece of code, about which the caller knows nothing.

A somewhat oversimplified view of things that nonetheless gives the flavour is to think of a delegate as a special case of an interface with exactly one method.