C# Declare Delegate in Interface
A reference type variable that can store a reference to one of the methods is called a Delegate. It is an object that points to a method. Comparable to the function pointer in C/C++, delegates are used in C#. It offers a mechanism to specify which method should be invoked if an event occurs. For instance:
using System; class TE { public delegate void Addition(int p, int q); public void Samp(int p, int q) { Console.WriteLine("[{0} + {1}] = [{2}]",p,q, p + q); } public static void Main(String[] args) { TE t = new TE(); Addition oj = new Addition(t.Samp); oj(38, 92); } }
Output:
An interface can have members such as methods, properties, events, and indexers, much like a class. However, interfaces will only include the members' declarations. The class that implements the Interface, whether explicitly or implicitly, will provide the implementation for its members. For instance:
using System; interface itfc { void display(); } class TE : itfc { public void display() { Console.WriteLine("Hello guys!"); } public static void Main(String[] args) { TE t = new TE(); t.display(); } }
Output:
Similarities:
Both interfaces and delegates share the following characteristics:
- The declaration is the only thing that delegates and interfaces contain. It takes a different programming object to implement them.
- A class designer can distinguish between type declarations and implementation with both.
- Any class can inherit and implement an interface, and any method on any class can have a delegate generated for it as long as the method complies with the Delegate's method signature.
- An object is using an interface or a delegate. Neither of them is familiar with the class that uses.
- In essence, a Delegate specifies the capabilities of a certain method, while an Interface specifies its methods and characteristics.
When is it appropriate to use delegates instead of interfaces?
The situation or situations listed below call for the use of Delegate rather than Interface:
- The Delegate should be used if the Interface defines just one method.
- If the need for multicast exists.
- If a subscriber needs to use the Interface more than once.
Delegate is a fairly simple replacement for Interface if Interface just has one method. Let us understand this with the example below:
Using Interfaces
using System; interface ITFC { int Addition(int x, int y); } public class Class : ITFC { public int Addition(int x, int y) { return x + y; } } class Program { static void Main(string[] args) { ITFC myInterface = new Class(); Console.WriteLine(myInterface.Addition(28, 13)); Console.ReadKey(); } }
Output:
Using Delegates
using System; public delegate int Deleg(int x, int y); public class Class { public static int Sum(int x, int y) { return x + y; } } class Program { static void Main(string[] args) { Deleg deleg = Class.Sum; Console.WriteLine(deleg(15, 67)); Console.ReadKey(); } }
Output:
How is a Delegate added to an Interface?
First, the Interface's goals do not include reminding you of your desired requirements or goals for the class. It serves as an abstraction tool. In object-oriented programming, it serves as the foundation for design.
These have no place in an interface since they essentially specify delegate types. An event of the Delegate type can be used in an interface.
Delegate Interface
You can utilize a delegate if one is accessible within your scope. An interface is utilized if and only if your class implements it. It can handle events with ease. Events are not managed by it. You don't need access to the class object where the method is defined to use delegates to access the method. It would help if you had the class object that implements the Interface to use the method. Any method that yields the same signature with the specified Delegate can be implemented by it. The same name and signature method override if the interface method is implemented. It does not consider whatever class the method belongs to; it can encapsulate any method whose signature resembles the Delegate's. Although a class can implement as many interfaces as it wants, it can only override methods that are part of the interfaces. You can use delegates as often as you like. An interface can only be used once. It might just be a method. It includes both attributes and methods. At runtime, it was constructed. At compilation time, it was constructed. It has access to anonymous methods. It is unable to use anonymous methods. Static methods and sealed class methods can be wrapped using it. Static methods and sealed class methods are not covered by it. It applies to a single method at one point in time. A class will implement all of the methods associated with an interface if it implements it. It opposes inheritance. It encourages inheritance.