C#

WebRequest and WebResponse classes are part of the System.Net namespace and the System.Net.Requests.dll and System.dll assemblies.They are used on the client for connecting to a server using HTTP or FTP protocol.

WebClient encapsulates the WebRequest and WebResponse classes and so makes it easier to work with the WebRequest and WebResponse classes.

HttpClient class is used for working with HTTP based services such as WebAPI.HttpClient includes many async methods such as GetAsync(Uri) and PostAsync(String, HttpContent).It is part of the System.Net.Http namespace.

To access a URL and fetch response using WebRequest and WebResponse classes follow the below steps:

1.Create an instance of the WebRequest object.Normally Create() method with URL as the argument is used to create an instance of WebRequest derived class.Since WebRequest is an abstract class so a derived class of WebRequest such as HttpWebRequest is used.

WebRequest reqObj = WebRequest.Create("http://www.example.com");

If you see the value of the reqObj at runtime you can see that it includes lots of useful properties:

If you see the type of the reqObj you will get the following response showing that the type of reqObj is HttpWebRequest.

{Name = “HttpWebRequest” FullName = “System.Net.HttpWebRequest”}

2.Once the WebRequest instance is created call the GetResponse() method using that instance.

WebResponse resObj = reqObj.GetResponse();

The above code will call the url which we passed in the create() method in step 1.We are assigning the returned value of the GetResponse() method to WebResponse object.WebResponse is an abstract class.So a derived class object is used depending on the scenario such as FileWebResponse or HttpWebResponse.Here the derived class is HttpWebResponse.

Like the WebRequest class ,the WebResponse class includes many useful properties:

3.Finally close the WebResponse object to clean the system resources.

resObj .Close();

ashish

QuickSort is one of the most popular sorting algorithms.It is based on the principle of divide and conquer.In simple words Quicksort uses partition based on pivot to sort an array.Elements in one array are greater than the pivot element while elements in the other array are smaller than the pivot element.The algorithm calls itself recursively.

There are two main functionalities in QuickSort algorithm:

Partition algorithm  It divides elements into smaller and larger elements based on the pivot

Sorting algorithm  It calls itself by passing the following parameters:

• Beginning value
• Ending value
• Pivot Index

In simple words Partition algorithm can be described as:

1. Pass low index and high index along with array.If the array has 5 elements then low index will be 0 and high index will be 4.
2. Set pivot element at any position in the array.For example you can set pivot to first element,middle element or last element.
3. Initialise tracking Index variable which represents the number of exchanges made in the array.This should be initialised to 0.
4. Loop from low index to high index.So in this case loop from index = 0 to index = 5
5. If current element is less than or equal to pivot then exchange the current element with the element at tracking Index.
6. Exchange tracking variable with the element at high index

Quciksort algorithm can be described as:

1. Pass the array and the begin and end parameters.begin and end are the beginning and end of the array which we want to
   partition.
2. Call partition method and fetch index returned by it.
3. Call quick sort two times.First call it by passing array ,low and pivot -1
4. Secondly call it with array,pivot+1 and high

You can implement QuickSort in C# as:

static int PartitionArray(int[] arr, int beginingIndex,int endIndex)
{
int pivot = arr[endIndex];

int swapIndex = (beginingIndex - 1);
for (int elementIndex = beginingIndex; elementIndex < endIndex; elementIndex++)
{
//compare pivot element
if (arr[elementIndex] <= pivot)
{
swapIndex++;

// swap arr[i] and arr[j]
int temp = arr[swapIndex];
arr[swapIndex] = arr[elementIndex];
arr[elementIndex] = temp;
}
}

int temp1 = arr[swapIndex + 1];
arr[swapIndex + 1] = arr[endIndex];
arr[endIndex] = temp1;

return swapIndex + 1;
}

public static void QuickSort(int[] arrObj, int beginIndex, int endIndex)
{
if (beginIndex < endIndex)
{

int pivot = PartitionArray(arrObj, beginIndex, endIndex);

// Recursively call quicksort method
QuickSort(arrObj, beginIndex, pivot - 1);
QuickSort(arrObj, pivot + 1, endIndex);
}
}

ashish