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

Delegates in C Sharp

A Delegate is a type variable that holds the reference to a method. Delegates are similar to Pointer to functions in C and C++

When we create a delegate then we can assign a method to delegate instance according to its signature and we can change the reference at run time. After assigning the method we can call this method using delegate instance.

Note - Your method signature and return type must match with Delegate

Why do we need to create a Delegate ?

• Delegate Invoke method at run time.
• Delegate can be used for callback methods.
• Delegates can invoke multiple methods on a single event. So this is useful when we have to give multiple implementation of a single method.
• When do you want to restrict access to caller then we can expose a delegate.

Now How can we create a Delegate ?

public delegate int MyPointer(int x, int y);

AccessModifier, delegate type , return type DelegateName(Delegate params)

This is how we can create a Delegate. Now the point is how can we create a Delegate instance and add methods at run time.

So let's check out this example - 

public class MyDelegate
    {
        public delegate int MyPointer(int x, int y);

        /// <summary>
        /// CTOR
        /// </summary>
        public MyDelegate() { }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="operation"></param>
        /// <returns></returns>
        public MyPointer MyOperation(int operation)
        { 
            MyPointer objPointer = null;
            if( operation == 1)
            {
                objPointer = Add;
            }
            else if (operation == 2)
            {
                objPointer = Sub;
            }
            else if (operation == 3)
            {
                objPointer = Mul;
            }
            else if (operation == 4)
            {
                objPointer = Div;
            }

            return objPointer;
        }

        private int Add(int x, int y)
        {
            return x + y;
        }

        private int Sub(int x, int y)
        {
            return x - y;
        }

        private int Mul(int x, int y)
        {
            return x * y;
        }

        private int Div(int x, int y)
        {
            return x / y;
        }
    }

How MainMethod will call delegate and execute the methods - Let's have a look

static MyDelegate objDel;

        static void Main(string[] args)
        {
            objDel = new MyDelegate();
            Delgateinvoke();
        }

private static void Delgateinvoke()
        {
            //Way 1
            int num = objDel.MyOperation(1).Invoke(4, 5);

            //Way2
            MyDelegate.MyPointer delegateInstance = objDel.MyOperation(1);
            delegateInstance.Invoke(4, 5);

            Console.WriteLine(num.ToString());
        }

So here we created instance of a class MyDelegate and call the method MyOperation.It returns a delegate instance now we call the invoke method of delegate.

Looks Cool..

Now the question comes What is this Invoke ? See below example -

So delegate has these mentioned methods for instantiation. Currently I am using Invoke method to instantiate the delegate. When we say instantiate it means delegate call the same method which we attach.

Let's talk about these methods mentioned above -

BeginInvoke - Executes asynchronously on a pooled thread (Thread pooling or TPL)

Invoke - Delegate execute synchronously on the same thread.

DynamicInvoke- Delegate execute synchronously but as name says dynamic, you pass the parameter to function does boxing and unboxing at runtime. It requires an object array to execute the method. Avoid this as it is Damn Slow.

GetInvocationList -  This Fetches all the method info you associated with the Delegate. So it is useful when you want to execute delegate according to your need. You can fetch the info and invoke accordingly. We will discuss this in next articles.

Types Of Delegates :

• Single Delegate
• Multi Cast Delegate
• Readymade Delegates - Func, Action and Predicate

In this article we talked about single delegate . In Next Article we will talk about Multi Cast Delegate and Readymade Delegates in C#

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

Happy Coding :)

Read More

Interfaces in C#

Hello Everyone, In this article we will try to understand about interfaces and its use in C#

Interfaces in C# are the empty vocabularies.

What does it mean ? It means it contains only the signature of methods, properties ,events and indexers.

Now the question arises what is the benefit of creating an interface ?

A class that implements interface must implement all the members of interface so basically it creates a responsibility or force implementation to child classes.

How can we create an interface ?

Interfaces are declared using interface keyword. Interface are internal by default.

namespace Interface
{
    public interface IProblem
    {
        void MyMethod();
    }
}

An interface can inherit from one or more interfaces.

public interface IProblem
    {
        void MyMethod();
    }

    public interface IProblem1 : IProblem
    {
        void MyMethod1();
    }

    public class MyClass : IProblem1
    {
        //Member of IProblem1
        public void MyMethod1()
        {
            //Some implementation
        }

        //Member of IProblem
        public void MyMethod()
        {
            //Some implementation
        }
    }

How to Create event member inside Interface ?

public interface IProblem
    {
        void MyMethod();

        event EventHandler Closed;
    }
    public interface IProblem1 : IProblem
    {
        void MyMethod1();
    }

    public class MyClass : IProblem1
    {
        event EventHandler myPrivateEvent1;

        //Member of IProblem1
        public void MyMethod1()
        {
            throw new NotImplementedException();
        }

        //Member of IProblem
        public void MyMethod()
        {
            throw new NotImplementedException();
        }


        public event EventHandler Closed
        {
            add
            {
                myPrivateEvent1 += value;
            }
            remove
            {
                myPrivateEvent1 -= value;
            }
        }

        /// <summary>
        /// Raising the event.
        /// </summary>
        public void OnClosed()
        {
            EventHandler handler = myPrivateEvent1;
            if (handler != null)
            {
                handler(null, new EventArgs());
            }
        }
    }

In C# using interfaces we can achieve multiple inheritance. So it means a class can inherit multiple interfaces. Looks Cool

But What if both of interfaces contains same members - like same method declaration, event declaration. Will it compile ?

Answer is Yes. C# introduces Explicit and Implicit Interface implementations. Above implementations are Implicit implementation and when we explicitly mentioned the name of interface while implementing in a class, It's called Explicit implementation.

Let's see an example -

In above example I have same method declaration in both of my interface but still I don't see any compile time error. .Net framework internally handling this.

But what if I need to implement different behaviours for both of the methods then how can I achieve this ?

See below example-

public interface IProblemNew
    {
        void MyMethod();
    }

    public interface IProblem2
    {
        void MyMethod();
    }

    public class NewClass : IProblem2, IProblemNew
    {

        void IProblem2.MyMethod()
        {
            
        }

        void IProblemNew.MyMethod()
        {

        }
    }

So If I am creating object of IProblem2 then in case I should see only the metadata of that interface only. See attached example -

In the same way we can use explicit events as well.

Conclusion of the story  -

• It allows force implementation and creates a responsibility on developer to implement all the members of the interface.
• Using interface we can achieve multiple inheritance.
• Interfaces cannot inherit Abstract class.
• Interface can inherit from one or more base interfaces.
•  By default interfaces are internal not public.
•  We cannot use Sealed keyword while defining interface.

Point to remember - There is some confusion over default access modifier of interface.

Default access modifier of Interface is Internal -

In below example one interface is public and on another one I didn't define any access modifier.

Hope you like reading the article. Please share your comments in case of any confusion.

Happy Coding :)

Read More