Use Of Delegates In Programming With Simple Example

We all have studied delegates in programming, especially in high-level languages. But often, it’s hard to understand if you are new to programming. So, I’ll be writing here some stuff on the use of delegates with a simple example. I’ll be more focused on the answer to “Why we need delegate” instead of “How to use delegates”.

These are the things we are going to discuss in this article.

• What a Delegate is
• Why we need delegates
• Life without delegates
• Some real-time examples where we use delegates.

What a Delegate is

A delegate is a reference to a function, just like the pointers that we use in C or C++, to reference a variable. In the same way, we use delegates to reference functions in programming.

Why we need a Delegate

Instead of discussing how to use delegates or what the syntax of delegates is, it’s more important to know why we need to use this concept.

Delegates save the address or reference of a function which means we can access to that function without knowing its name.

Let’s discuss this with a real-life example. Suppose you don’t know the name of a town and road in a city but you know its location on Google or Bing maps. Then, you can easily access that location without knowing its name and other stuff.

Getting started with a simple example

Long-running tasks in any application make the application or software irresponsive. So to keep the user updated about the running task and to keep the application responsive while working with the long-running tasks, we can use different types of loading bar options -

Let's discuss XAML Progress Bar in WPF apps.

XAML Progress Bar represents a control that indicates that an operation is ongoing. It looks like this.

XAML Progress Bar has 2 states

• Determinate ( for the tasks whose time of completion is known already )
• Indeterminate ( for a task whose time of completion is dynamic or not known )

Whenever we need to perform a lengthy task, we start it asynchronously and we want to issue a notification whenever the task completes.

Like in the below example, the long-running task is being performed in a background class which is actually known as “Business Logic” of the application and it’s not a code that lies behind UI. This literally means that upon the completion of the long-running task, it’s not easy to access a UI method in order to change the UI.

So, instead of accessing the UI method or Control from background class, we simply access that function using a delegate reference.

Open VisualStudio and make a blank WPF app.

Once you click OK, you'll see an empty application like this.

We need 3 controls to implement Progress Ring Control in this app.

Make a Grid and place these controls accordingly.