using System;
using System.ComponentModel;
using System.Diagnostics;
/// <summary>
/// Summary description for Class1
/// </summary>
public class Class1
{
/*********************************************************************
* Quick Pastes:
*********************************************************************/
#region private members
#region public properties
#region constructors
#region private methods
#region public methods
#region properties
/*********************************************************************
* Array Methods:
* BinarySearch GetLength IsFixedSize Rank
* Clear GetLowerBound IsReadOnly Reverse
* Copy GetUpperBound IsSynchronized SetValue
* CreateInstance IndexOf LastIndexOf Sort
* GetEnumerator Initialize Length SyncRoot
* // http://en.csharp-online.net/index.php?title=CSharp_Code_Snippets
*********************************************************************/
private void Arrays() {
int i;
int[] a;
int[] b = new int[20]; // elements initialize to null
int[,] c;
int[,] d = new int[10,20];
int[] primes = {2, 3, 5, 7, 11, 13, 17,};
a = new int[10];
System.Array.Copy(primes, 0, a, 0, 2);
for (i = 0; i < a.Length; i++) a[i] = i;
foreach (int j in a) a[j] = j;
int[][] e = new int[10][]; // multidimensional arrays do not have to be rectangular
for (i = 0; i < e.Length; i++) e[i] = new int[i+1];
}
/*********************************************************************
* Array Reverse:
*********************************************************************/
public string Reverse(string x)
{
char[] charArray = new char[x.Length];
int len = x.Length – 1;
for (int i = 0; i <= len; i++)
charArray[i] = x[len-i];
return new string(charArray);
}
public string Reverse( string x )
{
char[] charArray = x.ToCharArray();
Array.Reverse(charArray);
return new string(charArray);
}
// http://en.csharp-online.net/index.php?title=CSharp_Code_Snippets
private void ReverseArray(string[] arr)
{
string[] strings = {“beta”, “alpha”, “gamma”};
Array.Reverse (strings); // Reverse element order
foreach (object o in strings)
{
Console.Write (“{0} “, o);
}
}
/*********************************************************************
* Array Copy:
*********************************************************************/
private void CopyArray(string[] arr)
{
int[] integers = new int[] { 5, 10, 15 };
double[] doubles = new double[3];
Array.Copy(integers, doubles, 2);
foreach (int integer in integers)
{
Console.Write(“{0,3}”, integer);
}
foreach (double duble in doubles)
{
Console.Write(“{0,3}”, duble);
}
}
/*********************************************************************
* Array Sort:
*********************************************************************/
private static void SortArray(string[] arr)
{
string[] strings = { “beta”, “alpha”, “gamma” };
Array.Sort(strings); // Sort elements
foreach (object o in strings)
{
Console.Write(“{0} “, o);
}
}
private void FindCommonValues()
{
object[] objects = { 1, 2, 4, 8 };
DisplayMatches(objects, new object[] { 0, 1, 5, 8 });
string[] strings = { “one”, “two”, “four”, “eight” };
DisplayMatches(strings,
new string[] { “zero”, “one”, “five”, “eight” });
}
private void DisplayMatches(IList iList, object[] objects)
{
foreach (object o in objects)
{
if (iList.Contains(o))
{
Console.WriteLine(“iList contains {0}”, o);
}
}
}
/*********************************************************************
* Array Load:
*********************************************************************/
int[] numbers;
private void SingleDimArrayApp()
{
numbers = new int[6];
for (int i = 0; i < 6; i++)
{
numbers[i] = i * i;
}
}
protected void PrintArray()
{
for (int i = 0; i < numbers.Length; i++)
{
Console.WriteLine(“numbers[{0}]={1}”, i, numbers[i]);
}
}
int range1 = 10;
int range2 = 20;
double[,] sales;
private void MultiDimArrayApp()
{
sales = new double[range1, range2];
for (int i = 0; i < sales.GetLength(0); i++)
{
for (int j = 0; j < sales.GetLength(1); j++)
{
// put a value in the array location
sales[i,j] = (i * 1) + j;
}
}
PrintSales();
}
private void PrintSales()
{
for (int i = 0; i < sales.GetLength(0); i++)
{
for (int j = 0; j < sales.GetLength(1); j++)
{
Console.WriteLine(“[{0}][{1}]={2}”, i, j, sales[i,j]);
}
}
}
//Fill an array with prime numbers
private void CreatePrimeNumbers()
{
const int UPPER_LIMIT = 1000;
int primes = 0;
BitArray candidates = new BitArray(UPPER_LIMIT, true);
for (int i = 2; i < UPPER_LIMIT; i++)
{
if (candidates[i])
{
for (int j = i * 2; j < UPPER_LIMIT; j += i)
{
candidates[j] = false;
}
}
}
// write them out
for (int i = 1; i < UPPER_LIMIT; i++)
{
if (candidates[i])
{
primes++;
Console.Out.WriteLine (i);
}
}
Console.Out.WriteLine(“\n” + primes + ” primes found in the range 2-” + UPPER_LIMIT);
}
/*********************************************************************
* Generic List from Array:
*********************************************************************/
/// <summary>
/// List list = GetGenericListFromArray(arr);
/// </summary>
/// <typeparam name=”T”></typeparam>
/// <param name=”items”></param>
/// <returns></returns>
private List<T> GetGenericListFromArray<T>(object[] items)
{
List<T> list = new List<T>();
for (int i = 0; i < items.Length; i++)
{
list.Add((T)items[i]);
}
return list;
}
/*********************************************************************
* Enums:
*********************************************************************/
enum Planets
{ // base type is int
Mercury, // default value 0
Venus,
Earth,
Mars,
Jupiter,
Saturn,
Uranus,
Neptune,
Pluto
}
enum Moons : short
{ // base type is short
Mercury = 0,
Venus = 0,
Earth = 1,
Mars = 2,
Jupiter = 16,
Saturn = 18,
Uranus = 15,
Neptune = 8,
Pluto = 1
}
private static void EnumExample()
{
Moons moonType = Moons.Neptune;
int integer = (int)Moons.Uranus;
Console.WriteLine(“moonType is {0}.”, moonType);
Console.WriteLine(“test is {0}.”, integer);
Console.WriteLine(“The planet {0} has {1} moons.”, Planets.Jupiter, (short)Moons.Jupiter);
}
/*********************************************************************
* Conversions:
*********************************************************************/
// instance variables (properties) default to 0, false, or null
//Convert to Fahrenheit
private double CelsiusToFahrenheit(string temperatureCelsius)
{
double celsius = Double.Parse (temperatureCelsius);
return (celsius * 9 / 5) + 32;
}
//Convert to Celsius
private double FahrenheitToCelsius(string temperatureFahrenheit)
{
double fahrenheit = Double.Parse (temperatureFahrenheit);
return (fahrenheit – 32) * 5 / 9;
}
/*********************************************************************
* Elasped Time:
*********************************************************************/
private void ElapsedTime()
{
Stopwatch watch = new Stopwatch();
watch.Start();
for (int i = 1; i < 1000000; i++) { } // Execute the task to be timed
watch.Stop();
Console.WriteLine(“Elapsed: {0}”, watch.Elapsed);
Console.WriteLine(“In milliseconds: {0}”, watch.ElapsedMilliseconds);
Console.WriteLine(“In seconds: {0}”, (long) watch.ElapsedMilliseconds / 1000);
Console.WriteLine(“In timer ticks: {0}”, watch.ElapsedTicks);
}
/*********************************************************************
* Date and Time:
*********************************************************************/
private void DatesAndTimes()
{
DateTime dateTime = DateTime.Now;
Console.WriteLine (“d = {0:d}”, dateTime ); // mm/dd/yyyy
Console.WriteLine (“D = {0:D}”, dateTime ); // month dd, yyyy
Console.WriteLine (“f = {0:f}”, dateTime ); // day, month dd, yyyy hh:mm
Console.WriteLine (“F = {0:F}”, dateTime ); // day, month dd, yyyy HH:mm:ss AM/PM
Console.WriteLine (“g = {0:g}”, dateTime ); // mm/dd/yyyy HH:mm
Console.WriteLine (“G = {0:G}”, dateTime ); // mm/dd/yyyy hh:mm:ss
Console.WriteLine (“M = {0:M}”, dateTime ); // month dd
Console.WriteLine (“R = {0:R}”, dateTime ); // ddd Month yyyy hh:mm:ss GMT
Console.WriteLine (“s = {0:s}”, dateTime ); // yyyy-mm-dd hh:mm:ss (Sortable)
Console.WriteLine (“t = {0:t}”, dateTime ); // hh:mm AM/PM
Console.WriteLine (“T = {0:T}”, dateTime ); // hh:mm:ss AM/PM
Console.WriteLine (“u = {0:u}”, dateTime ); // yyyy-mm-dd hh:mm:ss (Sortable)
Console.WriteLine (“U = {0:U}”, dateTime ); // day, month dd, yyyy hh:mm:ss AM/PM
Console.WriteLine (“Y = {0:Y}”, dateTime ); // month, yyyy (March, 2006)
Console.WriteLine (“Month = “ + dateTime.Month); // month number (3)
Console.WriteLine (“Day Of Week = “ + dateTime.DayOfWeek); // day of week name (Friday)
Console.WriteLine (“Time Of Day = “ + dateTime.TimeOfDay); // 24 hour time (16:12:11)
Console.WriteLine(“DateTime.Ticks = “ + dateTime.Ticks); // (632769991310000000)
// Ticks are the number of 100 nanosecond intervals since 01/01/0001 12:00am
// Ticks are useful in elapsed time measurement.
}
/*********************************************************************
* Validation:
*********************************************************************/
private bool IsValidGuid(string guidCandidate)
{
if (!string.IsNullOrEmpty(guidCandidate))
{
Regex rx = new Regex(@”^(\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1}$”);
return rx.IsMatch(guidCandidate);
}
return false;
}
// Check if string is all numbers
private bool AllNumeric(string inputString)
{
const string ALL_NUMERIC = “[a-z|A-Z]“;
const string ALL_CAPS = “[a-z]“;
Regex AllNumericRegex = new Regex(ALL_NUMERIC);
if (AllNumericRegex.IsMatch(inputString))
{
return false;
}
return true;
}
// Check if string is all a specific type of number
// Test for an integer:
// isNumeric(“42000″, System.Globalization.NumberStyles.Integer)
// Test for an integer separated with commas:
// isNumeric(“42,000″, System.Globalization.NumberStyles.Integer | System.Globalization.NumberStyles.AllowThousands)
public bool isNumeric(string val, System.Globalization.NumberStyles NumberStyle)
{
Double result;
return Double.TryParse(val, NumberStyle, System.Globalization.CultureInfo.CurrentCulture, out result);
}
if ( ! isNumeric(this.txtBestGuess.Text, System.Globalization.NumberStyles.Integer))
{
string str = “Your entry needs to be a number: “;
MessageBox.Show(str);
return;
}
try
{
bestGuess = Convert.ToInt32(this.txtBestGuess.Text);
}
catch (Exception ex)
{
string str = “Your entry could not be converted to a number: “;
MessageBox.Show(str + ex.Message);
}
/*********************************************************************
* App.Config:
*********************************************************************/
<appSettings>
<!–<add key=“DataStore” value=“Xml”/>–>
<add key=“DataStore” value=“SQLServer2005″/>
</appSettings>
//Need to add a Reference the Configuration
using System.Configuration;
// Get setting
private static string DataStore = ConfigurationManager.AppSettings["DataStore"];
private static string ConnectionString = ConfigurationManager.ConnectionStrings["SQLConnString"].ConnectionString;
public void AddSetting(string SettingName, string SettingValue)
{
// Open app.config of executable
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
// Add setting.
config.AppSettings.Settings.Add(SettingName, SettingValue);
config.Save(ConfigurationSaveMode.Modified);
ConfigurationManager.RefreshSection(“appSettings”);
}
public void ChangeSetting(string SettingName, string SettingValue)
{
// Open app.config of executable
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
// Chnage the Application Setting.
config.AppSettings.Settings["DataStore"].Value = “XML”;
// Save the configuration file.
config.Save(ConfigurationSaveMode.Modified);
// Force a reload of a changed section.
ConfigurationManager.RefreshSection(“appSettings”);
}
/*********************************************************************
* Parameter List:
*********************************************************************/
/// Use the params keyword to implement a method
/// e.g. ListArguments (“Arguments: “, DateTime.Now, 3.14f);
private void ListArguments(params object[] arguments)
{
foreach (object argument in arguments)
{
Console.WriteLine(argument);
}
}
public static void Main()
{
double a = 1;
int b = 2;
int c = 3;
int d = totalIgnoreFirst(a, b, c);
}
public static int totalIgnoreFirst(double a, params int[] intArr)
{
int sum = 0;
for (int i=0; i < intArr.Length; i++)
sum += intArr[i];
return sum;
}
/*********************************************************************
* Out Parameters :
*********************************************************************/
public static void Main()
{
bool b;
int c = change(5, out b);
}
public static int change (int a, out bool b)
{
b=false;
if (a>0)
b=true;
return (2*a);
}
/*********************************************************************
* Passing by reference:
*********************************************************************/
public static void Main()
{
int a = 0;
change(ref a); // following this method invocation, a==5
}
public static void change (ref int b)
{
b = 5;
}
/*********************************************************************
* Methods:
*********************************************************************/
private void Functions() {
int i = Factorial(5);
int a = 0;
int b = 0;
int c;
int d = Parms(a, ref b, out c);
i = Max(5, 3);
double x = Max(5.0, 3.0);
VarArgs(1,2,3);
}
private int Factorial(int n) { // methods must always specify a return value (can be void)
if (n == 1) {
return (1);
} else {
return (n * Factorial(n-1));
}
}
static int SFactorial(int n) { // static methods belong to class – can be called with no instance
if (n == 1) {
return (1); // static methods are implicitly final – no override allowed
} else {
return (n * SFactorial(n-1));
}
}
private int Parms(int x, ref int y, out int z) {
x = 1; // x = by value
y = 2; // y = by reference
z = 3; // z = output only
return 4;
}
private void VarArgs(params int[] x) { // params keyword allows var arg type calls VarArgs(1,2,3);
}
/*********************************************************************
* Method Overloading:
*********************************************************************/
private int Max(int a, int b) { // method overloading is resolved at compile time
if (a >= b) { // method of derived class always overrides – no matter how accessed
return a; // all function parameters are passed by value
} else {
return b;
}
}
private double Max(double a, double b) {
if (a >= b) {
return a;
} else {
return b;
}
}
/*********************************************************************
* Object Methods:
* Equals GetType MemberwiseClone ToString
* GetHashCode Finalize ReferenceEquals
*********************************************************************/
private void Objects() {
Object x = new Rational(1,2);
Object y = new Rational(1,2);
bool b = x.Equals(y);
}
/*********************************************************************
* String Methods:
* Chars Empty LastIndexOf ToCharArray
* Clone EndsWith Length ToLower
* Compare Equals PadLeft ToUpper
* CompareOrdinal Format ParRight Trim
* CompareTo Insert Remove TrimEnd
* Concat Intern Split TrimStart
* Copy IsInterned StartsWith
* CopyTo Join Substring
*********************************************************************/
private void Strings() {
string a = “Hello World”;
string b = @”\Hello World”; // literal string – no escape
int i = string.Compare(a, b);
i = string.Compare(a, b, true); // case insensitive
string s = string.Concat(a, b); // join strings
s = string.Copy(a);
i = a.Length;
char c = a[2];
bool f = a.EndsWith(“World”);
i = a.IndexOf(“World”);
i = a.LastIndexOf(“o”);
s = a.Insert(5, “fred”);
s = a.Substring(5);
s = a.Substring(0, 5);
char[] delimiters = {‘ ‘, ‘,’, ‘;’};
string[] xs = a.Split(delimiters);
s = String.Format(“{0,5:0.0}”, 1); // {ParamIndex[,MinWidth][:FormatString]}
System.Console.WriteLine(s);
Console.WriteLine(“Got {0} elements in UserInfoCollection”, userList.GetType().ToString());
}
/*********************************************************************
* StringBuilder Methods:
* Append Chars Length Remove
* AppendFormat EnsureCapacity MaxCapacity Replace
* Capacity Insert
*********************************************************************/
private void StringBuilders() {
System.Text.StringBuilder s = new System.Text.StringBuilder(“”);
s.Append(“abc”);
s.AppendFormat(“{0}{1}{2}”, “d”, “e”, “f”);
}
/*********************************************************************
* Regex Methods:
*********************************************************************/
private void RegEx() {
string s = “One,Two,Three Liberty Associates, Inc.”;
System.Text.RegularExpressions.Regex re = new System.Text.RegularExpressions.Regex(” |, |,”);
re.Split(s);
foreach (string a in re.Split(s)) {
System.Console.WriteLine(a);
}
}
/*********************************************************************
* Indexers:
*********************************************************************/
private void Indexers() {
Indexer indx = new Indexer();
indx.Add(“a”);
indx.Add(“b”);
for (int j = 0; j < indx.GetNumEntries(); j++) {
System.Console.WriteLine(indx[j]);
}
}
class Indexer {
private string[] s = new string[256];
private int i = 0;
public void Add(string a) {
s[i++] = a;
}
public string this[int index] {
get {
if ((index < 0) || (index >= s.Length)) {
// handle bad index
}
return s[index];
}
set {
if (index >= i) {
// add only through add method
} else {
s[index] = value;
}
}
}
public int GetNumEntries() {
return i;
}
}
/*********************************************************************
* Collection Classes:
*********************************************************************/
private void Collect() {
// ArrayList – dynamically sized array
System.Collections.ArrayList a = new System.Collections.ArrayList();
a.Add(“Fred”);
a.Add(“Hank”);
a.Sort();
foreach (string x in a) System.Console.WriteLine(x);
// BitArray – dynamically sized boolean array
System.Collections.BitArray b = new System.Collections.BitArray(0);
b.Length = 2;
b[1] = true;
b.Xor(b);
// HashTable – dictionary
System.Collections.Hashtable d = new System.Collections.Hashtable();
d["ab"] = 1;
d["cd"] = 2;
int i = (int)d["ab"];
// SortedList – sorted dictionary
System.Collections.Hashtable e = new System.Collections.Hashtable();
e["ab"] = 1;
e["cd"] = 2;
i = (int)e["ab"];
// Queue – fifo
System.Collections.Queue q = new System.Collections.Queue();
q.Enqueue(1);
q.Enqueue(2);
i = (int)q.Dequeue();
i = (int)q.Dequeue();
// Stack – lifo
System.Collections.Stack s = new System.Collections.Stack();
s.Push(1);
s.Push(2);
i = (int)s.Pop();
i = (int)s.Pop();
// StringCollection
System.Collections.Specialized.StringCollection c = new System.Collections.Specialized.StringCollection();
c.Add(“abc”);
c.Add(“def”);
}
/*********************************************************************
* XML – Serialize:
*********************************************************************/
/// <summary>
/// Serialization – Writes the XML to disk.
/// </summary>
public void SaveXmlToDisk(UserList userList)
{
if (userList == null || userList.Count < 1 )
{
throw new ArgumentException(“The collection must contain data”);
}
try
{
if (File.Exists(xmlFile))
{
File.Delete(xmlFile);
}
}
catch (IOException)
{
throw;
}
XmlSerializer xser = new XmlSerializer(userList.GetType());
using (TextWriter writer = new StreamWriter(xmlFile))
{
// serialize without the default namespace
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add(“”, “”);
xser.Serialize(writer, userList, ns);
}
}
/*********************************************************************
* XML – Deserialize:
*********************************************************************/
/// <summary>
/// Deserialization – Reads the XML from disk.
/// </summary>
/// <returns>An Entity Collection object</returns>
public UserInfoCollection ReadXmlFromDisk()
{
UserInfoCollection newList = new UserInfoCollection();
newList = null;
if ( ! File.Exists(xmlFile))
{
MakeEmptyXmlDocument(xmlFile);
}
if (File.Exists(xmlFile))
{
using (XmlTextReader xr = new XmlTextReader(xmlFile))
{
XmlSerializer xs = new XmlSerializer(typeof(UserInfoCollection));
newList = (UserInfoCollection)xs.Deserialize(xr);
Console.WriteLine(“Got {0} elements in UserInfoCollection”, newList.GetType().ToString());
}
}
return newList;
}
/*********************************************************************
* XML – Create an XML file:
*********************************************************************/
/// <summary>
/// Makes the empty XML document.
/// </summary>
/// <param name=”xmlFile”>The XML file.</param>
private void MakeEmptyXmlDocument(string xmlFile)
{
XmlDocument xmldoc = new XmlDocument();
//Add the XML declaration section
XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration, “”, “”);
xmldoc.AppendChild(xmlnode);
//Add the root element
XmlNode xmlelem = xmldoc.CreateElement(“”, “UserList”, “”);
xmldoc.AppendChild(xmlelem);
//Add remaining elements
string[] elements =
{
“Login”, “Password”, “FirstName”, “LastName”, “Address”, “City”, “State”, “Zip”, “Telephone”
};
foreach (string element in elements)
{
xmlelem = xmldoc.CreateElement(“”, element, “”);
xmldoc.ChildNodes.Item(1).AppendChild(xmlelem);
}
try
{
xmldoc.Save(xmlFile);
}
catch (IOException)
{
throw;
}
}
/*********************************************************************
* Retrieve the path of a file:
*********************************************************************/
OpenFileDialog openFileDialog1 = new OpenFileDialog();
string fn = “”;
string path = “”;
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
fn = System.IO.Path.GetFileName(openFileDialog1.FileName);
path = System.IO.Path.GetDirectoryName(openFileDialog1.FileName);
}
MessageBox.Show(fn, “Filename”);
MessageBox.Show(path, “Directory”);
/*********************************************************************
*Reading a file on disk:
*********************************************************************/
void FileIO()
{
System.IO.Stream ios = new System.IO.FileStream(“foo.txt”, System.IO.FileMode.Create);
ios.WriteByte(67);
ios.WriteByte(35);
ios.WriteByte(0xd);
ios.WriteByte(0xa);
ios.Close();
ios = new System.IO.FileStream(“foo.txt”, System.IO.FileMode.Open);
int i = ios.ReadByte();
i = ios.ReadByte();
ios.Close();
ios = new System.IO.FileStream(“bar.txt”, System.IO.FileMode.Create);
System.IO.StreamWriter sw = new System.IO.StreamWriter(ios, System.Text.Encoding.ASCII);
sw.WriteLine(“C#”);
sw.Close();
ios = new System.IO.FileStream(“bar.txt”, System.IO.FileMode.Open);
System.IO.StreamReader sr = new System.IO.StreamReader(ios, System.Text.Encoding.ASCII);
string a = sr.ReadLine();
sr.Close();
}
/*********************************************************************
* Save string text to a file:
*********************************************************************/
string temp = importResult.GetResult().OuterXml;
string pPath = “C:\\test.txt”;
System.IO.StreamWriter lfWriter = new System.IO.StreamWriter(pPath);
lfWriter.Write(“”);
System.IO.StringReader reader = new System.IO.StringReader(temp);
string strTemp = string.Empty;
strTemp = reader.ReadToEnd();
lfWriter.WriteLine(strTemp);
lfWriter.WriteLine();
lfWriter.Close();
/// <summary>
/// Write text to a file.
/// </summary>
/// <param name=”file”>The file to write to.</param>
/// <param name=”text”>The text to write into the file.</param>
/// <remarks>
/// If the file does not exist, it will be created. If the file does
/// exist, the text will be appended at the end of the current contents
/// of the file.
/// e.g. WriteToFile(@”C:\temp.txt”, “This is a test.”);
/// </remarks>
private void WriteToFile(string file, string text)
{
FileStream fs = null;
StreamWriter sw = null;
try
{
fs = new FileStream(file, FileMode.OpenOrCreate, FileAccess.Write);
sw = new StreamWriter(fs);
// Begin writing at the end of the existing contents of the file
sw.BaseStream.Seek(0, SeekOrigin.End);
// Write the text to the file
sw.WriteLine(text);
sw.Flush();
}
catch (Exception)
{
throw;
}
finally
{
sw.Close();
fs.Close();
}
}
/*********************************************************************
* Save to a specific folder:
*********************************************************************/
private static string UserData = “UserData.xml”;
private static string FilePath = Environment.GetFolderPath( Environment.SpecialFolder.Personal );
/*********************************************************************
* Threading:
*********************************************************************/
void Threads() {
System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ThreadStart(StartMe));
t.Start();
}
void StartMe() {
lock(this) {
//System.Threading.Monitor.Wait(this);
//System.Threading.Monitor.Pulse(this);
System.Console.WriteLine(“Thread Me”);
}
}
/************************************************************************
* Attributes:
************************************************************************/
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]
public class MyAttribute : System.Attribute {
private int commentID;
private string comment;
public MyAttribute(int commentID, string comment) {
this.commentID = commentID;
this.comment = comment;
}
public int CommentID {
get { return commentID; }
}
public string Comment {
get { return comment; }
set { comment = value; }
}
}
// using attributes
[MyAttribute(1, "Hello World")]
[MyAttribute(2, "Foo Bar")]
class TestAttributes { }
/*********************************************************************
* Reflection:
*********************************************************************/
void DumpType(System.Type t) {
System.Console.WriteLine(“Type: {0}”, t);
System.Reflection.MemberInfo[] a = t.GetMembers();
foreach (System.Reflection.MemberInfo m in a) {
Console.WriteLine(“ {0} = {1}”, m.MemberType, m);
}
// filtering for a method
a = t.FindMembers(
System.Reflection.MemberTypes.Method,
System.Reflection.BindingFlags.Public |
System.Reflection.BindingFlags.Static |
System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Instance |
System.Reflection.BindingFlags.DeclaredOnly,
Type.FilterName, “Get*”);
foreach (System.Reflection.MemberInfo m in a) {
Console.WriteLine(“ {0} = {1}”, m.MemberType, m);
}
}
void Reflections() {
// type discovery
System.Type ta = System.Type.GetType(“System.Int32″);
System.Type tb = typeof(System.Int32);
DumpType((new System.Object()).GetType());
//DumpType(typeof(string));
// viewing attribute metadata
System.Reflection.MemberInfo inf = typeof(TestAttributes);
object[] a = inf.GetCustomAttributes(typeof(MyAttribute), false);
foreach (object m in a) {
MyAttribute x = (MyAttribute)m;
System.Console.WriteLine(x.CommentID + ” : “ + x.Comment);
}
}
/// <summary>
/// Get Calling Method using Reflection
/// </summary>
private void GetCallingMethod()
{
// Get new instance of the call stack
StackTrace stack = new StackTrace();
// GetFrame index of 0 is current stack frame, index of 1 is previous stack frame and so on
StackFrame frame = stack.GetFrame(1);
// Use reflection to get the actual method from the previous stack frame
MethodBase method = frame.GetMethod();
// Get the name of the method and the class it’s containedin using reflection properties
string methodName = method.Name;
string className = method.ReflectedType.ToString();
}
/*********************************************************************
* Database:
*********************************************************************/
void Databases() {
System.Data.SqlClient.SqlConnection Db;
System.Data.SqlClient.SqlDataAdapter Da;
System.Data.DataSet Ds;
System.Data.DataTable Dt;
System.Data.SqlClient.SqlCommand Cmd;
System.Data.SqlClient.SqlDataReader Rs;
string connectionStr = “Server=.; Database=Northwind; Integrated Security=sspi”;
string commandStr;
// open up a database connection
Db = new System.Data.SqlClient.SqlConnection(connectionStr);
Db.Open();
// create a table
commandStr = “CREATE TABLE TestCSharp(“ +
“ TestCD CHAR(2) NOT NULL PRIMARY KEY,” +
“ Description VARCHAR(80) NOT NULL)”;
Cmd = new System.Data.SqlClient.SqlCommand(commandStr, Db);
Cmd.CommandType = System.Data.CommandType.Text;
Rs = Cmd.ExecuteReader();
Rs.Close();
// create a stored procedure for saves
commandStr = “CREATE PROCEDURE spSaveTestCSharp” +
“ @TestCD CHAR(2) = NULL,” +
“ @Description VARCHAR(80) = NULL” +
“ AS” +
“ SET NOCOUNT ON” +
“ INSERT INTO TestCSharp(TestCD, Description) VALUES(@TestCD, @Description)” +
“ SELECT” +
“ Status = 0,” +
“ Token = ‘1234′”;
Cmd = new System.Data.SqlClient.SqlCommand(commandStr, Db);
Cmd.CommandType = System.Data.CommandType.Text;
Rs = Cmd.ExecuteReader();
Rs.Close();
// create a stored procedure for reads
commandStr = “CREATE PROCEDURE spReadTestCSharp” +
“ AS” +
“ SET NOCOUNT ON” +
“ SELECT” +
“ Status = 0,” +
“ Token = ‘1234′,” +
“ TestCD = tab.TestCD,” +
“ Description = tab.Description” +
“ FROM TestCSharp tab” +
“ ORDER BY tab.TestCD”;
Cmd = new System.Data.SqlClient.SqlCommand(commandStr, Db);
Cmd.CommandType = System.Data.CommandType.Text;
Rs = Cmd.ExecuteReader();
Rs.Close();
// insert via stored procedure call
Cmd = new System.Data.SqlClient.SqlCommand(“spSaveTestCSharp”, Db);
Cmd.CommandType = System.Data.CommandType.StoredProcedure;
Cmd.Parameters.Add(new System.Data.SqlClient.SqlParameter(“@TestCD”, System.Data.SqlDbType.VarChar, 2));
Cmd.Parameters.Add(new System.Data.SqlClient.SqlParameter(“@Description”, System.Data.SqlDbType.VarChar, 80));
Cmd.Parameters["@TestCD"].Value = “TX”;
Cmd.Parameters["@Description"].Value = “Texas”;
Rs = Cmd.ExecuteReader();
Rs.Read();
int Status = (int)Rs["Status"];
string Token = (string)Rs["Token"];
if (Status != 0) {
System.Console.WriteLine(“Error in test insert”);
}
Rs.Close();
// read via stored procedure call
Cmd = new System.Data.SqlClient.SqlCommand(“spReadTestCSharp”, Db);
Cmd.CommandType = System.Data.CommandType.StoredProcedure;
Rs = Cmd.ExecuteReader();
Rs.Read();
Status = (int)Rs["Status"];
Token = (string)Rs["Token"];
if (Status != 0) {
System.Console.WriteLine(“Error in test insert”);
} else {
do
System.Console.WriteLine(Rs["TestCD"] + ” “ + Rs["Description"]);
while (Rs.Read());
}
Rs.Close();
// example using DataAdapter (sans SqlConnection)
commandStr = “SELECT * FROM TestCSharp”;
Da = new System.Data.SqlClient.SqlDataAdapter(commandStr, connectionStr);
Ds = new System.Data.DataSet();
Da.Fill(Ds, “Test”);
Dt = Ds.Tables[0];
foreach (System.Data.DataRow row in Dt.Rows) {
System.Console.WriteLine(row["TestCD"] + ” “ + row["Description"]);
}
// drop the read stored procedure
commandStr = “DROP PROCEDURE spReadTestCSharp”;
Cmd = new System.Data.SqlClient.SqlCommand(commandStr, Db);
Cmd.CommandType = System.Data.CommandType.Text;
Rs = Cmd.ExecuteReader();
Rs.Close();
// drop the save stored procedure
commandStr = “DROP PROCEDURE spSaveTestCSharp”;
Cmd = new System.Data.SqlClient.SqlCommand(commandStr, Db);
Cmd.CommandType = System.Data.CommandType.Text;
Rs = Cmd.ExecuteReader();
Rs.Close();
// drop the table
commandStr = “DROP TABLE TestCSharp”;
Cmd = new System.Data.SqlClient.SqlCommand(commandStr, Db);
Cmd.CommandType = System.Data.CommandType.Text;
Rs = Cmd.ExecuteReader();
Rs.Close();
// close the database connection
Db.Close();
}
/*********************************************************************
* Networking:
*********************************************************************/
void Networking() {
System.Net.WebClient wc = new System.Net.WebClient();
System.Text.UTF8Encoding utf = new System.Text.UTF8Encoding();
try {
// can’t seem to get this thing to work???
string doc = utf.GetString(wc.DownloadData(“http://localhost/”));
System.Console.WriteLine(doc);
} catch (System.Net.WebException e) {
Console.WriteLine(e);
}
}
/*********************************************************************
* Inner Classes:
*********************************************************************/
public class InnerClass { // C# inner classes are equivalent to static inner classes in Java
int a; // No C# equivalent for instance inner classes or anonymous classes
public int b; // can not access instance methods or properties of the outer class
private int c;
public InnerClass() {
InnerInnerClass xa = new InnerInnerClass();
}
public class InnerInnerClass {
int a;
public int b;
private int c;
public InnerInnerClass() {
System.Console.WriteLine(“InnerInnerClass”);
a = 0;
}
}
}
}
/************************************************************************
* Outer Classes:
************************************************************************/
class OuterClass { // outer class can not be declared public
const double PI = 3.14;
static int objcount = 0;
internal OuterClass() {
int i;
double x;
String s;
XShape x1;
XShape x2;
XShape x3;
XShape x4;
XShape x5;
XRectangle xa;
IConvert xb;
x1 = new XRectangle(3.0, 4.0);
x2 = new Square(3.0);
x3 = new Triangle(1.0, 2.0, 3.0);
x4 = new Circle(4.0);
x5 = new EquilateralTriangle(5.0);
xa = (XRectangle)x2; // polymorphism – base class object can point to any derived class
x2 = xa; // assigning object to super class does not require casting
x = x1.Area(); // appropriate method for the subclass instance is called
i = x2.Sides; // superclass variables can only access variables and methods
s = x3.ToString(); // that exist at the superclass level of the variable
xb = (IConvert)x4; // polymorphism – interface var can point to any class that implements
x = xb.InchToMM();
System.Console.WriteLine(x1.ToString() + “:” + x2.ToString() + “:” + x3.ToString() + “:” +
x4.ToString() + “:” + x5.ToString());
}
// inner class objects outside of class can be created only in context of the top level class
OuterClass(String s) {
Syntax xa = new Syntax();
Syntax.InnerClass xb = new Syntax.InnerClass();
Syntax.InnerClass.InnerInnerClass xc = new Syntax.InnerClass.InnerInnerClass();
}
}
/************************************************************************
* SubClasses:
************************************************************************/
abstract class XShape { // abstract class can not be alocated – serves as subclass template
internal String name;
internal int Sides = 0; // subclasses inherit all fields and methods not defined as private
internal XShape(int Sides) {
this.Sides = Sides;
}
internal abstract double Area(); // abstract requires all subclasses to define this method
internal virtual double Perimeter() { // virtual methods are intended to be overridden – must be explicit (final is default)
return 0;
}
public override String ToString() { // override the inherited Object method
return name;
}
}
class XRectangle : XShape { // extends identifies this as a subclass of the specified superclass
internal double length = 1.0; // subclass inherits all members of superclass that are not private
double width = 1.0;
internal XRectangle(double length, double width) : base(4) { // constructors of base class not inherited – but can be called
name = “XRectangle”;
this.length = length;
this.width = width;
}
internal XRectangle() : this(2, 4) { // this or super constructor must be first statement in constructor
}
override internal double Area() { // define abstract method
return length * width;
}
override internal double Perimeter() {
return 2 * length * width;
}
}
sealed class Square : XRectangle { // sealed (final) class prevents any further subclassing
new internal double length; // new keyword indicates intentionally shadowing
internal Square(double length) : base(length, length) {
name = “Square”;
this.length = length;
base.length = length; // accessing shadowed variables allowed through super
((XRectangle)this).length = length; // accessing shadowed variables allowed through casting
double x = base.Area(); // accessing overridden method allowed through super
x = ((XRectangle)this).Area(); // casting does not provide access to the overridden method
}
override internal double Area() { // override base class method – Perimeter function is inherited
return base.Area(); // overriding method cannot be less accessible than overridden method
} // throws clause of overriding method must match overridden method
}
class Triangle : XShape {
internal double[] side = new double[3];
double xbase;
double height;
internal Triangle(double a, double b, double c) : base(3) {
name = “Triangle”;
side[0] = a;
side[1] = b;
side[2] = c;
xbase = a;
height = 1.0;
}
override internal double Area() {
return 0.5 * xbase * height;
}
override internal double Perimeter() {
return (side[0] + side[1] + side[2]);
}
}
class Factors {
public const double PI = 3.14;
public static double PISQUARE = Math.Pow(PI, 2);
public const double INCH_TO_MM = 25.4;
private Factors() { }
}
/************************************************************************
* Interfaces:
************************************************************************/
interface IConvert { // an interface is a collection of abstract methods
double InchToMM(); // methods in interface are always abstract and public (can not specify access modifier)
} // C# does not support constant fields in interfaces
interface IMoreConvert : IConvert { // interfaces can be extended similar to classes
double MMToInch();
}
class Circle : XShape, IMoreConvert { // multiple interfaces may be implemented
double radius; // explicit implementation can be used for methods that exist in more than one interface
// IMoreConvert.MMToInch() – can only be accessed through cast of the object to interface
internal Circle(double radius) : base(0) {
name = “Circle”;
this.radius = radius;
}
override internal double Area() { // abstract methods required from superclass
return Factors.PI * Factors.PI * radius;
}
override internal double Perimeter() { // override superclass method
return 2 * Factors.PI * radius;
}
public double InchToMM() { // abstract method for interface
return (Perimeter() * Factors.INCH_TO_MM);
}
public double MMToInch() {
return radius * (1 / Factors.INCH_TO_MM);
}
}
internal class EquilateralTriangle : Triangle, IConvert {
internal EquilateralTriangle(double a) : base(a, a, a) {
name = “EquilateralTriangle”;
}
override internal double Area() {
return 0.5;
}
public double InchToMM() { // abstract method for interface
return 3 * side[0] * Factors.INCH_TO_MM;
}
}
/************************************************************************
* Structs:
************************************************************************/
public struct Location { // structs do not support inheritance (can implement interfaces)
private int xval; // initialization not supported
private int yval;
public Location(int x, int y) { // structs are value objects
xval = x; // destructors not supported
yval = y;
}
public int x {
get {
return xval;
}
set {
xval = value;
}
}
public int y {
get {
return yval;
}
set {
yval = value;
}
}
public override string ToString() {
return String.Format(“{0}, {1}”, xval, yval);
}
}
/************************************************************************
* Link Lists:
************************************************************************/
class LinkList {
LinkList prev;
LinkList next;
LinkList() {
prev = null;
next = null;
}
LinkList(LinkList x) {
x.prev = x;
x.next = null;
x.prev.next = this;
}
}
}
/************************************************************************
* Documentation Comments:
************************************************************************/
/// <summary>
/// Summary of a Member
/// </summary>
/// <remarks>Description of a type</remarks>
/// <param name=”pname”>Description for method parameter</param>
/// <returns>Description of return value</returns>
/// <exception cref=”IndexOutOfRangeException”>Description of Exceptions that may be thrown</exception>
/// <permission cref=”public”>Description of permission requirements</permission>
/// <example>Example Description</example>
/// <code>Syntax x = new Syntax();</code>
/// <seealso cref=”System.IO”>Document Cross Reference</seealso>
/// <see cref=”System.IO”>Inline Document Cross Reference</see>
/// <value>Description of Property Value</value>
/// <paramref name=”prname”>Parameter name within descriptive text</paramref>
/// <include file=”documentation.xml” path=”/”>External documentation file</include>
/// <mytag>User Defined Tags</mytag>
/***************************************************************************
* Preprocessor Defines:
***************************************************************************/
#define DEBUG // defines/undefines must be first directives in file
#undef DEBUG
/***************************************************************************
* Using NameSpace References:
***************************************************************************/
using System; // allow simple access to classes within namespace without full name
using socks = System.Net.Sockets; // aliasing namespace
using txt = System.String; // aliasing type
/***************************************************************************
* NameSpace Definition:
***************************************************************************/
namespace Fred { namespace Hank { } } // namespaces may be nested
namespace Fred.Hank { } // shortcut for nested namespaces
namespace Test {
/************************************************************************
* Classes:
************************************************************************/
class Syntax {
/*********************************************************************
* Access Modifiers:
*********************************************************************/
int mydefault; // private by default
public int mypublic; // visible to any class
private int myprivate; // visible only to this class
protected int myprotected; // visible only to this class and subclasses
internal int myinternal; // visible to any class in this assembly
protected internal int myprotint; // protected or internal visibility
// class, struct, properties and indexers can be set with: abstract, virtual, override, sealed
}
