Implementing Multithreading

Hi ,

In the last post I discussed about what multi-threading is all about.
Please refer to "Understanding Multi-Threading in C#" in case you need to know about it.
This blog is all about the implementation of the same.

Too implement Multi-threading we make use of Thread class which is present in "System.Threading" namespace.
To make a portion of code to be implemented in separate thread(also known as worker thread) we need to have that chunk of code in another method.
For example:
If our existing program looks like this:

    class Program
    {
        public static void Main()
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine(i);
            }
            Console.WriteLine("Rest of the code");
        }
     }

then in order to make use of another thread we need to have an extra method which will run as the thread.
so the above code will be changed to :

    class Program
    {
        public static void Main() 
        {
            ForMyNewThread(); //just a dummy name;u may give ur pets name too ;)
            Console.WriteLine("Rest of the code");
        }

        private static void ForMyNewThread()
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine(i);
            }
        }
     }

Now, we need to pass this method(ForMyNewThread) to the constructor of the Thread class, so that our method can act like a Thread.
Note: Please don't forget to include System.Threading name space;

so our code looks like this now:

public static void Main()
        {
             Thread Mythread = new Thread(ForMyNewThread);
            Mythread.Start();
            Console.WriteLine("Rest of the code");
    
        }

        private static void ForMyNewThread()
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine(i);
            }
        }

"Start()" is used to make the Thread functional,if we don't give start the thread will not get started and the our program will return just  "Rest of the code".

I strongly recommend you to try the above example one to have a better understanding.

If you actually try the above example(which u should :p ), u may see that the constructor of the Thread class has four overloads, which expect either "ThreadStart" or "ParameterisedThreadStart".

So what are these and why we got the output without passing the above in our previous example!!???

Magic!! Nah doesn't happen in real life! :-P

Actually "ThreadStart" and "ParameterisedThreadStart" are delegates.

If you don't know what are delegates, then it is advised to see my post named,"Real Use Of Delegates", where I have explained properly what and why should we use Delegates.


So coming back to our current topic :p ;)


Now as we know thread is basically a method which will have a chunk of code in it which will be executed when thread.start() is invoked.

but how do we point a method to thread!! Please note that i wrote "point a method"!!..can you recollect something!!? ..Yes you are right a Delegate(Function pointer!).So a Thread class uses Delegate to point to a particular method.

But how did it work before !!
we didn't passed any delegate there, it is because .Net framework is doing it by itself!!(cool right!, at least if you are a lazy person like me you would love this feature of .Net framework )



Program with the delegate:

   public static void Main()

        {

           

            Console.WriteLine("Rest of the code");

            Thread Mythread = new Thread(new ThreadStart(ForMyNewThread));

            Mythread.Start();

        }

        private static void ForMyNewThread()

        {

            for (int i = 1; i <= 10; i++)

            {

                Console.WriteLine(i);

            }

        }

the output remains the same.

Wondering what is "ParameterizedThreadStart delegate"!!?
If we want to pass some data to the method we make use of ParameterizedThreadStart.

 class Program
    {
        public static void Main()
        {
            Console.WriteLine("Please enter a number for which you want to see all the natural numbers less than or equal to the number");
            object target = Console.ReadLine();
            Thread T1 = new Thread(new ParameterizedThreadStart(ForMyNewThread));
           T1.Start(target);
        }
        public static void ForMyNewThread(object target)
        {
            int numberEnteredByUser = 0;
            if (int.TryParse(target.ToString(), out numberEnteredByUser))
            {
                for (int i = 1; i <= numberEnteredByUser; i++)
                {
                    Console.WriteLine(i);
                }
            }
        }
    }

Here in this program we are prompting the user to enter a number of his choice and we will display all the natural numbers less than or equal to the Entered number.
As you may see we can pass the data in Start() method itself.

Hope This is clear.
Do leave your comments if you need any clarification.

Regards,
Ashish Agarwal

Understanding Multi-Threading in C#

What is a thread???

Definition: Thread is a light weight process or it can be seen as a subset of process.

wondering what is process!!?
well process is a program which the operating system runs, in order to execute the set of instruction given to it. You may go to task manager(press ctrl+shift+del) and see large number of  processes running on the machine.
Now each process has at least one thread which is commonly called as main thread.A process can have one or more threads.

So what is Multi threading and why do we use it?

Many a times there will be a chunk of code which may take more time to execute and hence makes your application less responsive(slow). In order to prevent this we go for the concept of multi threading.

Let us understand with the help of a day to day life scenario!

"We all have been to schools,colleges or some coaching institutes or say to a place where you need take admission.
Imagine yourself sitting with a person(X) who is responsible to give you all the information about the institute, and you being a very serious candidate(just imagine ;)) ask 100s of questions . For this the person X has to be very very responsive! Or else he may loose other candidates or his manager may fire him!(sounds terrible right!,managers are always harsh!) now obviously if you have to take admission ,there is a need to fill the application form and again it is the responsibility of the institute to do so.
Now imagine person X filling the form as well as responding to our queries side by side!! what do you think what will happen? Can he be responsive with a lengthy task of filling your details!?
Not actually! So what can his manager do?? The manager may allocate another Person(Y) the job of filling your form and let Mr. X concentrate on your queries! This way both the jobs will be done smoothly.
Now imagine person X as your main process(Thread) which has a lengthy and time consuming logic of filling the form which may decrease the responsiveness of X, and now you are the manager(kind one for a change)! so you can create a new thread(Person Y) and assign the lengthy job to it so that your thread(X) is responsive as well as the task of filling the form is also completed!
This way your program will be super cool and you as a Manager will be cool dude! ;)
"

Hope it is clear!


Regards,
Ashish Agarwal

Real Use Of Delegates

Understanding Delegates:

Hi Readers,

Today I want to take a very confusing topic.(At least was for me, when I first went through it).
It is bit Confusing, as many of us actually don't know what is the use of  Delegates or in what scenarios it should be used.

Now if you search about Delegates, you would get something  like,"Delegates are function Pointers!"
So what actually is a function pointer?
As the name suggests it may be a reference to a function!
True indeed,but why shall we use it?

For the Readers for whom concept of delegate is completely new, I request them to read from "Delegate Explanation Start" to "Delegate Explanation End " first ,others can Skip this block. 

Delegate Explanation Start:
Prerequisite: Some knowledge about OOPS. :)

Well a delegate is a type safe function pointer. i.e  it holds a reference (pointer) to a function.
Wondering what is type safe!?
The signature of the delegate must match the signature of the function, the delegate points to,otherwise you will get a compilier eror.
This is the reason delegates are called type safe function pointers.
Delegates are of Reference type,so you need to create an instance of it and pass a function as the parameter to its constructor.
This is how we declare a delegate:
Access Specifier delegate ReturnType Name(Method Reference).
Example:

public delegate void MyFirstDelegate(string Message);

class Test
{
    public static void Main()
    {
        MyFirstDelegate myDel = new  MyFirstDelegate(Yo);
        myDel ("Delegates are awesome");
    }
    public static void Yo(string strMessge)
    {
        Console.WriteLine(strMessge);
    }
}

If you run the above code, as you may expect you would get result as "Delegates are awesome".
This is the basics of how delegates work.
But did you understand why shall we use delegates ? It looks idiotic to create a method(here "Yo") then create instance of a delegate(MyFirstDelegate) and then passing the method(Yo), Isn't it??
You may argue that we could have directly created an instance of the "Test" class and call the method! then why the heck we have to use delegate?? Just a stupid concept!!??
Not actually!
Please Read the below Explanation. "Real Use of Delegates":) ;)

Delegate Explanation End. 

Real Use of Delegates:

Now lets Assume that you are a Project head of a Products Company(Sounds good right! ;)).
And you are responsible to create a product which returns the Employees' name of different organisation who are eligible for promotion.
Obviously different organisations may have different criteria to promote its Employees,in that case we cant hard code the logic in our base product, as we have to sell it to different organisation and hard coding the logic for one organisation would mean creating 'n' number of products for 'n' number of organisations!! Which we obviously don't wanna do.
Then want can be done in this scenario!!?? Any idea?

Surprisingly,Delegates are the go to Concept!
how?
Lets see ;):

   #region GenericLogic //think of this as a Product

    #region--a generic function pointer
    public delegate Boolean Promotable(Employee emp);
    #endregion


    public class Employee
    {
        public int ID { get; set; }

        public string Name { get; set; }
        public int Salary { get; set; }
        public int Experience { get; set; }
        public void PromoteEmployee(List<Employee> empList,Promotable obj)
   //need the list of Employees and the logic
        {
            foreach(Employee emp in empList)
            {
                if (obj(emp))
                {
                    Console.WriteLine("{0} is Promoted",emp.Name);
                }
            }
        }
    }
    #endregion

Think of region "GenericLogic"  as our Product, which we will be selling.

Here you can see that our Product just needs  the list of employees of the organisation and the logic for promoting those employees.
So now we would ask our client to just give there employee list and the logic specific to there organisation so that they would get the Employee Names who are eligible foe promotion.

What client will do? :

They would just call the Delegate and pass there own logic!!

   public class ClientClass
    {
   
        public static void Main(string[] args)
       {

           #region company has to call the product's method to get the list of Employees Eligible for promotion by giving its internal logic and its employees

           #region company forming an employee list //this is Private data of company!!
           List<Employee> empList = new List<Employee>();
           empList.Add(new Employee()
           {
               ID = 1,
               Name = "asd",
               Experience = 4,
               Salary = 123
           }
                       );
           empList.Add(new Employee()
           {
               ID = 1,
               Name = "ashish",
               Experience = 7,
               Salary = 123567
           });
           empList.Add(new Employee()
           {
               ID = 1,
               Name = "asddfg",
               Experience = 14,
               Salary = 12453
           });
           empList.Add(new Employee()
           {
               ID = 1,
               Name = "asdff",
               Experience = 3,
               Salary = 23
           });
           #endregion

           #region now the company has to have a method(logic) for the promotion of its employees,

           Promotable obj3 = new Promotable(Test.IsPromotable); //making use of Product's Delegate,pls find the logic of IsPromotable
           #endregion

           #region now passing the values to the shared function to the product
           Employee obj = new Employee();
           obj.PromoteEmployee(empList, obj3);
           #endregion

           #endregion
}
        #region IsPromotable Method--logic of a particular company to promote its employees
        public static Boolean IsPromotable(Employee Emp)
        {
            if (Emp.Experience >= 5)
            {
                return true;
            }
            else
                return false;
        }
        #endregion
     
    }

#endregion

Now each and Every client may have different logic to promote there Employees!.
so ,they can just provide there logic to the base product and get the output!.


I hope it is clear.
Please Leave your comments ! :)

Thank you.
Regards,
Ashish Agarwal