ASP.NET, SQL Server, WPF, C#, VB.NET

using System;
using System.Drawing;
using System.Drawing.Imaging; 
using System.Windows.Forms;
using System.Text;
using System.Collections;
using System.IO;
using System.Reflection; 
using MyApplication;
 
namespace MyApplication
{
 
   public class HandSignature : System.Windows.Forms.Form
   {
 
     static void Main() 
     {
       Application.Run(new HandSignature());
     }

      private string SignatureBackgroundImageFileName="signhere.png";
      private string SignatureFileName="Signature.txt";
      private string AppPath=Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase);
      private System.Windows.Forms.Button butNew;
      private System.Windows.Forms.Panel areaSignature;
      private System.Windows.Forms.Button butSave;
      private System.Windows.Forms.Button butLoad;

      SignatureControl MySignature;
 
      public HandSignature()
      {
 
        InitializeComponent();

        try
        {
				 
          MySignature = new SignatureControl(AppPath,SignatureBackgroundImageFileName);
          MySignature.Location = areaSignature.Location;
          MySignature.Size = areaSignature.Size;
			
          this.Controls.Add(MySignature);
			
        }
        catch (Exception err) { MessageBox.Show(err.Message); }
      }
        
      protected override void Dispose( bool disposing )
      {
        base.Dispose( disposing );
      }
    
      private void HandSignature_Load(object sender, System.EventArgs e)
      {
        MySignature.Clear(true); 
      }
    
      private void butNew_Click(object sender, System.EventArgs e)
      {
        MySignature.Clear(true);
      }
     
      private void butSave_Click(object sender, System.EventArgs e)
      {
        try
        {
          Cursor.Current = Cursors.WaitCursor;
          MySignature.Save(Path.Combine(AppPath,SignatureFileName));
          MySignature.Clear(false);
        }
        catch (Exception ex)
        {
          MessageBox.Show(ex.Message);
        }
        finally
        {
          Cursor.Current = Cursors.Default;
        }
      }
    
      private void butLoad_Click(object sender, System.EventArgs e)
      {
        try
        {
          Cursor.Current = Cursors.WaitCursor;
          MySignature.Clear(false);
          MySignature.Load(Path.Combine(AppPath,SignatureFileName));
          MySignature.DrawSignature(); 
        }
        catch (Exception ex)
        {
          MessageBox.Show(ex.Message);
        }
        finally
        {
          Cursor.Current = Cursors.Default;
        }
       }
		 
  }	 
}
		 

using System;
using System.Drawing;
using System.Drawing.Imaging; 
using System.Windows.Forms;
using System.Text;
using System.Collections;
using System.IO;
using System.Reflection; 

namespace MyApplication
{ 
	 
  public class SignatureControl : Control
  {

    private ArrayList Points = new ArrayList();
    private Bitmap BackGroundImage;
    private Graphics GraphicsHandle;
    private Pen SignaturePen = new Pen(Color.Black);
    private Point LastMouseCoordinates = new Point(0,0);
    private bool CaptureMouseCoordinates = false;
    private string AppPath="";
    private string ImageFileName="";
    private string Delimiter=",";
		
    private struct LineToDraw
    { 
      public int StartX;
      public int StartY;
      public int EndX;
      public int EndY;
    }
		 
    public SignatureControl(string ApplicationPath,string BaseImageFileName)
    {
      AppPath = ApplicationPath; 
      ImageFileName = BaseImageFileName;
    }

    protected override void OnPaint(PaintEventArgs e) 
    {
      LoadBackgroundImageIfInvalid();
      e.Graphics.DrawImage(BackGroundImage, 0, 0);			 
    }

    protected override void OnPaintBackground(PaintEventArgs e) 
    {
			
    }

    protected override void OnMouseDown(MouseEventArgs e) 
    {
      base.OnMouseDown(e);

      if (CaptureMouseCoordinates) { return; }
      
      CaptureMouseCoordinates = true;
      LastMouseCoordinates.X = e.X;
      LastMouseCoordinates.Y = e.Y;

    }

    protected override void OnMouseUp(MouseEventArgs e) 
    {
      base.OnMouseUp(e);
      CaptureMouseCoordinates = false;	
    }

    protected override void OnMouseMove(MouseEventArgs e)
    {
      base.OnMouseMove(e);			

      if (!CaptureMouseCoordinates) { return; }

      LineToDraw l = new LineToDraw();

      l.StartX = LastMouseCoordinates.X;
      l.StartY = LastMouseCoordinates.Y;
      l.EndX = e.X;
      l.EndY = e.Y;

      Points.Add(l);
 
      GraphicsHandle.DrawLine(SignaturePen, l.StartX, l.StartY, l.EndX,l.EndY);

      LastMouseCoordinates.X = l.EndX;
      LastMouseCoordinates.Y = l.EndY;
			 
      Invalidate();
           
    }

    public void DrawSignature()
    {
      LineToDraw l;

      try
      {
        if (Points.Count < 1) { return; } 

        for(int i=0;i<Points.Count;i++)
        {
          l = (LineToDraw)Points[i];
          GraphicsHandle.DrawLine(SignaturePen, l.StartX, l.StartY, l.EndX,l.EndY);
        }

        Invalidate();
      }
      catch (Exception) { throw; }
    }

    public void Save(string FileName)
    {
      LineToDraw l;

      try
      {

        if (Points.Count < 1) { return; } 
  
        StreamWriter sw = new StreamWriter(FileName,false);
  
        for(int i=0;i<Points.Count;i++)
        {
          l = (LineToDraw)Points[i];
          sw.Write(l.StartX.ToString() + Delimiter);
          sw.Write(l.StartY.ToString() + Delimiter);
          sw.Write(l.EndX.ToString() + Delimiter);
          sw.WriteLine(l.EndY.ToString());
        }
 
        sw.Close(); 
				 
      }
      catch (Exception) { throw; }
    }

    public void Load(string FileName)
    {
      LineToDraw l;

      try
      {

        this.Clear(true);
  
        StreamReader sr = new StreamReader(FileName);

        string line;
	 
        while ((line = sr.ReadLine()) != null)
        {

          l = new LineToDraw();
				   
          string[] linesplit = line.Split(Delimiter.ToCharArray());
  
          l.StartX = int.Parse(linesplit[0].ToString());
          l.StartY = int.Parse(linesplit[1].ToString());
          l.EndX = int.Parse(linesplit[2].ToString());
          l.EndY = int.Parse(linesplit[3].ToString());
          Points.Add(l); 
        }
 
        sr.Close(); 
				 
      }
      catch (Exception) { throw; }
    }


    public void Clear(bool ClearCapturedLines)
    {
       try
       {
          LoadBackgroundImage();
          Invalidate();
          if (ClearCapturedLines == false) { return; }
          Points.Clear();
       }
       catch (Exception) { throw; }
    }

    private void LoadBackgroundImageIfInvalid()
    {
      try
      {
        if (BackGroundImage == null || BackGroundImage.Width != this.Width || BackGroundImage.Height != this.Height)
        {
          LoadBackgroundImage();
        }
      }
      catch (Exception) { throw; }
     }

     private void LoadBackgroundImage()
     {
       try
       {
         BackGroundImage = new Bitmap(Path.Combine(AppPath,ImageFileName));   
         GraphicsHandle = Graphics.FromImage(BackGroundImage);
       }
       catch (Exception) { throw; }
     }


 }
	 
}