When to Use Delegates Instead of Interfaces in C#

Both delegates and interfaces allow a class designer to separate type declarations and implementation. A given interface can be inherited and implemented by any class or struct; a delegate can created for a method on any class, as long as the method fits the method signature for the delegate. An interface reference or a delegate can be used by an object with no knowledge of the class that implements the interface or delegate method.

Delegate approach is very similar to the interface approach. But here the classes are not bound to implement any interface. They only need to have methods which match the delegate signature. Class need not know whom to notify and which methods to call. It just has a set of delegates which it needs to invoke. Hence this removes the tight coupling between the two classes.

Both approaches require an explicit step to integrate the two pieces of code. The fundamental difference between the two approaches is that the delegate-based design requires that explicit step to take place at the point of integration, not at a particular type definition. The delegate-based approach specifically does not assume that the target method will have any awareness of its integration partner, rather, it's just a method that can be called by anyone with sufficient security/access permissions. In contrast, the interface-based approach requires the target method to have an a priori understanding of the integration contract. (by Don Box)

When you implement an interface, and you pass a reference to that interface to someone, you're engaging in a contract which says: whenever you call one of those functions, the same object will handle the call [in different methods]. When you expose a set of delegates, you don't have that guarantee. Calls could be redirected to different objects. This breaks the idea of an interface as a whole contract, switching to a model of methods [delegates, actually] as individual contracts

Use a delegate when:
• An eventing design pattern is used.

• It is desirable to encapsulate a static method.

• The caller has no need access other properties, methods, or interfaces on the object implementing the method.

• Easy composition is desired.

• A class may need more than one implementation of the method.

Use an interface when:
• There are a group of related methods that may be called.

• A class only needs one implementation of the method.

• The class using the interface will want to cast that interface to other interface or class types.

• The method being implemented is linked to the type or identity of the class:
for example, comparison methods.

Ref:

Delegates vs. Interfaces - http://www.devsource.com/c/a/Using-VS/Delegates-vs-Interfaces/

Use of Interfaces and Delegates for an Extensible Design - http://www.codeproject.com/KB/architecture/ClassDesign.aspx