Predicate delegate in C#

Hello Everyone, In the article we will talk about Predicate delegate.

Predicate is also a delegate which encapsulate a method that takes  only one parameter and returns a bool value - true or false.

So in general Predicate is -

1. Which is contra variant

2. Takes one parameter and return true or false.

Let's talk about some use case of predicates -

1. Let's say we want to filter some data in a collection. We can provide a predicate which will take the input of collection and returns bool value.

e.g. - In WPF when we implement list view filtering. It is very useful

2. Some extension methods also take predicate as a parameter. e.g - List.FindAll(predicate)

Please have a look on implementation of predicate.

Hope you like reading the article. Please inbox me in case of any confusion.

Happy Coding :)

Read More

Func Delegate in C#

Hello Everyone, In this article we will talk about Func< in T, out TResult>  Delegate.

 

It is another readymade delegate that provides by .Net framework. It can encapsulate a method that takes some parameters as input and returns an output as TResult.

So in general Func is a delegate

1. Which takes from 0 to 16 parameters.

2.  It is contra variant and co variant both. Input parameters are contra variant and Output parameters are co variant.

Where can we use Func delegate ?

You can use this delegate to encapsulate a method where you need to pass some parameter( 0 to 16 ) and need to get some result. In this case you do not need to explicitly create a delegate. Func is perfect placeholder.

Let's see a complete example of Func delegate -

Use case - Let's say An array is given and you have to print only odd numbers.

Solution - You can create a foreach loop and check  if the number is odd then print that

At later stage of development you get some more rules added. Let's say print those odd numbers which are greater than 5.

So in this case you have to modify your for loop which can be at the UI level. In that case we will break some SOLID rules.

What is the solution ?

We can create a Func that takes input of array and apply all the rules and return list of data or one by one. This can be at model level and UI won't be aware of the logic and functionality.

Hope you like reading the article. Please inbox me in case of any confusion.

Happy Coding :)

Read More

Action Delegate in C#

Hello everyone, in this article we will talk about “Action” a readymade delegate.

Action is just another delegate that takes some parameters and doesn’t return a value. So when do you want to execute some method which doesn’t return any value then rather creating your own delegate. .Net framework provides us an Action Delegate. Please have a look on below image –

So In general Action is a delegate -

• Which is contra variant ( in parameter  will discuss this in next articles )
• Which takes 1 to 16 parameters but do not return any value.

So let’s take an example of using Action –

private static void MyActionMethod()
        {
           Action obj = new Action(MyDummyMethod);
           //Synchronous way
           obj.Invoke();
           //Asynchronous way
           obj.BeginInvoke(null, null);
           Console.ReadLine();
           // You can call it as asynchronous way because this is just a delegate
        }

Cool J So we saw in this example we can invoke an action as a synchronous way as well as asynchronous way because Action is none other than a delegate.

Action using Lambda Expressions –

static Action<string> MyActionUsingLambda = str => Console.WriteLine(str);
MyActionUsingLambda("saurabh");

Action using Anonymous Functions-

Action<string> MyActionUsingAnounymous = delegate(string str)
        {
            Console.WriteLine(str);
        };
public void ActionUsingAnonymousMethod(string str)
        {
            MyActionUsingAnounymous(str);
        }

So that was all about Action in C#.

Hope you like reading the article. Please inbox me in case of any confusion you have.

Happy CodingJ

 

Read More

Exception Handling in Multicast Delegate ?

Hello Guys, In this article we will discuss about how to handle exception in multicast delegate ?

In case you want to understand Delegate and Multicast Delegate. Please visit the links -

Delegate-Delegates
Multicast Delegate-Multicast Delegate

Please look this example -

 

Read More

Multicast Delegate in C#

Hello Everyone, I talked about delegate in my last article. In this article we will talk about multicast delegate.

A Delegate is a type variable that holds the reference of a method and multicast delegate can holds the reference of multiple methods. So basically it's kind of linked list of methods. When we execute the multicast delegate then all the methods which are associated with the multicast delegate will execute in sequence.

How can we create a multicast delegate ?

There is no difference in creation of Delegate and Multicast Delegate. It's just we can associate multiple methods with the same delegate.

 Now the question is how can we associate  multiple methods to a delegate ?

There are two ways of associating multiple methods  -

Delegate.Combine(myDelA, myDelB);

Or

myDelA += MethodB;


Let's see the example -

So now question is How multicast delegate reference to the methods and invoke it ?

There is a method exposed in delegate from which we can fetch the invocation list
and that list returns the collection of all the associated delegates.

public delegate int myDel();

        static void Main(string[] args)
        {
            myDel multiCast = MethodC;
            multiCast += MethodD;

            foreach (myDel del in multiCast.GetInvocationList())
            {
                del.Invoke();
            }
        }

        static int MethodC()
        {
            Console.WriteLine("Executing method C.");
            return 1;
        }

        static int MethodD()
        {
            Console.WriteLine("Executing method D.");
            return 1;
        }

So in the above example I have not called invoke method of delegate directly. Instead of fetching all the method info from GetInvocationList() and invoking it one by one. This is the way .Net framework calls the method in sequential way.

Let's say if some of the method throws exception then how multicast delegate handles that situation ?

Have a look on below Example this is the answer of the question -

public delegate int myDel();

        static void Main(string[] args)
        {
            myDel multiCast = MethodC;
            multiCast += MethodD;
            //If you will call this. This will throw exception
            //multiCast.Invoke();

            foreach (myDel del in multiCast.GetInvocationList())
            {
                try
                {
                    del.Invoke();
                }
                catch (Exception)
                {
                    //Handled
                }
            }
        }

        static int MethodC()
        {
            try
            {
                return 1;
            }
            catch (Exception ex)
            {
                return 0;
            }

            throw new Exception();
        }

        static int MethodD()
        {
            Console.WriteLine("Executing method D.");
            return 1;
        }

Hope you like reading this article. Please inbox me in case of any confusion.

Happy Coding :) 

Read More

Calling the Delegates using Invoke(), BeginInvoke() and DynamicInvoke() ?

Hello Guys, So in the last article we talked about What is delegate and how can we create a delegate.

In this article we will discuss what are the ways available to call a delegate and what are the differences in between ?

There are different ways in which you can invoke delegates to get a synchronous or an asynchronous behavior.

synchronous -  Using Invoke we can achieve this and in this delegate execute synchronously on the same thread. So in general when you want to invoke a delegate and want to wait for its completion before current thread continues then Invoke is the right choice. Details you can see in this article -

Asynchronous Way -  We can achieve this using BeginInvoke, It means you do not want that main thread  wait for the completion of the delegate. In this scenario the delegate and current thread can work in parallel.

Point to notice here is You can achieve Asynchronous  way using Delegate.BeginInvoke or creating a new thread then Which one to prefer and Why ?

Delegate provides a very less control over async behavior as when you invoke a delegate you can fetch the result using EndInvoke but you cannot terminate the process. While creating a thread you have more control on Async behavior. So in my understanding creating a Thread is better than invoking a delegate in Async way.

Implementation of BeginInvoke -

In the above example we saw how can we invoke a delegate using BeginInvoke.

So now in case GenerateMainXml has to return some value. How can we handle this situation ?

Answer is EndInvoke.

Calling EndInvoke will always block your main thread until it completes the execution. There are two ways of calling EndInvoke. One is as a callback and another one is direct way.

Direct way of calling an EndInvoke() -
 

So in the above example we created a Square number function and assigned it to a delegate. Called using BeginInvoke and on the same delegate called the EndInvoke method to get the results.

There is one problem in this approach. Use case of BeginInvoke is to get asynchronous way of implementing one of the method. But after calling EndInvoke we are telling to main thread to wait until delegates execution completes. Then only we can fetch the results .

So now what is the solution ?

Calling EndInvoke as Callback method. In this way we tell delegate once it completes the execution, call  the callback method and tell us the results. So main thread won't be blocked.

Looks Good :)

DynamicInvoke :  It is similar to Invoke, it invokes a delegate in asynchronous way. The only benefit is it takes  object[] as parameter. So it does boxing and unboxing at run time.

Correct implementation is -

So we can see in the above example we can pass an object array as aparameter in dynamicinvoke and the result will also be a object type. So this is usefule when you are not aware of the type but it will be damn slow. So think before using it.

Hope you like reading the article. Please inbox me in case of any confusion is in your mind.

Happy Coding:)

Read More