using System.CodeDom.Compiler;
    using Microsoft.CSharp;
    using Microsoft.VisualBasic;

 CompilerParameters cparams = new CompilerParameters();
 
 cparams.GenerateInMemory = false;
 cparams.IncludeDebugInformation = true;
 cparams.CompilerOptions += " /debug:pdbonly";
 
 cparams.TreatWarningsAsErrors = false;
 cparams.GenerateExecutable = false;

CodeDomProvider provider = CSharpCodeProvider();
CompilerResults result = provider.CompileAssemblyFromFile(cparams, script);

        [DllImport("Kernel32.dll", EntryPoint = "GetPrivateProfileStringW", SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern int GetPrivateProfileString(string lpAppName,
                                                         string lpKeyName,
                                                         string lpDefault,
                                                         [In, Out] char[] lpReturnString,
                                                         int nSize,
                                                         string lpFilename);

        private string[] GetPrivateProfileString(string appName, string keyName, string defaultName, string inifile)
        {
            // the file inifile should exist as it's validated in the class constructor, however GetPrivateProfileString does not lock the file hence it could be locked or deleted by
            // another process between calls to this method
 
            // used to tell if we successfully read all requested data from the file 
            // from MSDN:
            //  If neither lpAppName nor lpKeyName is NULL and the supplied destination buffer is too small to hold the requested string, the string is truncated and followed by a null character, and the return value is equal to nSize minus one.
            //  If either lpAppName or lpKeyName is NULL and the supplied destination buffer is too small to hold all the strings, the last string is truncated and followed by two null characters. In this case, the return value is equal to nSize minus two.
            int sizeReadOffset = (appName != null && keyName != null) ? 1 : 2;
 
            // try and read the entire amount of data from the ini file
            int sizeRead = Kernel32.GetPrivateProfileString(appName, keyName, defaultName, _readBuffer, _readBufferSize, inifile);
 
            // if unable to read all of the data because the buffer is to small, increase the size and try again, but only allow memory to increase up to _readBufferMaxSize
            while ((sizeRead >= _readBufferSize - sizeReadOffset) && (_readBufferSize < _readBufferMaxSize))
            {
                _readBufferSize += 512;
                _readBuffer = new char[_readBufferSize];
 
                sizeRead = Kernel32.GetPrivateProfileString(appName, keyName, defaultName, _readBuffer, _readBufferSize, inifile);
            }
 
            // if memory consumption exceeded _readBufferMaxSize then we have a problem
            if (_readBufferSize >= _readBufferMaxSize)
                throw new FileLoadException("ErrorBadIniLoad");
 
            // the buffer returned from GetPrivateProfileString will be null terminated C-strings followed by a double null at the end - so split the strings on the nulls
            char[] sep = new char[1];
            sep[0] = '\0';
 
            string s = new string(_readBuffer, 0, sizeRead);
 
            string[] result = s.Split(sep, StringSplitOptions.RemoveEmptyEntries);
 
            return result;
        }

[StructLayout(LayoutKind.Sequential)]
private struct RECT
{
public int left;
      public int top;
      public int right;
      public int bottom;
}
 
[StructLayout(LayoutKind.Sequential)]
private struct APPBARDATA
{
public Int32 cbSize;
      public IntPtr hWnd;
      public Int32 uCallbackMessage;
      public ABEdge uEdge;
      public RECT rc;
      public IntPtr lParam;
}
 
private enum ABMsg
{
ABM_NEW = 0,
      ABM_REMOVE = 1,
      ABM_QUERYPOS = 2,
      ABM_SETPOS = 3,
      ABM_GETSTATE = 4,
      ABM_GETTASKBARPOS = 5,
      ABM_ACTIVATE = 6,
      ABM_GETAUTOHIDEBAR = 7,
      ABM_SETAUTOHIDEBAR = 8,
      ABM_WINDOWPOSCHANGED = 9,
      ABM_SETSTATE = 10
}
 
private enum ABEdge
{
ABE_LEFT = 0,
      ABE_TOP = 1,
      ABE_RIGHT = 2,
      ABE_BOTTOM = 3,
}
 
private enum ABState
{
ABS_MANUAL = 0,
      ABS_AUTOHIDE = 1,
      ABS_ALWAYSONTOP = 2,
      ABS_AUTOHIDEANDONTOP = 3
}
 
[DllImport("shell32.dll")]
private static extern IntPtr SHAppBarMessage(ABMsg dwMessage, [In, Out] ref APPBARDATA pData);

[DllImport("user32.dll")]
private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
 
APPBARDATA appBar = new APPBARDATA();
 
appBar.hWnd = FindWindow("Shell_TrayWnd", "");
appBar.cbSize = Marshal.SizeOf(appBar);
 
System.IntPtr ret = SHAppBarMessage(ABMsg.ABM_GETTASKBARPOS, ref appBar);
 
Size s = new Size(appBar.rc.right - appBar.rc.left, appBar.rc.bottom - appBar.rc.top);

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Drawing;
 
namespace TaskbarInfoExample
{
    /// <summary>
    /// Provides methods for obtaining and modifying information for the system taskbar.
    /// </summary>
    class TaskBar
    {
        #region Native API
        // The native API functions/enums/structs needed to access taskbar info
        // consult MSDN for more detailed information about them
        [StructLayout(LayoutKind.Sequential)]
        private struct RECT
        {
            public int left;
            public int top;
            public int right;
            public int bottom;
        }
 
        [StructLayout(LayoutKind.Sequential)]
        private struct APPBARDATA
        {
            public Int32 cbSize;
            public IntPtr hWnd;
            public Int32 uCallbackMessage;
            public ABEdge uEdge;
            public RECT rc;
            public IntPtr lParam;
        }
 
        private enum ABMsg
        {
            ABM_NEW = 0,
            ABM_REMOVE = 1,
            ABM_QUERYPOS = 2,
            ABM_SETPOS = 3,
            ABM_GETSTATE = 4,
            ABM_GETTASKBARPOS = 5,
            ABM_ACTIVATE = 6,
            ABM_GETAUTOHIDEBAR = 7,
            ABM_SETAUTOHIDEBAR = 8,
            ABM_WINDOWPOSCHANGED = 9,
            ABM_SETSTATE = 10
        }
 
        private enum ABEdge
        {
            ABE_LEFT = 0,
            ABE_TOP = 1,
            ABE_RIGHT = 2,
            ABE_BOTTOM = 3,
        }
 
        private enum ABState
        {
            ABS_MANUAL = 0,
            ABS_AUTOHIDE = 1,
            ABS_ALWAYSONTOP = 2,
            ABS_AUTOHIDEANDONTOP = 3
        }
 
        [DllImport("shell32.dll")]
        private static extern IntPtr SHAppBarMessage(ABMsg dwMessage, [In, Out] ref APPBARDATA pData);
 
        [DllImport("user32.dll")]
        private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
        #endregion
 
        /// <summary>
        /// Represents the edge of the screen the task bar is docked to.
        /// </summary>
        public enum TaskBarEdge
        {
            Left = ABEdge.ABE_LEFT,
            Top = ABEdge.ABE_TOP,
            Right = ABEdge.ABE_RIGHT,
            Bottom = ABEdge.ABE_BOTTOM
        }
 
        /// <summary>
        /// The states the task bar can be in.
        /// </summary>
        [Flags]
        public enum TaskBarState
        {
            /// <summary>
            /// No autohide, not always top
            /// </summary>
            None = ABState.ABS_MANUAL,
 
            /// <summary>
            /// Hides task bar when mouse exits task bar region
            /// </summary>
            AutoHide = ABState.ABS_AUTOHIDE,
 
            /// <summary>
            /// Taskbar is always on top of other windows
            /// </summary>
            AlwaysTop = ABState.ABS_ALWAYSONTOP
        }
 
        /// <summary>
        /// Gets the location, in screen coordinates of the task bar.
        /// </summary>
        /// <returns>The taskbar location.</returns>
        public static Point GetTaskBarLocation()
        {
            APPBARDATA appBar = GetTaskBarData();
 
            return new Point(appBar.rc.left, appBar.rc.top);
        }
 
        /// <summary>
        /// Gets the size, in pixels of the task bar.
        /// </summary>
        /// <returns>The taskbar size.</returns>
        public static Size GetTaskBarSize()
        {
            APPBARDATA appBar = GetTaskBarData();
 
            return new Size(appBar.rc.right - appBar.rc.left, appBar.rc.bottom - appBar.rc.top);
        }
 
        /// <summary>
        /// Gets the edge of the screen that the task bar is docked to.
        /// </summary>
        /// <returns></returns>
        public static TaskBarEdge GetTaskBarEdge()
        {
            APPBARDATA appBar = GetTaskBarData();
 
            return (TaskBarEdge)appBar.uEdge;
        }
 
        /// <summary>
        /// Gets the current state of the taskbar.
        /// </summary>
        /// <returns></returns>
        public static TaskBarState GetTaskBarState()
        {
            APPBARDATA appBar = CreateAppBarData();
 
            return (TaskBarState)SHAppBarMessage(ABMsg.ABM_GETSTATE, ref appBar);
        }
 
        /// <summary>
        /// Sets the state of the task bar.
        /// </summary>
        /// <param name="state">The new state.</param>
        public static void SetTaskBarState(TaskBarState state)
        {
            APPBARDATA appBar = CreateAppBarData();
 
            appBar.lParam = (IntPtr)state;
 
            SHAppBarMessage(ABMsg.ABM_SETSTATE, ref appBar);
        }
 
        /// <summary>
        /// Gets an APPBARDATA struct with valid location,size,and edge of the taskbar.
        /// </summary>
        /// <returns></returns>
        private static APPBARDATA GetTaskBarData()
        {
            APPBARDATA appBar = CreateAppBarData();
 
            System.IntPtr ret = SHAppBarMessage(ABMsg.ABM_GETTASKBARPOS, ref appBar);
 
            return appBar;
        }
 
        /// <summary>
        /// Creats an APPBARDATA struct with its hWnd member set to the task bar window.
        /// </summary>
        /// <returns></returns>
        private static APPBARDATA CreateAppBarData()
        {
            APPBARDATA appBar = new APPBARDATA();
 
            appBar.hWnd = FindWindow("Shell_TrayWnd", "");
            appBar.cbSize = Marshal.SizeOf(appBar);
 
            return appBar;
        }
    }
}

Process.Start( "Notepad.exe" );

Process p = Process.Start( "Notepad.exe");
 
p.WaitForExit();

// launch the program / process on a new thread from the thread pool
ThreadPool.QueueUserWorkItem( (WaitCallback)delegate(object state)
{
    ProcessStartInfo psi = new ProcessStartInfo("Notepad.exe", "");
 
    Process p = Process.Start(psi);
 
    p.WaitForExit();
});

ProcessStartInfo psi = new ProcessStartInfo("Notepad.exe", @"C:\My\Path\MyFile.txt");
 
Process p = Process.Start(psi);

ProcessStartInfo psi = new ProcessStartInfo(@"C:\My\Path\MyFile.txt");
psi.Verb = "print";
 
Process p = Process.Start(psi);
 
p.WaitForExit();

Process[] processes = Process.GetProcesses();
 
foreach( Process process in processes )
   listBox1.Items.Add( process.ProcessName );

/// <summary>
/// Saves a screen capture in the specified image format to a file.
/// </summary>
/// <param name="filename"></param>
/// <param name="format"></param>
private void SaveScreenShot(string filename, ImageFormat format)
{
        Bitmap screenShot = CaptureScreenShot();
 
  	screenShot.Save(filename, format);
}
 
/// <summary>
/// Saves a picture of the screen to a bitmap image.
/// </summary>
/// <returns>The saved bitmap.</returns>
private Bitmap CaptureScreenShot()
{
 	// get the bounding area of the screen containing (0,0)
        // remember in a multidisplay environment you don't know which display holds this point
    	Rectangle bounds = Screen.GetBounds(Point.Empty);
 
    	// create the bitmap to copy the screen shot to
   	Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height);
 
    	// now copy the screen image to the graphics device from the bitmap
   	using (Graphics gr = Graphics.FromImage(bitmap))
   	{
       	   gr.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);
   	}
 
  	return bitmap;
}

//save screen shot in PNG image format
SaveScreenShot("MyScreenShot.png", ImageFormat.Png);

/// <summary>
/// Saves a screen capture of the specified control to a file.
/// </summary>
/// <param name="control"></param>
/// <param name="filename"></param>
/// <param name="format"></param>
private void SaveControlShot(Control control, string filename, ImageFormat format)
{
   	Bitmap controlShot = CaptureControlShot(control);
 
   	controlShot.Save(filename, format);
}
 
/// <summary>
/// Gets a bitmap image of the specified control.
/// </summary>
/// <param name="control"></param>
/// <returns></returns>
private Bitmap CaptureControlShot(Control control)
{
        // get control bounding rectangle
     	Rectangle bounds = control.Bounds;
 
   	// create the new bitmap that holds the image of the control
     	Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height);
 
   	// copy controls image data to the bitmaps graphics device
    	using (Graphics gr = Graphics.FromImage(bitmap))
    	{
        	gr.CopyFromScreen(control.Location, Point.Empty, bounds.Size);
     	}
 
    	return bitmap;
}

// if "this" is a control, like a form
SaveControlShot(this, "MyControlShot.png", ImageFormat.Png);

Thread myThread = new Thread(MyThreadFunction);
myThread.Start();
 
private void MyThreadFunction()
{
   MessageBox.Show("HI");
}

Thread myThread = new Thread(MyThreadFunction);
myThread.Start("HELLO WORLD");
 
private void MyThreadFunction(object x)
{
   MessageBox.Show(x as string);
}

myThread = new Thread(MyThreadFunction);
myThread.Start("HELLO WORLD");
 
myThread.Join();
 
MessageBox.Show("ALL DONE!");
 
//-elsewhere
private void MyThreadFunction(object x)
{
   MessageBox.Show(x as string);
}

myThread.Abort();

XmlTextReader xmlreader = new XmlTextReader(“MyWebService” + "?wsdl");
 
ServiceDescription serviceDescription = ServiceDescription.Read(xmlreader);
 
// build an importer, that assumes the SOAP protocol, client binding, and generates properties
ServiceDescriptionImporter descriptionImporter = new ServiceDescriptionImporter();
descriptionImporter.ProtocolName = "Soap";
descriptionImporter.AddServiceDescription(serviceDescription, null, null);
descriptionImporter.Style = ServiceDescriptionImportStyle.Client;
descriptionImporter.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;

// a namespace and compile unit are needed by importer
CodeNamespace codeNamespace = new CodeNamespace();
CodeCompileUnit codeUnit = new CodeCompileUnit();
 
codeUnit.Namespaces.Add(codeNamespace);
 
ServiceDescriptionImportWarnings importWarnings = descriptionImporter.Import(codeNamespace, codeUnit);
 
if (importWarnings == 0) // no warnings
{
     // create a c# compiler
     CodeDomProvider compiler = CodeDomProvider.CreateProvider("CSharp");
 
     // include the assembly references needed to compile
     string[] references = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
 
     CompilerParameters parameters = new CompilerParameters(references);
 
     // compile into assembly
     CompilerResults results = compiler.CompileAssemblyFromDom(parameters, codeUnit);
 
     foreach (CompilerError oops in results.Errors)
     {
          // trap these errors and make them available to exception object
          throw new Exception("Compilation Error Creating Assembly");
     }
 
     // all done....
     return results.CompiledAssembly;
}
else
{
     // warnings issued from importers, something wrong with WSDL
     throw new Exception("Invalid WSDL");
}

object obj = this.webServiceAssembly.CreateInstance(serviceName);
 
Type type = obj.GetType();
 
return (T)type.InvokeMember(methodName, BindingFlags.InvokeMethod, null, obj, args);

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Web.Services;
using System.Web.Services.Description;
using System.Web.Services.Discovery;
using System.Xml;
 
namespace DynamicWebExample
{
    class WebServiceInvoker
    {
        Dictionary<string, Type> availableTypes;
 
        /// <summary>
        /// Text description of the available services within this web service.
        /// </summary>
        public List<string> AvailableServices
        {
            get{ return this.services; }
        }
 
        /// <summary>
        /// Creates the service invoker using the specified web service.
        /// </summary>
        /// <param name="webServiceUri"></param>
        public WebServiceInvoker(Uri webServiceUri)
        {
            this.services = new List<string>(); // available services
            this.availableTypes = new Dictionary<string, Type>(); // available types
 
            // create an assembly from the web service description
            this.webServiceAssembly = BuildAssemblyFromWSDL(webServiceUri);
 
            // see what service types are available
            Type[] types = this.webServiceAssembly.GetExportedTypes();
 
            // and save them
            foreach (Type type in types)
            {
                services.Add(type.FullName);
                availableTypes.Add(type.FullName, type);
            }
        }
 
        /// <summary>
        /// Gets a list of all methods available for the specified service.
        /// </summary>
        /// <param name="serviceName"></param>
        /// <returns></returns>
        public List<string> EnumerateServiceMethods(string serviceName)
        {
            List<string> methods = new List<string>();
 
            if (!this.availableTypes.ContainsKey(serviceName))
                throw new Exception("Service Not Available");
            else
            {
                Type type = this.availableTypes[serviceName];
 
                // only find methods of this object type (the one we generated)
                // we don't want inherited members (this type inherited from SoapHttpClientProtocol)
                foreach (MethodInfo minfo in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly))
                    methods.Add(minfo.Name);
 
                return methods;
            }
        }
 
        /// <summary>
        /// Invokes the specified method of the named service.
        /// </summary>
        /// <typeparam name="T">The expected return type.</typeparam>
        /// <param name="serviceName">The name of the service to use.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="args">The arguments to the method.</param>
        /// <returns>The return value from the web service method.</returns>
        public T InvokeMethod<T>( string serviceName, string methodName, params object[] args )
        {
            // create an instance of the specified service
            // and invoke the method
            object obj = this.webServiceAssembly.CreateInstance(serviceName);
 
            Type type = obj.GetType();
 
            return (T)type.InvokeMember(methodName, BindingFlags.InvokeMethod, null, obj, args);
        }
 
        /// <summary>
        /// Builds the web service description importer, which allows us to generate a proxy class based on the 
        /// content of the WSDL described by the XmlTextReader.
        /// </summary>
        /// <param name="xmlreader">The WSDL content, described by XML.</param>
        /// <returns>A ServiceDescriptionImporter that can be used to create a proxy class.</returns>
        private ServiceDescriptionImporter BuildServiceDescriptionImporter( XmlTextReader xmlreader )
        {
            // make sure xml describes a valid wsdl
            if (!ServiceDescription.CanRead(xmlreader))
                throw new Exception("Invalid Web Service Description");
 
            // parse wsdl
            ServiceDescription serviceDescription = ServiceDescription.Read(xmlreader);
 
            // build an importer, that assumes the SOAP protocol, client binding, and generates properties
            ServiceDescriptionImporter descriptionImporter = new ServiceDescriptionImporter();
            descriptionImporter.ProtocolName = "Soap";
            descriptionImporter.AddServiceDescription(serviceDescription, null, null);
            descriptionImporter.Style = ServiceDescriptionImportStyle.Client;
            descriptionImporter.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;
 
            return descriptionImporter;
        }
 
        /// <summary>
        /// Compiles an assembly from the proxy class provided by the ServiceDescriptionImporter.
        /// </summary>
        /// <param name="descriptionImporter"></param>
        /// <returns>An assembly that can be used to execute the web service methods.</returns>
        private Assembly CompileAssembly(ServiceDescriptionImporter descriptionImporter)
        {
            // a namespace and compile unit are needed by importer
            CodeNamespace codeNamespace = new CodeNamespace();
            CodeCompileUnit codeUnit = new CodeCompileUnit();
 
            codeUnit.Namespaces.Add(codeNamespace);
 
            ServiceDescriptionImportWarnings importWarnings = descriptionImporter.Import(codeNamespace, codeUnit);
 
            if (importWarnings == 0) // no warnings
            {
                // create a c# compiler
                CodeDomProvider compiler = CodeDomProvider.CreateProvider("CSharp");
 
                // include the assembly references needed to compile
                string[] references = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
 
                CompilerParameters parameters = new CompilerParameters(references);
 
                // compile into assembly
                CompilerResults results = compiler.CompileAssemblyFromDom(parameters, codeUnit);
 
                foreach (CompilerError oops in results.Errors)
                {
                    // trap these errors and make them available to exception object
                    throw new Exception("Compilation Error Creating Assembly");
                }
 
                // all done....
                return results.CompiledAssembly;
            }
            else
            {
                // warnings issued from importers, something wrong with WSDL
                throw new Exception("Invalid WSDL");
            }
        }
 
        /// <summary>
        /// Builds an assembly from a web service description.
        /// The assembly can be used to execute the web service methods.
        /// </summary>
        /// <param name="webServiceUri">Location of WSDL.</param>
        /// <returns>A web service assembly.</returns>
        private Assembly BuildAssemblyFromWSDL(Uri webServiceUri)
        {
            if (String.IsNullOrEmpty(webServiceUri.ToString()))
                throw new Exception("Web Service Not Found");
 
            XmlTextReader xmlreader = new XmlTextReader(webServiceUri.ToString() + "?wsdl");
 
            ServiceDescriptionImporter descriptionImporter = BuildServiceDescriptionImporter(xmlreader);
 
            return CompileAssembly(descriptionImporter);
        }
 
        private Assembly webServiceAssembly;
        private List<string> services;
    }
}

WebServiceInvoker invoker = new WebServiceInvoker(new Uri("http://localhost/services/test.php"));
 
string service = “MyService”;
string method = “MyMethod”;
 
string[] args = new string[] { “arg1”, “arg2” };
 
string result = invoker.InvokeMethod<string>(service, method, args);