C# Cheat Sheet

string strTest = string.Empty; // NICHT strTest = "";

StringBuilder sb = new StringBuilder();

sb.Append(strIrgendwas); // schneller als alles über GC laufen zu lassen via +=

sb.Replace('A', 'B');

// FALSCH (wenn dann mit try/catch): 

string strOfConsole = Console.ReadLine();

int iTest = Convert.ToInt32(strOfConsole);

// RICHTIG: 

int iTest;

if( int.TryParse(Console.ReadLine(), out iTest) == true )

{ ... }

string.Format("{0,5}", 15); // ___15

string.Format("{0,-5}", 15); // 15___

foreach( string s in arrOfStrings ) { ... } // IEnumerator

int[] arrIntTest = new int[5];

int[,] arrIntTest = new int[5,10];

int[,,] arrIntTest = new int[5,10,15];

int[] arrIntTest = new int[] { 1,2,3,4,5 };

int[,] arrIntTest = new int[,] { {1,2,3,4,5} , {7,8,9} };

int[] arrIntTest = new int[5];

arrIntTest.CopyTo(arrAnotherOne); // dynamisch

Array.Copy(arrIntTest, arrAnotherOne); // statisch, aber dasselbe

Array.Clear(arrIntTest,1,4); // Nur noch EIN Element enthalten und Clear nicht dynamisch!

Array.BinarySearch(dDouble, 2.0); // Baumsuche, beim ersten mal unsortiert, danach schneller

Array.BinarySearch<double>(dDouble, 2.0); // noch besser, da generisch

public string strProperty

{

   get

   { return strProperty; }

   set

   { strProperty = value; }

}

public MyClass<number,Customer> where number: IComparable { ... } // eigentliche generische Klasse

public MyCompareClass : IComparable { ... } // notwendige Ableitung

MyClass<int,Customer> Test = new MyClass<int,Customer>; // funktioniert sofort, da comparable

MyClass<MyCompareClass,Customer> = new MyClass<int,Customer>; // nur wenn von IComparable abgeleitet

// foreach ( int iSth in Test ) { ... } 

public IEnumerator<MyType> GetEnumerator() { for(...) { yield return arrSth[i]; } }