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

Singly Linked List in C#

Node class is a generic class that will help to initialize each node of linked list.

public class Node
{
    public Node(T value)
    {
        this.Value = value;
    }

    public T Value { get; set; }

    public Node Next { get; set; }

    public override string ToString()
    {
        return this.Value.ToString();
    }
}

    /// <summary>
    /// This is a singly linked list and it will allow you to add bunch of Node<T>s
    /// and that will be linked to each other.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class LinkedList where T : IEnumerable
    {
        public LinkedList(IEnumerable collection)
        {
            if (collection == null)
            {
                throw new NullReferenceException("collection is null");
            }
            foreach (T item in collection)
            {
                this.Add(item);
            }
        }

        public int Count { get; set; }

        private Node firstNode;

        public Node FirstNode
        {
            get { return firstNode; }
            private set { firstNode = value; }
        }

        private Node lastNode;

        public Node LastNode
        {
            get { return lastNode; }
            private set { lastNode = value; }
        }


        public void AddFirst(T item)
        {
            Node newNode = new Node(item);
            if (this.FirstNode == null)
            {
                this.FirstNode = this.LastNode = newNode;
            }
            else
            {
                newNode.Next = this.FirstNode;
                this.FirstNode = newNode;
            } this.Count++;
        }

        /// <summary>
        /// Add will always add the items at last.
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            Node newNode = new Nodeitem);
            if (this.LastNode == null)
            {
                this.FirstNode = this.LastNode = newNode;
            }
            else
            {
                this.LastNode.Next = newNode;
                this.LastNode = newNode;
            }
            this.Count++;
        }

        /// <summary>
        ///  Add new item after particular Node<T>
        /// </summary>
        /// <param name="node"></param>
        /// <param name="item"></param>
        public void AddAfter(Node node, T item)
        {
            if (node == null)
            {
                return;
            }
            Node; newNode = new Nodeitem);
            if (node.Next == null)
            {
                node.Next = newNode;
            }
            else
            {
                newNode.Next = node.Next;
                node.Next = newNode;
            }
            this.Count++;
        }

       /// <summary>
       /// Remove the item
       /// </summary>
       /// <param name="item"></param>
        public void Remove(T item)
        {
            if (item == null)
            {
                throw new NullReferenceException("item is null");
            }
            Node newNode = this.Find(item);
            this.RemoveTheRef(ref newNode);
        }

        /// <summary>
        /// Remove the first node
        /// </summary>
        public void RemoveFirst()
        {
            Node first = this.FirstNode;
            RemoveTheRef(ref first);
        }

        /// <summary>
        /// Remove the last node
        /// </summary>
        public void RemoveLast()
        {
            Node last = this.LastNode;
            RemoveTheRef(ref last);
        }

       /// <summary>
       /// Find the item inside list.
       /// </summary>
       /// <param name="value"></param>
       /// <returns></returns>
        public Node Find(T value)
        {
            Node Node = this.FirstNode;
            while (Node != null)
            {
                if (Node.Value.Equals(value))
                {
                    return Node;
                }
                Node = Node.Next;
            }
            return null;
        }

        ///          
        /// Find previous Node<T>
        /// 
        public Node FindPreviousNode(T value)
        {
            Node Node = this.FirstNode;
            Node previousNode = this.FirstNode;
            while (Node != null)
            {
                if (Node.Value.Equals(value))
                {
                    return previousNode;
                }
                previousNode = Node;
                Node = Node.Next;
            }
            return null;
        }

        /// <summary>
        /// Clear the collection
        /// </summary>
        public void Clear()
        {
            this.FirstNode = null;
            this.LastNode = null;
            this.Count = 0;
        }

        /// <summary>
        /// Get enumerator will help you to traverse the collection
        /// </summary>
        /// <returns></returns>
        IEnumerator GetEnumerator()
        {
            Node currentNode = this.FirstNode;
            while (currentNode != null)
            {
                yield return currentNode.Value;
                currentNode = currentNode.Next;
            }
        }

        ///                 
        /// Remove the item from the linked list.  
        /// 
        public void RemoveTheRef(ref Node<T> Node)
        {
            if (Node != null)
            {
                Node prevNode = FindPreviousNode(Node.Value);
                if (prevNode != null)
                {
                    prevNode.Next = Node.Next;
                }
                if (Node.Equals(this.FirstNode))
                {
                    this.FirstNode = Node.Next;
                }
                if (Node.Equals(this.LastNode))
                {
                    this.LastNode = prevNode;
                }
            }
            Node = null;
            this.Count--;
        }
    }

Guys, there is some problem in posting generic type. So please Replace Node to Node of T type

Happy Coding :)

Read More

Abstract Class

Abstract classes are the base class of C#. Looks good but What is abstract keyword?

So abstract is a modifier that can be used with classes, indexers, properties, methods and events.

Let's talk about Abstract Class first -

abstract class BaseClass
{

}

Using abstract keyword we can  create abstract class. These classes are always implemented in inheritance model. Some points need to remember before implementing it -

1.  Abstract classes cannot be instantiated.

2.  Abstract class may or may not contain abstract methods.

3.  Abstract classes can inherit interfaces and that class should implement all interface members.

4.  Abstract class can have public, protected constructor but still you cannot instantiate it.

5.  Abstract class can inherit Abstract class but need not to implement/override any abstract method .

6.  Child class must override all abstract methods but may override virtual methods.

7.  Abstract methods cannot mark as virtual.

8.  You cannot use private access modifier in case of abstract/virtual methods.

Point 1 - Abstract classes cannot be instantiated.

See this -

An Abstract keyword is define in a way you can create only subtype of that. This is how framework designed abstract keyword. But if I say you can create an instance of abstract class. Confused ??
 

public MainClass()
{
    BaseClass obj = new ChildClass();
}

Yes Base class can be instantiated through child class only.

Point 2 - Abstract classes may or may not contain abstract methods.

As code mentioned in above example my abstract class doesn't have any abstract method. I do not get any compile time error for the same.

Point 3 - Abstract classes may can inherit interfaces and that class should implement all interface members

So if you do not implement interface members in abstract class it will give you a compile time error. 

 

Point 4 - Abstract class can have public, protected or private constructor but still you cannot instantiate it.

public abstract class BaseClass
{
        public BaseClass()
        {

        }

        private BaseClass(string name)
        { 
        
        }

        protected BaseClass(string name, string instantiatedFor)
        { 
            
        }

        void MYMethod()
        { 
            
        }
 }

After defining these constructors you still cannot instantiate it by default. 

So what is the use case of defining these constructors in the abstract class ?

Child classes can pass some data to base class to initialize it. Let's say child classes want to initialize base
class with their name to track the object.

Point 5 - Abstract class can inherit Abstract class.

Yes Abstract class can inherit abstract class but they need not to override any method defined in super base class. See below image for more understanding.

Point 6 - Child classes must override all abstract methods but may override virtual methods.

See the below example for more understanding -

public abstract class BaseClass1
{
    public abstract void MyMethod();
}

public abstract class BaseClass2 : BaseClass1
{
    public virtual void MyMethod2()
    { 
      //some base implementation.
    }
}

public class ChildCLass : BaseClass2
{ 
    
}

So in case you have some base implementation and you do not want to override it in child class then mark it as virtual so marking it virtual you are explaining to CLI. You may or may not override this method. So to fix this error -

public class ChildCLass : BaseClass2
{
     public override void MyMethod()
     {
           //Some implementation
     }
}

Point 7 - Abstract methods cannot mark as virtual.

See the compile time error for more understanding

Point 8 - You cannot use private access modifier in case of abstract/virtual methods.

 

See below screenshot for more understanding -

Hope you enjoyed reading this article. Drop a comment if you still have some confusion.

Happy Coding :)

 

Read More