Use Alter Keyword to Modify a Table. To Run Queries you have to execute  SQL Plus that comes with oracle.

The Query Below would add a field ” Identifier” of var chart type  to Table Mapping

Add Field or Column to Data Base Table Use Alter Keyword with Add

ALTER TABLE MAPPING

ADD (Identifier varChar (255));

To Drop existing Field From table Use Drop Keyword,

ALTER TABLE MAPPING

drop (Identifier );

Lets say you have a list of generic collection you can query this collection with linq and create small result

set out of this list as in example

// we use Collection Initialize

var PeopleList = new List<String> {"Ali", "Ahemed", "Anwar", "Khan", "Saleem"};

// Here comes Linq Query to extract name start with A in collection List PeopleList

var PeoplewhoseNamestartswithA = from ppl in PeopleList where ppl.StartsWith("A") select new {Name = ppl.TrimEnd()};

//Name is the variable that keep hold of the Names it could be any thing //

foreach (var ppA in PeoplewhoseNamestartswithA)
{

// Accessing item in SubList

MessageBox.Show(ppA.Name);

}

That is because in Windows 2003, all the webservice extensions are "Prohibited" by default to ensure security. so to Deploy WCF Service on Freshly Installed Windows 2003 Machine Use the instructions given below.

1. From your Run command, type inetmgr and press enter.
2. Expand the appropriate nodes in the IIS to locate the "Webservice Extensions" Node
3. Click on the same.
4. You will find a list of "prohibited" extensions in the right.
5. Click on ASP.NET and "allow" it

var Data=new List
{
new MailingList("A.R", "Suite 102", "Karachi", "Pakistan"),
new MailingList("Umair Butt", "Suite 106", "Karachi", "Pakistan"),
new MailingList("Afzal Hussain", "Suite 109", "Karachi", "Pakistan"),
new MailingList("Saleem Khan", "Suite 108", "Karachi", "Pakistan")
};

DataTable dt = GenericCollectionToDataTable.ConvertTo(Data);

public class GenericCollectionToDataTable
{
///

/// Default Constructor
///

private GenericCollectionToDataTable()
{ }
///

///
///

/// Custome Class
///
List Of The Custome Class
/// Return the class datatbl
public static DataTable ConvertTo(IList lst)
{
//create DataTable Structure
DataTable tbl = CreateTable();
Type entType = typeof(T);

PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(entType);
//get the list item and add into the list
foreach (T item in lst)
{
DataRow row = tbl.NewRow();
foreach (PropertyDescriptor prop in properties)
{
row[prop.Name] = prop.GetValue(item);
}
tbl.Rows.Add(row);
}

return tbl;
}

///

///
///

/// Custome Class
///
private static DataTable CreateTable()
{
//T –> ClassName
Type entType = typeof(T);
//set the datatable name as class name
DataTable tbl = new DataTable(entType.Name);
//get the property list
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(entType);
foreach (PropertyDescriptor prop in properties)
{
//add property as column
tbl.Columns.Add(prop.Name, prop.PropertyType);
}
return tbl;
}
}
}

private void ListPdfFormFields()
{

string pdfTemplate = Application.StartupPath + "\\a.pdf";

lstfields.Items.Clear();

// create a new PDF reader based on the PDF template document

PdfReader pdfReader = new PdfReader(pdfTemplate);

// create and populate a string builder with each of the

// field names available in the subject PDF

foreach (DictionaryEntry de in pdfReader.AcroFields.Fields)
{

var currentfield =
de.Key.ToString();

currentfield = ParseFormField(currentfield);
lstfields.Items.Add(currentfield);

}

lstfields.Sorted = true;

}

private string ParseFormField(string fieldname)
{
fieldname = fieldname.Replace("form1[0].#subform[0].", "");
fieldname = fieldname.Replace("[0]", "");
fieldname.TrimEnd();
return fieldname;
}

The CompressFile method accepts a path to the source file to compress, a path to the
destination of the compressed file, and a CompressionType enumeration value indicating
which type of compression algorithm to use (Deflate or GZip). This method produces
a file containing the compressed data.
The DecompressFile method accepts a path to the source compressed file to decompress,
a path to the destination of the decompressed file, and a CompressionType enumeration
value indicating which type of decompression algorithm to use (Deflate or GZip)

/// <summary>
/// Compress the source file to the destination file.
/// This is done in 1MB chunks to not overwhelm the memory usage.
/// </summary>
/// <param name="sourceFile">the uncompressed file</param>
/// <param name="destinationFile">the compressed file</param>
/// <param name="compressionType">the type of compression to use</param>
public static void CompressFile(string sourceFile,
string destinationFile,
CompressionType compressionType)
{
if (sourceFile != null)
{
FileStream streamSource = null;
FileStream streamDestination = null;
Stream streamCompressed = null;
try
{
streamSource = File.OpenRead(sourceFile);
streamDestination = File.OpenWrite(destinationFile);
// read 1MB chunks and compress them
long fileLength = streamSource.Length;
// write out the fileLength size
byte[] size = BitConverter.GetBytes(fileLength);
streamDestination.Write(size, 0, size.Length);

long chunkSize = 1048576; // 1MB
while (fileLength > 0)
{
// read the chunk
byte[] data = new byte[chunkSize];
streamSource.Read(data, 0, data.Length);
// compress the chunk
MemoryStream compressedDataStream =
new MemoryStream( );
if (compressionType == CompressionType.Deflate)
streamCompressed =
new DeflateStream(compressedDataStream,
CompressionMode.Compress);
else
streamCompressed =
new GZipStream(compressedDataStream,
CompressionMode.Compress);
using (streamCompressed)
{
// write the chunk in the compressed stream
streamCompressed.Write(data, 0, data.Length);
}
// get the bytes for the compressed chunk
byte[] compressedData =
compressedDataStream.GetBuffer( );
// write out the chunk size
size = BitConverter.GetBytes(chunkSize);
streamDestination.Write(size, 0, size.Length);
// write out the compressed size
size = BitConverter.GetBytes(compressedData.Length);
streamDestination.Write(size, 0, size.Length);
// write out the compressed chunk
streamDestination.Write(compressedData, 0,
compressedData.Length);
// subtract the chunk size from the file size
fileLength -= chunkSize;
// if chunk is less than remaining file use
// remaining file
if (fileLength < chunkSize)
chunkSize = fileLength;
}
}
finally
streamSource.Close( );
streamDestination.Close( );
}
}
}
/// <summary>
/// This function will decompress the chunked compressed file
/// created by the CompressFile function.
/// </summary>
/// <param name="sourceFile">the compressed file</param>
/// <param name="destinationFile">the destination file</param>
/// <param name="compressionType">the type of compression to use</param>
public static void DecompressFile(string sourceFile,
string destinationFile,
CompressionType compressionType)
{
FileStream streamSource = null;
FileStream streamDestination = null;
Stream streamUncompressed = null;
try
{
streamSource = File.OpenRead(sourceFile);
streamDestination = File.OpenWrite(destinationFile);
// read the fileLength size
// read the chunk size
byte[] size = new byte[sizeof(long)];
streamSource.Read(size, 0, size.Length);
// convert the size back to a number
long fileLength = BitConverter.ToInt64(size, 0);
long chunkSize = 0;
int storedSize = 0;
while (fileLength > 0)
{
// read the chunk size
size = new byte[sizeof(long)];
streamSource.Read(size, 0, size.Length);
// convert the size back to a number
chunkSize = BitConverter.ToInt64(size, 0);
if (chunkSize > fileLength ||
chunkSize > workingSet)
throw new InvalidDataException( );
// read the compressed size
size = new byte[sizeof(int)];
streamSource.Read(size, 0, size.Length);
// convert the size back to a number
storedSize = BitConverter.ToInt32(size, 0);

Compressing and Decompressing Your Files | 485
if (storedSize > fileLength ||
storedSize > workingSet)
throw new InvalidDataException( );
if (storedSize > chunkSize)
throw new InvalidDataException( );
byte[] uncompressedData = new byte[chunkSize];
byte[] compressedData = new byte[storedSize];
streamSource.Read(compressedData, 0,
compressedData.Length);
// uncompress the chunk
MemoryStream uncompressedDataStream =
new MemoryStream(compressedData);
if (compressionType == CompressionType.Deflate)
streamUncompressed =
new DeflateStream(uncompressedDataStream,
CompressionMode.Decompress);
else
streamUncompressed =
new GZipStream(uncompressedDataStream,
CompressionMode.Decompress);
using (streamUncompressed)
{
// read the chunk in the compressed stream
streamUncompressed.Read(uncompressedData, 0,
uncompressedData.Length);
}
// write out the uncompressed chunk
streamDestination.Write(uncompressedData, 0,
uncompressedData.Length);
// subtract the chunk size from the file size
fileLength -= chunkSize;
// if chunk is less than remaining file use remaining file
if (fileLength < chunkSize)
chunkSize = fileLength;
}
}
finally
{
streamSource.Close( );
streamDestination.Close( );
}
}
public enum CompressionType
{
Deflate,
GZip
}

Read More

using System;
using System.Collections;
using System.Collections.Generic;
static class CharStrExtMethods
{
public static int[] FindAll(this string matchStr, string searchedStr,
int startPos)
{
int foundPos = -1; // -1 represents not found.
int count = 0;
List<int> foundItems = new List<int>( );
do
{
foundPos = searchedStr.IndexOf(matchStr, startPos, StringComparison.
Ordinal);
if (foundPos > -1)
{
startPos = foundPos + 1;
count++;
foundItems.Add(foundPos);
Console.WriteLine("Found item at position: " + foundPos.
ToString( ));
}
} while (foundPos > -1 && startPos < searchedStr.Length);
return ((int[])foundItems.ToArray( ));
}