C# Delegates in .NET

Delegates in .NET

• A delegate is a type that represents references to methods, facilitating method calls indirectly.
• Declaring a delegate in C# involves using the delegate keyword followed by the return type and method signature.
• The delegate keyword defines a delegate type, allowing for encapsulation of method references.
• Delegates are instantiated in C# by specifying the delegate type and assigning it a method reference.
• Declaring a delegate serves the purpose of enabling the invocation of methods passed as parameters, promoting flexibility in coding.

Event Handling with Delegates

• Using the += operator adds an event handler to a class, allowing multiple methods to respond to an event.
• Events are typically initiated by calling the delegate associated with the event, effectively notifying subscribers.

Collections in .NET Framework

• The System.Collections namespace in .NET Framework contains standard types for managing collections of objects.
• An ArrayList in C# is characterized by its ability to dynamically resize, storing elements of any type in a single collection.
• A Hashtable in C# stores key-value pairs, enabling fast retrieval of values based on unique keys.

Standard vs Generic Collections

• Standard collections (like ArrayList and Hashtable) can store any data type but may require type casting, leading to runtime errors.
• Generic collections provide type safety, usually yielding better performance and avoiding runtime type checks.

Delegates vs Interfaces

• A key difference between delegates and interfaces is that delegates can point to multiple methods, while interfaces define a contract that a class must fulfill.
• Delegates can be more efficient than interfaces as they utilize less overhead, making them faster in method invocation.

Event Handlers in C#

• Event handlers are special methods designated to respond to specific events, executed when the respective event occurs.
• A true statement about delegates in C# is that they support asynchronous method calls through invocation lists.
• Interfaces may be slower in executing due to the added overhead of ensuring the contract but are faster to retrieve since they provide a structured way to access functionality.