C#

private void btnSave_Click(object sender, EventArgs e)
        {
            DataRow row = ds.Tables[0].NewRow();
            row[1] = txtFirstName.Text;
            row[2] = txtSurname.Text;
            row[3] = txtJobTitle.Text;
            row[4] = txtDepartment.Text;
            ds.Tables[0].Rows.Add(row);
            
            try
            {
                objConnect.UpdateDatabase(ds);

                MaxRows = MaxRows + 1;
                inc = MaxRows - 1;

                MessageBox.Show("Database updated");
            }
            catch (Exception err)
            {

                MessageBox.Show(err.Message);

            }
            btnCancel.Enabled = false;
            btnSave.Enabled = false;
            btnAddNew.Enabled = true;
        }

public class MyPdfPageEventHelpPageNo : iTextSharp.text.pdf.PdfPageEventHelper
  {
            public override void OnStartPage(PdfWriter writer, Document document)
            {
                /// my code
            }
  }

class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Exercise 24.10 - Quicksort\n\n");

        Quicksort sort = new Quicksort(12);

        Console.WriteLine("Unsorted: {0}\n", sort);

        sort.Sort();

        Console.WriteLine("\n  Sorted: " + sort);

        Console.Write("\nPress any key to continue . . . ");
        Console.ReadKey(true);
    }
}

class Quicksort
{
	private int[] data;
	private Random rng = new Random();
	
	public Quicksort(int size)
	{
		data = new int[size];
		//Test Data from TextBook:
		//data = new int[] {37, 2, 6, 4, 89, 8, 10, 12, 68, 45};

		// Generate some Random Data
		for(int i=0; i<data.Length;i++)
			data[i]=rng.Next(0,100);
		
	} // end constructor
	
	public void Sort()
	{
		// Calls the 'private' recursive Quicksort method
		recSort(0, data.Length-1);
	}
	
	private void recSort(int left, int right)
	{
		// Recursively calls itself until the pointers collide
		// And as the partitioning works in-place there's no
		// writing at the end, the array is already sorted
		if(left<right) {
			int pivot = Partition(left, right); 
			recSort(left, pivot-1);
			recSort(pivot+1, right);
		}

	}
	
	private int Partition(int left, int right)
	{
		// Takes the leftmost value of our input array
		// and puts it in its correct final position
		// ie. all values larger than it above and all values
		// lower than it below
		
		int i=left;		// i is our bot->top travelling "pointer"
		int j=right+1;	// j if our top->bot travelling "pointer"
		int pivot = data[left];
		
		while(i<j) {
			do {
				j--;
			} while (data[i]<data[j]);
			
			if(i<j)
				Swap(i,j);
			
			do {
				i++;
			} while (data[j]>data[i]);
			
			if(i<j)
				Swap(i,j);
		}
		
		return j;
	}
	
	private void Swap(int i, int j)
	{
		int temp=data[i];
		data[i]=data[j];
		data[j]=temp;
		// DEBUG: Uncomment to show swap details
		//Console.WriteLine  ("SW {0:00}/{1:00}: {2}",data[j], data[i],this.ToString());
	}
	
	public override string ToString()
	{
		// Display a pretty version of the array
		StringBuilder temp = new StringBuilder((data.Length*6)+1);
		
		for(int i=0; i<data.Length; i++)
			temp.AppendFormat("[{0:00}] ", data[i]);
		
		return temp.ToString();
	}

} // end class

Exercise 24.10 - Quicksort


Unsorted: [64] [48] [79] [43] [75] [54] [81] [94] [75] [66] [57] [61]

SW 64/61: [61] [48] [79] [43] [75] [54] [81] [94] [75] [66] [57] [64]
SW 79/64: [61] [48] [64] [43] [75] [54] [81] [94] [75] [66] [57] [79]
SW 64/57: [61] [48] [57] [43] [75] [54] [81] [94] [75] [66] [64] [79]
SW 75/64: [61] [48] [57] [43] [64] [54] [81] [94] [75] [66] [75] [79]
SW 64/54: [61] [48] [57] [43] [54] [64] [81] [94] [75] [66] [75] [79]
SW 61/54: [54] [48] [57] [43] [61] [64] [81] [94] [75] [66] [75] [79]
SW 54/43: [43] [48] [57] [54] [61] [64] [81] [94] [75] [66] [75] [79]
SW 57/54: [43] [48] [54] [57] [61] [64] [81] [94] [75] [66] [75] [79]
SW 81/79: [43] [48] [54] [57] [61] [64] [79] [94] [75] [66] [75] [81]
SW 94/81: [43] [48] [54] [57] [61] [64] [79] [81] [75] [66] [75] [94]
SW 81/75: [43] [48] [54] [57] [61] [64] [79] [75] [75] [66] [81] [94]
SW 79/66: [43] [48] [54] [57] [61] [64] [66] [75] [75] [79] [81] [94]
SW 75/75: [43] [48] [54] [57] [61] [64] [66] [75] [75] [79] [81] [94]

  Sorted: [43] [48] [54] [57] [61] [64] [66] [75] [75] [79] [81] [94]

// Do you want to del prev data?
            if (selResult == DialogResult.OK)
            {
                DialogResult dr = MessageBox.Show("Do you want to delete previous data?", "Delete?", MessageBoxButtons.YesNo);
                if (dr == DialogResult.OK)
                {
                    try
                    {
                        File.Delete("data.txt");
                    }
                    catch(IOException copyError)
                    {
                        MessageBox.Show(copyError.ToString());
                    }

                    StreamWriter sw0 = new StreamWriter("data.txt", true);
                    sw0.Close();

                }else if(dr == DialogResult.No)
                {
                    MessageBox.Show("Cancelled");
                    return;
                }