Learn about Method delegates in C# Programming

0
989
C# (14) - Method Delegates 740X296

C# (14) - Method Delegates 740X296

Earlier in this series, you examined functions, how they can encapsulate a block of code, how they may accept parameters, do some processing and then they may or may not return an output. All this is great but have you ever thought about using functions the same way you use variables? Yes I mean passing them to other functions in the same way you pass normal variables, possibly returning them the same way you return a value from a function. Welcome to function delegates.

The first question that might pop into your head is: “Why should we use functions that way?” The typical usage of function delegates will be very obvious when you start working with events call-back methods. But let’s leave that aside for the moment and start learning about the concept first.

If you come from a C or C++ environment, you can regard delegates the same way you regard pointers to functions. Otherwise, consider a delegate as a reference type variable that references a function (called a method henceforth).

An example is the best way to understand what’s been just said. Take a look at the following code:

There is no difference between a method declaration and a delegate one except for two things:

  • The keyword delegate is added before the return type
  • There is no method body.

Note that this is just a declaration, you haven’t instantiated your delegate yet. To do so, first, you have to have a method that has the same signature as the delegate. A signature of a method is its parameter list and return type. That is, string ExampleMethod(string str) { } has the following signature: it has a return type of string and takes one string parameter. Accordingly, we have to create a method with the same signature as ExampleDelegate’s. Let’s do just that:

Instantiating a delegate is done by using the new keyword followed by the delegate. The delegate here is used like a function, accepting the method name as an argument. Notice that we passed the method name without the parentheses, because we are not calling it, we’re just passing its reference. Once we have our delegate method, greeter, we can use it the same way we would use ExampleMethod. It would print whatever string we pass in uppercase.

The complete code is listed below:

Learn Cloud Computing from Scratch for Beginners

Now to see the real power of delegates, consider the following situation: you are developing an application that would take text and format it so that it can appear on web pages as HTML. If you don’t know HTML, it’s a language that adds tags to text to make it appear with a specific look on web pages. For example <a href=”www.google.com”>www.google.com</a> will make www.google.com appear as clickable text (hyperlink) on a web page like this www.google.com. Ok, this is easy, you develop a method that would take www.google.com, add the necessary tags like this:

But hyperlinks are not the only tags that may be on a typical web page, there are other tags like, for example, the <p></p> tag, which formats text in between it as a paragraph. Ok, nothing different here as far as a C# developer is concerned, let’s create a method for this as well:

You call the appropriate method whenever the specific formatting is needed. But later on, you are required to add some heading text before the output of both methods: “The link is” followed by the URL whether it is in a hyperlink, or a paragraph. Modifying each method separately is a waste of time. Let’s use delegates instead:

Let’s go through this step by step:

  1. You created a delegate for a method that would accept a string, and return a string.
  2. Then you created two methods with the same signature as the delegate (that is, accepting a string argument and returning a string value), one to format the string as a hyperlink, and another to format it as a paragraph.
  3. Finally, you created a general function: format(). This time, it accepts not only a string parameter s, but also a reference to any method that accepts a string and returns one, (a delegate). You named it formatter.
  4. Inside this general function, you return “The link is: ” followed by whatever output returned from the formatter method, after passing your string to it as a parameter.
  5. In the Main() function, you create two delegates to your formatting methods hyperlink and paragraph. You call them hl and p. Those will be the second-place arguments to the generic format() method.
  6. To test the output, you print the output of format() when a hyperlink reference is passed, and when a paragraph one is passed.

The output of the above code should be:

The key to understanding the usefulness of delegates in this example is to realize that the format() function does not care about what the method reference passed to it does to the text it accepts. You can make as many methods that format text to HTML tags as you wish, the format() method will return their output preceded by whatever text you want to add. Now if you are asked to change “The link is: ” to some other phrase, you have to change it only in one place. As mentioned, delegates have more powerful uses than this, discussed when we start examining events.

Conclusion

Today, we examined one of the powerful – and a bit advanced – topics of C#: delegates. You have learned what delegates are, how useful they can be, and how to define them and use them.

In the next article, we will start talking about new important topic: Error Handling. A topic that you shouldn’t miss; so, see you there.

LEAVE A REPLY

Please enter your comment!
Please enter your name here