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.

Bridge

Defination: Decouple an abstraction from its implementation so that the two can vary independently.
 

This structural code demonstrates the Bridge pattern which separates (decouples) the interface from its implementation. The implementation can evolve without changing clients which use the abstraction of the object.

// Bridge pattern -- Structural example  
 using System;  
 namespace DoFactory.GangOfFour.Bridge.Structural  
 {  
  /// <summary>  
  /// MainApp startup class for Structural  
  /// Bridge Design Pattern.  
  /// </summary>  
  class MainApp  
  {  
   /// <summary>  
   /// Entry point into console application.  
   /// </summary>  
   static void Main()  
   {  
    Abstraction ab = new RefinedAbstraction();  
    // Set implementation and call  
    ab.Implementor = new ConcreteImplementorA();  
    ab.Operation();  
    // Change implemention and call  
    ab.Implementor = new ConcreteImplementorB();  
    ab.Operation();  
    // Wait for user  
    Console.ReadKey();  
   }  
  }  
  /// <summary>  
  /// The 'Abstraction' class  
  /// </summary>  
  class Abstraction  
  {  
   protected Implementor implementor;  
   // Property  
   public Implementor Implementor  
   {  
    set { implementor = value; }  
   }  
   public virtual void Operation()  
   {  
    implementor.Operation();  
   }  
  }  
  /// <summary>  
  /// The 'Implementor' abstract class  
  /// </summary>  
  abstract class Implementor  
  {  
   public abstract void Operation();  
  }  
  /// <summary>  
  /// The 'RefinedAbstraction' class  
  /// </summary>  
  class RefinedAbstraction : Abstraction  
  {  
   public override void Operation()  
   {  
    implementor.Operation();  
   }  
  }  
  /// <summary>  
  /// The 'ConcreteImplementorA' class  
  /// </summary>  
  class ConcreteImplementorA : Implementor  
  {  
   public override void Operation()  
   {  
    Console.WriteLine("ConcreteImplementorA Operation");  
   }  
  }  
  /// <summary>  
  /// The 'ConcreteImplementorB' class  
  /// </summary>  
  class ConcreteImplementorB : Implementor  
  {  
   public override void Operation()  
   {  
    Console.WriteLine("ConcreteImplementorB Operation");  
   }  
  }  
 }  

// Bridge pattern -- Real World example  
 using System;  
 using System.Collections.Generic;  
 namespace DoFactory.GangOfFour.Bridge.RealWorld  
 {  
  /// <summary>  
  /// MainApp startup class for Real-World  
  /// Bridge Design Pattern.  
  /// </summary>  
  class MainApp  
  {  
   /// <summary>  
   /// Entry point into console application.  
   /// </summary>  
   static void Main()  
   {  
    // Create RefinedAbstraction  
    Customers customers = new Customers("Chicago");  
    // Set ConcreteImplementor  
    customers.Data = new CustomersData();  
    // Exercise the bridge  
    customers.Show();  
    customers.Next();  
    customers.Show();  
    customers.Next();  
    customers.Show();  
    customers.Add("Henry Velasquez");  
    customers.ShowAll();  
    // Wait for user  
    Console.ReadKey();  
   }  
  }  
  /// <summary>  
  /// The 'Abstraction' class  
  /// </summary>  
  class CustomersBase  
  {  
   private DataObject _dataObject;  
   protected string group;  
   public CustomersBase(string group)  
   {  
    this.group = group;  
   }  
   // Property  
   public DataObject Data  
   {  
    set { _dataObject = value; }  
    get { return _dataObject; }  
   }  
   public virtual void Next()  
   {  
    _dataObject.NextRecord();  
   }  
   public virtual void Prior()  
   {  
    _dataObject.PriorRecord();  
   }  
   public virtual void Add(string customer)  
   {  
    _dataObject.AddRecord(customer);  
   }  
   public virtual void Delete(string customer)  
   {  
    _dataObject.DeleteRecord(customer);  
   }  
   public virtual void Show()  
   {  
    _dataObject.ShowRecord();  
   }  
   public virtual void ShowAll()  
   {  
    Console.WriteLine("Customer Group: " + group);  
    _dataObject.ShowAllRecords();  
   }  
  }  
  /// <summary>  
  /// The 'RefinedAbstraction' class  
  /// </summary>  
  class Customers : CustomersBase  
  {  
   // Constructor  
   public Customers(string group)  
    : base(group)  
   {  
   }  
   public override void ShowAll()  
   {  
    // Add separator lines  
    Console.WriteLine();  
    Console.WriteLine("------------------------");  
    base.ShowAll();  
    Console.WriteLine("------------------------");  
   }  
  }  
  /// <summary>  
  /// The 'Implementor' abstract class  
  /// </summary>  
  abstract class DataObject  
  {  
   public abstract void NextRecord();  
   public abstract void PriorRecord();  
   public abstract void AddRecord(string name);  
   public abstract void DeleteRecord(string name);  
   public abstract void ShowRecord();  
   public abstract void ShowAllRecords();  
  }  
  /// <summary>  
  /// The 'ConcreteImplementor' class  
  /// </summary>  
  class CustomersData : DataObject  
  {  
   private List<string> _customers = new List<string>();  
   private int _current = 0;  
   public CustomersData()  
   {  
    // Loaded from a database  
    _customers.Add("Jim Jones");  
    _customers.Add("Samual Jackson");  
    _customers.Add("Allen Good");  
    _customers.Add("Ann Stills");  
    _customers.Add("Lisa Giolani");  
   }  
   public override void NextRecord()  
   {  
    if (_current <= _customers.Count - 1)  
    {  
     _current++;  
    }  
   }  
   public override void PriorRecord()  
   {  
    if (_current > 0)  
    {  
     _current--;  
    }  
   }  
   public override void AddRecord(string customer)  
   {  
    _customers.Add(customer);  
   }  
   public override void DeleteRecord(string customer)  
   {  
    _customers.Remove(customer);  
   }  
   public override void ShowRecord()  
   {  
    Console.WriteLine(_customers[_current]);  
   }  
   public override void ShowAllRecords()  
   {  
    foreach (string customer in _customers)  
    {  
     Console.WriteLine(" " + customer);  
    }  
   }  
  }  
 }  

Design Pattern eBook

High rated ebook of Design patterns for beginners.

http://www.jtbookyard.com/uploads/6/2/9/3/6293106/head_first_design_pattern.pdf

Change string type list to type integer

You can use List.ConvertAll<int>:

List<int> ints = list2.ConvertAll<int>(int.Parse);
If you don't have a list you could use a Select with int.Parse:

List<int> ints = strings.Select(s=> int.Parse(s)).ToList();