ThreadPool - QueueUserWorkItem

ThreadPool.QueueUserWorkItem

You can't use the Task Parallel Library if you're targeting an earlier version of the .NET Framework (prior to 4.0). Instead, you must use one of the older constructs for entering the thread pool: ThreadPool.QueueUserWorkItem and asynchronous delegates. The difference between the two is that asynchronous delegates let you return data from the thread. Asynchronous delegates also marshal any exception back to the caller.

QueueUserWorkItem

To use QueueUserWorkItem, simply call this method with a delegate that you want to run on a pooled thread:

static void Main()
{
  ThreadPool.QueueUserWorkItem (Go);
  ThreadPool.QueueUserWorkItem (Go, 123);
  Console.ReadLine();
}
 
static void Go (object data)   // data will be null with the first call.
{
  Console.WriteLine ("Hello from the thread pool! " + data);
}

Our target method, Go, must accept a single object argument (to satisfy the WaitCallback delegate). This provides a convenient way of passing data to the method, just like with ParameterizedThreadStart. Unlike with Task,QueueUserWorkItem doesn't return an object to help you subsequently manage execution. 

We must use WaitCallback. At MSDN, WaitCallback is described as a delegate callback method to be called when the ThreadPool executes. It is a delegate that "calls back" its argument.
WaitCallback
You can use WaitCallback by simply specifying the "new WaitCallback" syntax as the first argument to ThreadPool.QueueUserWorkItem. You don't need any other code to make this approach effective.

public partial class MainWindow : Form
{
    // This is the delegate that runs on the UI thread to update the bar.
    public delegate void BarDelegate();
 
    // The form's constructor (autogenerated by Visual Studio)
    public MainWindow()
    {
                InitializeComponent();
    }
 
    // When a buttom is pressed, launch a new thread
    private void button_Click(object sender, EventArgs e)
    {
                // Set progress bar length.
                progressBar1.Maximum = 6;
                progressBar1.Minimum = 0;
 
                // Pass these values to the thread.
                ThreadInfo threadInfo = new ThreadInfo();
                threadInfo.FileName = "file.txt";
                threadInfo.SelectedIndex = 3;
 
                ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessFile), threadInfo);
    }
 
    // What runs on a background thread.
    private void ProcessFile(object a)
    {
                // (Omitted)
                // Do something important using 'a'.
 
                // Tell the UI we are done.
                try
                {
                    // Invoke the delegate on the form.
                    this.Invoke(new BarDelegate(UpdateBar));
                }
                catch
                {
                    // Some problem occurred but we can recover.
                }
    }
 
    // Update the graphical bar.
    private void UpdateBar()
    {
                progressBar1.Value++;
                if (progressBar1.Value == progressBar1.Maximum)
                {
                    // We are finished and the progress bar is full.
                }
    }
}

Source




http://www.albahari.com/threading/#_Thread_Pooling



http://www.dotnetperls.com/threadpool

When & why to use delegates?

Say you want to write a procedure to integrate some real-valued function f (x) over some interval [a, b]. Say we want to use the 3-Point Gaussian method to do this (any will do, of course).

Ideally we want some function that looks like:

 // 'f' is the integrand we want to integrate over [a, b] with 'n' subintervals.  
 static double Gauss3(Integrand f, double a, double b, int n) {  
  double res = 0;  
  // compute result  
  // ...  
  return res;  
 } 

So we can pass in any Integrand, f, and get its definite integral over the closed interval.

Just what type should Integrand be?

Without Delegates
Well, without delegates, we'd need some sort of interface with a single method, say eval declared as follows:

// Interface describing real-valued functions of one variable.  
 interface Integrand {  
  double eval(double x);  
 }  

Then we'd need to create a whole bunch of classes implementing this interface, as follows:

// Some function  
 class MyFunc1 : Integrand {  
  public double eval(double x) {  
   return /* some_result */ ;  
  }  
 }  
 // Some other function  
 class MyFunc2 : Integrand {  
  public double eval(double x) {  
   return /* some_result */ ;  
  }  
 }  
 // etc 

Then to use them in our Gauss3 method, we need to invoke it as follows:

 double res1 = Gauss3(new MyFunc1(), -1, 1, 16);  
 double res2 = Gauss3(new MyFunc2(), 0, Math.PI, 16);  
 And Gauss3 needs to do the look like the following:  
 static double Gauss3(Integrand f, double a, double b, int n) {  
  // Use the integrand passed in:  
  f.eval(x);  
 }  

So we need to do all that just to use our arbitrary functions in Guass3.

With Delegates

 public delegate double Integrand(double x);  

Now we can define some static (or not) functions adhering to that prototype:

class Program {  
   static double MyFunc1(double x) { /* ... */ }  
   static double MyFunc2(double x) { /* ... */ }  
   // ... etc ...  
   public static double Gauss3(Integrand f, ...) {   
    // Now just call the function naturally, no f.eval() stuff.  
    double a = f(x);   
    // ...  
   }  
   // Let's use it  
   static void Main() {  
    // Just pass the function in naturally (well, its reference).  
    double res = Gauss3(MyFunc1, a, b, n);  
    double res = Gauss3(MyFunc2, a, b, n);    
   }  
 }  

No interfaces, no clunky .eval stuff, no object instantiate, just simple function-pointer like usage, for a simple task.

Of course, delegates are more than just function pointers under the hood, but that's a separate issue (function chaining and events).

source: 
http://stackoverflow.com/questions/2019402/when-why-to-use-delegates

Differences between Abstract Factory Pattern and Factory Method

Factory Method is used to create one product only but Abstract Factory is about creating families of related or dependent products.

Factory Method pattern exposes a method to the client for creating the object whereas in case ofAbstract Factory they expose a family of related objects which may consist of these Factory methods.

Factory Method pattern hides the construction of single object where as Abstract factory method hides the construction of a family of related objects. Abstract factories are usually implemented using (a set of) factory methods.

AbstractFactory pattern uses composition to delegate responsibility of creating object to another class while Factory design pattern uses inheritance and relies on derived class or sub class to create object.

The idea behind the Factory Method pattern is that it allows for the case where a client doesn't know what concrete classes it will be required to create at runtime, but just wants to get a class that will do the job while AbstractFactory pattern is best utilised when your system has to create multiple families of products or you want to provide a library of products without exposing the implementation details.!

Factory Pattern Implementation: 

AbstractFactory Pattern Implementation:

Full list of Design Patterns

To See the connection opened in Unix Terminal.

Use this command –

netstat -nputw

If you are looking for particular IP address or key then Grep it as

netstat -nputw|egrep "192.0.0.1"

I use for monitoring the Connection OPEN and CLOSE status.

In one of my project huge one, I got an exception “12 - too many connections “ .  I was sure about the connection Open() and Close()  and the calling place was right.

To test if there is anything missing from human eye. I had restarted the application and parallel to that  I was running netstat command to watch opened connection is closing or not. 

Load an icon file embedded in your executable

When you are developing a Windows Forms application in .NET, it’s not immediately obvious how to programatically load an icon file embedded in your executable.

This recipe shows you the 1 line solution.

Your icon file should be a regular windows icon file. Add it to your project, and in the properties for the icon make sure that it is set to Embedded Resource.

Now in your code, add the following line:

     public static NotifyIcon icon;  
     protected override void OnStartup(StartupEventArgs e)  
     {       
       App.icon = new NotifyIcon();  
       icon.Click += new EventHandler(icon_Click);       
       icon.Icon = new Icon(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("WorkingHours.time_n.ico"));          
       //icon.Icon = new System.Drawing.Icon(@"icon\time_n.ico");  
       icon.BalloonTipIcon = System.Windows.Forms.ToolTipIcon.Info;  
       icon.Visible = true;         
       base.OnStartup(e);  
     } 

You should now be able to use the icon directly in any windows control that uses icons, like the NotifyIcon control.

Allowing only one instance of a WPF application to execute

Sometimes, for any reason, you want to have only one instance per application.

Search on the internet and you will find many different ways of doing this. However, inside Jeffrey Ricther’s excellent book there is a way of allowing only one instance of an application (Console, WinForms, WPF) to execute at any given time using kernel-mode constructs.

Using what has been described in the book and searching at P/Invoke.net, I wrote some code that works with WPF applications. The code also attempts to set focus on the window and if it’s minimized it will attempt to restore it. 

 using System;  
 using System.Collections.Generic;  
 using System.Configuration;  
 using System.Data;  
 using System.Linq;  
 using System.Windows;  
 using System.Diagnostics;  
 using System.Runtime.InteropServices;  
 using System.Reflection;  
 using System.Threading;  
 using System.Windows;  
 namespace WorkingHours  
 {  
   /// <summary>  
   /// Interaction logic for App.xaml  
   /// </summary>  
   public partial class App : Application  
   {  
     private static readonly Semaphore singleInstanceWatcher;  
     private static readonly bool createdNew;  
     static App()  
     {  
       // Ensure other instances of this application are not running.  
       singleInstanceWatcher = new Semaphore(  
         0, // Initial count.  
         1, // Maximum count.  
         Assembly.GetExecutingAssembly().GetName().Name,  
         out createdNew);  
       if (createdNew)  
       {  
         // This thread created the kernel object so no other instance  
         // of this application must be running.  
       }  
       else  
       {  
         // This thread opened an existing kernel object with the same  
         // string name; another instance of this app must be running now.  
         // Gets a new System.Diagnostics.Process component and the  
         // associates it with currently active process.  
         Process current = Process.GetCurrentProcess();  
         // Enumerate through all the process resources on the share  
         // local computer that the specified process name.  
         foreach (Process process in  
            Process.GetProcessesByName(current.ProcessName))  
         {  
           if (process.Id != current.Id)  
           {  
             NativeMethods.SetForegroundWindow(  
               process.MainWindowHandle);  
             NativeMethods.ShowWindow(process.MainWindowHandle,  
               WindowShowStyle.Restore);  
             break;  
           }  
         }  
         // Terminate this process and gives the underlying operating   
         // system the specified exit code.  
         Environment.Exit(-2);  
       }  
     }  
     private static class NativeMethods  
     {  
       /// <summary>  
       /// Brings the thread that created the specified window into the  
       /// foreground and activates the window. Keyboard input is directed  
       /// to the window, and various visual cues are changed for the user.  
       /// The system assigns a slightly higher priority to the thread that  
       /// created the foreground window than it does to other threads.  
       /// </summary>  
       /// <param name="hWnd">A handle to the window that should be  
       /// activated and brought to the foreground.  
       /// </param>  
       /// <returns>If the window was brought to the foreground, the  
       /// return value is nonzero. </returns>  
       [DllImport("user32.dll")]  
       internal static extern bool SetForegroundWindow(IntPtr hWnd);  
       /// <summary>Shows a Window</summary>  
       /// <remarks>  
       /// <para>To perform certain special effects when showing or hiding a  
       /// window, use AnimateWindow.</para>  
       /// <para>The first time an application calls ShowWindow, it should use  
       /// the WinMain function's nCmdShow parameter as its nCmdShow ..  
       /// Subsequent calls to ShowWindow must use one of the values in the  
       /// given list, instead of the one specified by the WinMain function's  
       /// nCmdShow parameter.</para>  
       /// <para>As noted in the discussion of the nCmdShow parameter, the  
       /// nCmdShow value is ignored in the first call to ShowWindow if the  
       /// program that launched the application specifies startup information  
       /// in the structure. In this case, ShowWindow uses the information  
       /// specified in the STARTUPINFO structure to show the window. On  
       /// subsequent calls, the application must call ShowWindow with ..  
       /// set to SW_SHOWDEFAULT to use the startup information provided by ..  
       /// program that launched the application. This behavior is designed ..  
       /// the following situations: </para>  
       /// <list type="">  
       ///  <item>Applications create their main window by calling ..  
       ///  with the WS_VISIBLE flag set. </item>  
       ///  <item>Applications create their main window by calling ..  
       ///  with the WS_VISIBLE flag cleared, and later call ShowWindow ..  
       ///  SW_SHOW flag set to make it visible.</item>  
       /// </list></remarks>  
       /// <param name="hWnd">Handle to the window.</param>  
       /// <param name="nCmdShow">Specifies how the window is to be shown.  
       /// This parameter is ignored the first time an application calls  
       /// ShowWindow, if the program that launched the application provides a  
       /// STARTUPINFO structure. Otherwise, the first time ShowWindow .. ,  
       /// the value should be the value obtained by the WinMain function ..  
       /// nCmdShow parameter. In subsequent calls, this parameter ..  
       /// the WindowShowStyle members.</param>  
       /// <returns>  
       /// If the window was previously visible, the return value is nonzero.  
       /// If the window was previously hidden, the return value is zero.  
       /// </returns>  
       [DllImport("user32.dll")]  
       internal static extern bool ShowWindow(IntPtr hWnd,  
         WindowShowStyle nCmdShow);  
     }  
     /// <summary>  
     /// Enumeration of the different ways of showing a window.</summary>  
     internal enum WindowShowStyle : uint  
     {  
       /// <summary>Hides the window and activates another window.</summary>  
       /// <remarks>See SW_HIDE</remarks>  
       Hide = 0,  
       /// <summary>Activates and displays a window. If the window ..  
       /// or maximized, the system restores it to its original size and  
       /// position. An application should specify this flag when displaying  
       /// the window for the first time.</summary>  
       /// <remarks>See SW_SHOWNORMAL</remarks>  
       ShowNormal = 1,  
       /// <summary>Activates the window and displays it ..</summary>  
       /// <remarks>See SW_SHOWMINIMIZED</remarks>  
       ShowMinimized = 2,  
       /// <summary>Activates the window and displays it ..</summary>  
       /// <remarks>See SW_SHOWMAXIMIZED</remarks>  
       ShowMaximized = 3,  
       /// <summary>Maximizes the specified window.</summary>  
       /// <remarks>See SW_MAXIMIZE</remarks>  
       Maximize = 3,  
       /// <summary>Displays a window in its most recent size and position.  
       /// This value is similar to "ShowNormal", except the window is not  
       /// actived.</summary>  
       /// <remarks>See SW_SHOWNOACTIVATE</remarks>  
       ShowNormalNoActivate = 4,  
       /// <summary>Activates the window and displays it in its current size  
       /// and position.</summary>  
       /// <remarks>See SW_SHOW</remarks>  
       Show = 5,  
       /// <summary>Minimizes the specified window and activates the next  
       /// top-level window in the Z order.</summary>  
       /// <remarks>See SW_MINIMIZE</remarks>  
       Minimize = 6,  
       /// <summary>Displays the window as a minimized window. This value is  
       /// similar to "ShowMinimized", except the window ..</summary>  
       /// <remarks>See SW_SHOWMINNOACTIVE</remarks>  
       ShowMinNoActivate = 7,  
       /// <summary>Displays the window in its current size and position. This  
       /// value is similar to "Show", except the window ..</summary>  
       /// <remarks>See SW_SHOWNA</remarks>  
       ShowNoActivate = 8,  
       /// <summary>Activates and displays the window. If the window is  
       /// minimized or maximized, the system restores it to its original size  
       /// and position. An application should specify this flag ..  
       /// a minimized window.</summary>  
       /// <remarks>See SW_RESTORE</remarks>  
       Restore = 9,  
       /// <summary>Sets the show state based on the SW_ value specified ..  
       /// STARTUPINFO structure passed to the CreateProcess function by the  
       /// program that started the application.</summary>  
       /// <remarks>See SW_SHOWDEFAULT</remarks>  
       ShowDefault = 10,  
       /// <summary>Windows 2000/XP: Minimizes a window, even if the thread  
       /// that owns the window is hung. This flag should only be used when  
       /// minimizing windows from a different thread.</summary>  
       /// <remarks>See SW_FORCEMINIMIZE</remarks>  
       ForceMinimized = 11  
     }  
     //protected override void OnStartup(StartupEventArgs e)  
     //{  
     //  // Get Reference to the current Process  
     //  Process thisProc = Process.GetCurrentProcess();  
     //  // Check how many total processes have the same name as the current one  
     //  if (Process.GetProcessesByName(thisProc.ProcessName).Length > 1)  
     //  {  
     //    // If ther is more than one, than it is already running.  
     //    MessageBox.Show("Application is already running.");  
     //    Application.Current.Shutdown();    
     //    return;  
     //  }  
     //  base.OnStartup(e);  
     //}  
   }  
 }  

One improvement would be to restore the window only if it’s minimized by checking the return value of SetForegroundWindow method. I leave this to you, go on and adapt it to your own needs.