C#

<appSettings>
  <add key="yourkey" value="yourvalue" />
</appSettings>

System.Configuration.ConfigurationSettings.AppSettings["yourkey"];

static FileInfo FindFile(string startDirectory, string extension)
{
	DirectoryInfo di = new DirectoryInfo(startDirectory);
	foreach(FileInfo fi in di.GetFiles())
	{
		if(fi.Extension.ToLower() == extension)
			return fi;
	}
	return null;
}

static DirectoryInfo FindDirectory(string startDirectory, string dirNameToSearch)
{
	DirectoryInfo di = new DirectoryInfo(startDirectory);
	foreach(DirectoryInfo diSearch in di.GetDirectories())
	{
		if(diSearch.Name == dirNameToSearch)
		        return diSearch;
	}
	return null;
}

string strSQL = "SELECT * FROM MyTable WHERE username = '" +<br />
Request.Form["username"] + "'";<br />
<br />
if (db.Execute().Rows.Count != 1) // Asuming that db.Execute is executing strSQL and that it returns a DataTable (if it returns a DataSet u need to do db.Execute().Tables[0].Rows.Count).<br />
// Now do the insert<br />
else<br />
Response.Write ("Record exists");

Tech, life, family, faith: Give me a visit.
I'm currently blogging about: Islamic Domination: Coming to a Jewish state near you!
The apostle Paul, modernly speaking: Epistles of Paul

Judah Himango

using System;
using System.Runtime.InteropServices;

namespace Communication
{
	public enum Parity
	{
		No = 0,
		Odd,
		Even,
		Mark,
		Space
	}

	public class CommPort
	{
		public int PortNum;
		public int BaudRate;
		public byte ByteSize;
		private byte parity; // 0-4=no,odd,even,mark,space 
		public byte StopBits; // 0,1,2 = 1, 1.5, 2 
		public int ReadTimeout;

		//comm port win32 file handle
		private int hComm = -1;

		public bool Opened = false;

		//win32 api constants
		private const uint GENERIC_READ = 0x80000000;
		private const uint GENERIC_WRITE = 0x40000000;
		private const int OPEN_EXISTING = 3;
		private const int INVALID_HANDLE_VALUE = -1;

		public Parity Parity
		{
			get
			{
				switch (parity)
				{
					case 0:
						return Parity.No;
					case 1:
						return Parity.Odd;
					case 2:
						return Parity.Even;
					case 3:
						return Parity.Mark;
					case 4:
						return Parity.Space;
					default:
						return Parity.No;
				}
			}
			set { parity = (byte) value.GetHashCode(); }
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct DCB
		{
			//taken from c struct in platform sdk 
			public int DCBlength; // sizeof(DCB) 
			public int BaudRate; // current baud rate
			/* these are the c struct bit fields, bit twiddle flag to set
			public int fBinary;          // binary mode, no EOF check 
			public int fParity;          // enable parity checking 
			public int fOutxCtsFlow;      // CTS output flow control 
			public int fOutxDsrFlow;      // DSR output flow control 
			public int fDtrControl;       // DTR flow control type 
			public int fDsrSensitivity;   // DSR sensitivity 
			public int fTXContinueOnXoff; // XOFF continues Tx 
			public int fOutX;          // XON/XOFF out flow control 
			public int fInX;           // XON/XOFF in flow control 
			public int fErrorChar;     // enable error replacement 
			public int fNull;          // enable null stripping 
			public int fRtsControl;     // RTS flow control 
			public int fAbortOnError;   // abort on error 
			public int fDummy2;        // reserved 
			*/
			public uint flags;
			public ushort wReserved; // not currently used 
			public ushort XonLim; // transmit XON threshold 
			public ushort XoffLim; // transmit XOFF threshold 
			public byte ByteSize; // number of bits/byte, 4-8 
			public byte Parity; // 0-4=no,odd,even,mark,space 
			public byte StopBits; // 0,1,2 = 1, 1.5, 2 
			public char XonChar; // Tx and Rx XON character 
			public char XoffChar; // Tx and Rx XOFF character 
			public char ErrorChar; // error replacement character 
			public char EofChar; // end of input character 
			public char EvtChar; // received event character 
			public ushort wReserved1; // reserved; do not use 
		}

		[StructLayout(LayoutKind.Sequential)]
		private struct COMMTIMEOUTS
		{
			public int ReadIntervalTimeout;
			public int ReadTotalTimeoutMultiplier;
			public int ReadTotalTimeoutConstant;
			public int WriteTotalTimeoutMultiplier;
			public int WriteTotalTimeoutConstant;
		}

		[StructLayout(LayoutKind.Sequential)]
		private struct OVERLAPPED
		{
			public int Internal;
			public int InternalHigh;
			public int Offset;
			public int OffsetHigh;
			public int hEvent;
		}

		[DllImport("kernel32.dll")]
		private static extern int CreateFile(
			string lpFileName, // file name
			uint dwDesiredAccess, // access mode
			int dwShareMode, // share mode
			int lpSecurityAttributes, // SD
			int dwCreationDisposition, // how to create
			int dwFlagsAndAttributes, // file attributes
			int hTemplateFile // handle to template file
			);

		[DllImport("kernel32.dll")]
		private static extern bool GetCommState(
			int hFile, // handle to communications device
			ref DCB lpDCB // device-control block
			);

		//		[DllImport("kernel32.dll")]
		//		private static extern bool BuildCommDCB(
		//			string lpDef,  // device-control string
		//			ref DCB lpDCB     // device-control block
		//			);
		[DllImport("kernel32.dll")]
		private static extern bool SetCommState(
			int hFile, // handle to communications device
			ref DCB lpDCB // device-control block
			);

		[DllImport("kernel32.dll")]
		private static extern bool GetCommTimeouts(
			int hFile, // handle to comm device
			ref COMMTIMEOUTS lpCommTimeouts // time-out values
			);

		[DllImport("kernel32.dll")]
		private static extern bool SetCommTimeouts(
			int hFile, // handle to comm device
			ref COMMTIMEOUTS lpCommTimeouts // time-out values
			);

		[DllImport("kernel32.dll")]
		private static extern bool ReadFile(
			int hFile, // handle to file
			byte[] lpBuffer, // data buffer
			int nNumberOfBytesToRead, // number of bytes to read
			ref int lpNumberOfBytesRead, // number of bytes read
			ref OVERLAPPED lpOverlapped // overlapped buffer
			);

		[DllImport("kernel32.dll")]
		private static extern bool WriteFile(
			int hFile, // handle to file
			byte[] lpBuffer, // data buffer
			int nNumberOfBytesToWrite, // number of bytes to write
			ref int lpNumberOfBytesWritten, // number of bytes written
			ref OVERLAPPED lpOverlapped // overlapped buffer
			);

		[DllImport("kernel32.dll")]
		private static extern bool CloseHandle(
			int hObject // handle to object
			);

		//		[DllImport("kernel32.dll")]
		//		private static extern uint GetLastError();

		public void Open()
		{
			DCB dcbCommPort = new DCB();
			COMMTIMEOUTS ctoCommPort = new COMMTIMEOUTS();

			// OPEN THE COMM PORT.
			hComm = CreateFile("COM" + PortNum, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);

			// IF THE PORT CANNOT BE OPENED, BAIL OUT.
			if (hComm == INVALID_HANDLE_VALUE)
			{
				throw(new ApplicationException("Comm Port Can Not Be Opened"));
			}

			// SET THE COMM TIMEOUTS.

			GetCommTimeouts(hComm, ref ctoCommPort);
			ctoCommPort.ReadTotalTimeoutConstant = ReadTimeout;
			ctoCommPort.ReadTotalTimeoutMultiplier = 0;
			ctoCommPort.WriteTotalTimeoutMultiplier = 0;
			ctoCommPort.WriteTotalTimeoutConstant = 0;
			SetCommTimeouts(hComm, ref ctoCommPort);

			// SET BAUD RATE, PARITY, WORD SIZE, AND STOP BITS.
			GetCommState(hComm, ref dcbCommPort);
			dcbCommPort.BaudRate = BaudRate;
			dcbCommPort.flags = 0;
			//dcb.fBinary=1;
			dcbCommPort.flags |= 1;
			if (Parity > 0)
			{
				//dcb.fParity=1
				dcbCommPort.flags |= 2;
			}
			dcbCommPort.Parity = parity;
			dcbCommPort.ByteSize = ByteSize;
			dcbCommPort.StopBits = StopBits;
			if (!SetCommState(hComm, ref dcbCommPort))
			{
				//uint ErrorNum=GetLastError();
				throw new Exception("Comm Port Can Not Be Opened");
			}
			//unremark to see if setting took correctly
			//DCB dcbCommPort2 = new DCB();
			//GetCommState(hComm, ref dcbCommPort2);
			Opened = true;
		}

		public void Close()
		{
			if (hComm != INVALID_HANDLE_VALUE)
			{
				CloseHandle(hComm);
			}
		}

		public byte[] Read(int NumBytes)
		{
			byte[] BufBytes;
			byte[] OutBytes;
			BufBytes = new byte[NumBytes];
			if (hComm != INVALID_HANDLE_VALUE)
			{
				OVERLAPPED ovlCommPort = new OVERLAPPED();
				int BytesRead = 0;
				ReadFile(hComm, BufBytes, NumBytes, ref BytesRead, ref ovlCommPort);
				OutBytes = new byte[BytesRead];
				Array.Copy(BufBytes, OutBytes, BytesRead);
			}
			else
			{
				throw(new ApplicationException("Comm Port Not Open"));
			}
			return OutBytes;
		}

		public void Write(byte[] WriteBytes)
		{
			if (hComm != INVALID_HANDLE_VALUE)
			{
				OVERLAPPED ovlCommPort = new OVERLAPPED();
				int BytesWritten = 0;
				WriteFile(hComm, WriteBytes, WriteBytes.Length, ref BytesWritten, ref ovlCommPort);
			}
			else
			{
				throw(new ApplicationException("Comm Port Not Open"));
			}
		}
	}
}

dt1.Columns.Remove("columnName");

------------------------------
"The Soapbox has been so ..."