Clanpage.net

Eventhandler

Ticker:

System.Windows.Forms.Timer t = new System.Windows.Forms.Timer();
t.Tick += new EventHandler(Methode);
t.Interval = 100; ; //Angabe für ms
t.Start(); t.Stop();
public void Methode(object sender, EventArgs e)
{ }

MAUS EVENTS

Start.MouseLeftButtonDown += new MouseButtonEventHandler(Startit);
public void Startit(object sender, MouseButtonEventArgs e)
{
startit();
}

 
Links: Gero|

 

MultiCast Delegate Beispiel
class Program
{
public delegate void Operation(int wert1, int wert2);
static void Main(string[] args)
{
klasse x = new klasse();
Operation[] proz = new Operation[2];
proz[0] = new Operation(x.Methode1);
proz[1] = new Operation(x.Methode2);
Operation array = (Operation)Delegate.Combine(proz);
array(1, 2);
Console.ReadLine();
}
class klasse
{
public void Methode1(int x, int y)
{
Console.WriteLine(“1.{0}{1}”,x,y);
}
public void Methode2(int x, int y)
{
Console.WriteLine(“2.{0}{1}”, x, y);
}
}

}

Maus Position

using System.Runtime.InteropServices;
[DllImport("user32.dll")]
static extern bool GetCursorPos(ref Point lpPoint);
Point MousePoint = new Point();
 
GetCursorPos(ref MousePoint);
string x = MousePoint.X.ToString();
string y = MousePoint.Y.ToString();

SQL

Achtung strings immer: ‘string’ schreiben!
using System.Data.SqlClient; //ZUR VERWENDUNG VON MS SQL NICHT FÜR MYSQL GEEIGNET!
 
const string verbindungsstr = “Data Source=.\\SQLEXPRESS;AttachDbFilename=C:\\PFAD\\DBNAME.mdf;Integrated Security=true;Connect Timeout=30;User Instance=True”; //String zur verbindung
SqlConnection verbindung = null;
SqlCommand befehl = null;
SqlDataReader leser = null;
int[] dbRang;
string[] dbBundesland;
int aktDatensatz = -1;
public void Getdataoderso…()
{
dbRang = new int[16];
dbBundesland = new string[16];
try
{
verbindung = new SqlConnection(verbindungsstr);
verbindung.Open();
befehl = verbindung.CreateCommand();
befehl.CommandText = “SELECT * FROM bndlaender”;
leser = befehl.ExecuteReader();
aktDatensatz = -1;
while (leser.Read())
{
aktDatensatz++;
dbRang[aktDatensatz] = leser.GetInt32(0);
dbBundesland[aktDatensatz] = leser.GetString(1);
}
}
catch (SqlException e)
{
MessageBox.Show(e.Message, “Datenbankfehler”);
}
catch (Exception e)
{
MessageBox.Show(e.Message, “Datenbankfehler 2″);
}
finally
{
if (leser != null)
leser.Close();
if (verbindung != null)
verbindung.Close();
}
}
 
xx.CommandText = “CREATE TABLE tabellenname ( name1 (zb) INTEGER NOT NULL PRIMARY KEY, name2 VARCHAR(50) NOT NULL, name3 REAL)”; //Integer = int; not null = kann leer bleiben; Primary darf nur 1x vorkommen; VARCHAR etwa string; REAL = double
 
xx.CommandText = “INSERT INTO tabellenname ( name1 (zb),name2, name3…) VALUES (wert1,wert2,wert3)”; // Fügt werte dazu…
 
xx.CommandText = “UPDATE tabellenname SET name2 = wert2 WHERE (name1 = wert1)”; // Ersetzt die werte…
 
xx.CommandText = “SELECT name1,name2,name3 FROM tabellenname WHERE (name2 > 10 ) ORDER BY name1″; // Gibt name1-3 aus wo name2 >10 ist reihen geordnet nach name1. SELECT * FROM tabellenname gibt alle aus. SELECT * FROM tabellenname WHERE (name2 >10) auch möglich. Es geht auch ORDER BY ASC oder ORDER BY DESC (aufsteigend bzw absteigend)

 
SOUND ABSPIELEN
using System.Media;
System.Media.SoundPlayer Sound = new System.Media.SoundPlayer();

Sound.SoundLocation = (@”C:\sound.wav”);

oder:

System.ComponentModel.ComponentResourceManager getsound = new System.ComponentModel.ComponentResourceManager(typeof(Form1));
Sound.Stream = (getsound.GetStream(“SOUNDNAME”));
Sound.Load();
Sound.Play();

Verschiedenes

Objekt einer Klasse anlegen und initialisieren
Test obj1 = new Test() {wert1=0, wert2=0,etc};
 
Parms Modifizierer // Für unbestimmte Anzahl an übergabe-Objekten
public long Addition(int value1,int value2,params int[] liste)
{
long summe= value1+Value2;
foreach(int z in liste)
summe += z;
return summe;
}
x= Addition(1,2,4,5,6,7,8);
oder x = Addition(1,2,arrary);

Die using Direktive bietet den vorteil das namespaces die dadurch in das Projekt eingebunden wurden, nichtmehr mit dem vollen Namen angesprochen werden müssen sondern nurnoch mit dem Typbezeichner.(zb ohne System.Console)
Bei Mehrdeutigkeit können Aliasnamen verwendet werden. (zb using Ausgabe = System.Console -> Ausgabe.Write())
Es gibt auch noch den :: -Operator welcher umleitet. (zb global :: System.Console.Write() ) Hierfür wird kein using System.Console benötigt es eignet sich daher nur wenn ein namespace nur sehr wenig benutzt wird.
Namespaces können auch inneinander verschachtelt werden. ( ns1{ ns2{ code2 } code1 } auruf: using ns1.ns2; )
 
Objekte (auch Klasseninstanzen oder nur Instanzen bezeichnet) sind Referenztypen und werden auf dem Heap gespeichert. Variablen wie Int, Double etc werden auf dem Stack gespeichert ( schneller & call by value )
 
Objektverknüpfung hat die Auswirkungen das durch obj1=obj2 sie verbunden werden.Ändert man einen wert wird der des anderen auch geändert nicht wie bei variablen des typs int etc… man spricht vom “verbiegen des Pointers”.
 
Instanzvariable sowie auch Instanzmethoden gehören den Klasseninstanzen bzw den Objekten, im Gegensatz zu Klassenvariablen(static) und Klassenmethoden(static) die der Klasse gehören und unabhänig von den Objekten sind.

Eigenschaften oder auch Properties sind Felder bzw Variablen welche mit Get/Set “erzeugt” werden.
 
const vs readonly Modifizierter: readonlys können direkt oder über einen Konstruktor zugewiesen werden daher können sie auch erst zur Laufzeit zugewiesen werden. Const müssen direkt zugewiesen werden. Const können nur über obj.constname zugegriffen werden ( bis auf bei string). Readonly können auch übergeben werden
int x = obj.readonlyname;
 
this: Wenn es variablen mit gleichen Namen gibt ( zb eins in der Klasse das andere in einer Methode dieser klasse) bezieht man sich mit this immer auf das Objekt und nicht auf die in der Methode definierte !
 
Der Destruktor ist das Pendant zum Konstruktor,( ~Klassenname(){ code } ) er zerstört Objekte (obj =null ) indem er die Referenz auf den Speicherbereich Löscht. Der Garbage Collector hat die Aufgabe diese objekte zu suchen und den speicherbereich wieder freizugeben.
Der GC schlägt zu wenn grade keine arbeit ansteht oder aber der Speicher fast voll ist. Ebenfalls kann er durch GC.Collect(); aufgerufen werden. Das Interface IDisposable mit der Methode Dispose gibt die sicherheit das nicht auf den GC gewartet werden muss. Die Dispose Funktion muss vom benutzer aufgeurfen werden, da dies nicht sichergestellt werden kann muss die Klasse auch für den GC eingerichtet werden. ( ~Klassenname() { Dispose(); } )–> S.195 in c#08
 
Die Ableitung bzw Vererbung ist eine ist-eine-Beziehung und nur sinnvoll wenn man sagen kann y ist ein Objekt von x.
 
abstract bedeutet es ist keine Instanzbildung möglich, durch public abstract class ist es zu erkennen.
Methoden & variablen können ebenfalls abstract sein,dies bedeutet sie haben keinen Code bzw wert, dadurch wird allerdings auch die ganze Klasse abstract!
Abstrakte Klassen könnnen nur abgeleitet werden und alle die als abstract gekennzeichnet sind müssen von der ableitung überschrieben werden. Statische methoden können nicht abstrakt sein!
 
Klassen die sealed oder static sind können garnicht abgeleiget werden, Methoden können auch sealed sein (nur in verbindung mit protected !) d.h. Bei ableitung wird sie vererbt kann allergins nicht mit override sondern nur mit new überdeckt werden!

Die Polymorphie sorgt dafür das der aufruf einer Methode richtig zugeordnet wird, wird er in der Subklasse nicht gefunden wird in der Basisklasse gesucht, dies kann hoch bis zur Objekt Klasse gehen. Methoden die als virtual in der Basis klasse deklariert sind können mit override in der Subklasse überschrieben werden.Die Zuordnung erfolgt über die Implementierung des Objekts. Wenn eine Methode mit new überdeckt wird, fällt das polymorphe verhalten weg.
klasse obj1 = new klasseabgel(); klasse obj2 = new klasse(); wenn sie die gleichen Methoden implementieren, werden jetzt bei obj1 die von der abgeleiteten und bei obj2 die von der basisklasse aufgerufen.
 
Die Aggregation ist eine hat-eine-Beziehung das bedeutet das ein untergeordnetes Objekt eine übergeordnete Klasse hat. Das Objekt wird im Konstruktor der übergeordneten angelegt welcher auch die variablen entgegen nimmt und dann den Konstruktor des untergeordneten Objekts aufruft. Der Zugriff erfolgt also über objÜber.objUnter.Methode(); Wenn er intern nicht weitergeleitet wird (d.h. eine Methode der übergeordneten Klasse die Methode der untergeordneten aufruft und dadurch das Objekt versteckt).
Die zweite Möglichkeit ist die Klassen zu verschachteln. klasse1{ klasse2{code2} code1 }. Die Instanzierung erfolgt genau wie oben, über den Konstruktor von klasse1. Der einzige unterschied ist hier das klasse2 als private deklariert werden kann und somit der zugriff nur über klasse1 möglich ist (Methodenaufrufe der klasse2 müssen von 1 weitergeleitet werden) S.256 c#08
 
Interfaces, auch Schnittstellen genannt, bieten die möglichkeit eine Art Vertrag zu unterschreiben sie werden durch public interface name { code } gebildet. Klassen die Schnittstellen Implementieren garantieren das die Klasse die Methoden bereitstellen. Die übernommenen Methoden dürfen abstract oder virual jedoch nicht const oder static, auserdem werden sie mitvererbt. Wenn Methoden mit dem gleichen namen vorhanden sind können sie mit vorranstellen des namens eindeutig benannt werden (zb Iname –> obj von Iname, Iobj.funk1() ).Interfaces können natürlich selbst andere Interfaces Implementieren ( wie vererbung, also keine wiederholung der Methode nötig)
 
Der is-Operator liefert ture oder false. Mit ihm kann gecheckt werden ob das Objekt von einem typ ist, oder ob zb eine Schnittstelle implementiert wird. (zb if( obj is Iname) oder if(obj is System.Objekt ) )
Der as-Operator kann ähnlich genutzt werden, jedoch nimmt er gleich die Form an oder ist null.
( zb if(obj as Iname != null) oder obj = obj2 as System.Objekt wird also entweder null oder obj2 ist vom typ Sys.Obj ).
 
Strukturen sind sonderformen von Klassen. Grundsätzlich sind Stukturen als Sammlungen von verschiedenen Wertetypen gedacht sie werden von der Laufzeitumgebung als Wertetyp behandelt und schonen somit Systemresourcen d.h. es muss nicht mit klasse obj = new klasse(); eine Instanz gebildet werden sondern es reicht strukur obj;
Es wird allerdings dann kein Konstuktor aufgerufen und die direkte Zuweißung ( zb public int x =0; ) ist bei Strukts nicht erlaubt, in diesem fall müsste das obj dann mit obj.x =0; zugewiesen werden. Einsatz von Konstuktoren,Methoden, Verschachtelungen und Implementieren von Schnittstellen ist genauso wie bei Klassen möglich.
Allerdings ist der Hauptunterschied das weder vererbt noch geerbt werden kann.
 
Aufzählungen auch Enumerationen genannt sind Sammlungen vom gleichen Datentyp.Unterstüzt werden nur byte,short,int oder long. Sie sorgen dafür das zb Obst nicht mit Farben verglichen werden kann. Die Zuordnung erfolgt über public enum Obst : long { Apfel, Birne, Kirsche}, ohne der Zuordnung über den :-Operator ist der typ int. Sie müssen durch Komma getrennt werden, die Werte werden durchgezählt wenn nicht definiert. Wenn kein Startwert festgelegt wird (zb Apfel =-5, ) ist der Startwert Wert 0. Enumerationen können nicht innerhalb von Methoden zugewiesen werden.
Zugriff über zb Obst.Apfel (Wert Apfel). Auslesen der Werte (long)Obst.Apfel; (Wert -5 )
Durchlaufen aller Werte ist mit foreach möglich. foreach (Obst ob in Enum.GetValues(typeof(Obst)))
 
Delegates ( Funktionszeiger) leiten Mehtodenaufrufe weiter, indem es den Zeiger auf eine Objektmethode schiebt. Delegates werden zB mit public delegate int Operation (int wert1,int wert2) definiert. Durch anlegen eines Objektes (Operation prozess; ) kann dann mit prozess = new Operation(Methodenname) die Auswahl stattfinden. Wenn jetzt prozess(wert1,wert2); aufgerufen wird, landet man bei der Methode “Methodenname”. Delegates müssen keine Argumente und auch keinen Rückgabewert besitzen. Der eigentliche Vorteil von Delegates ist die multicast Fähigkeit, durch einen aufruf können so mehrere Methoden aufgerufen werden Operation[] proz = new Operation[2]; die zuordnung erfolgt über proz[0] = new Operation(Methode1); proz[1] = new Operation(Methode2); wenn jetzt der Befehl Operation array = (Operation)Delegate.Combine(proz); aufgerufen wird werden sie verbunden. Wird jetzt array(wert1,wert2); aufgerufen, werden beide Methoden gestartet. Combine kann entweder einen Array vom Typ Delegate oder 2 objekte dieses typs entgegennehmen.
Entfernen: Remove(Delegate source, Delegate value); ( zb proz1 = Delegate.Remove(proz1,proz2); )
Delegates können auch anonyme Methoden aufrufen zb prozess = delegate(int x,inty) { code }; aufruf davon folgt wie gewohnt mit prozess(wer1,wer2);anonyme Methoden dürfen contine,break oder goto nicht enthalten !
 
Eventhandler dienen dazu eine Methode auszuführen falls ein bestimmtes Ereigniss eintrifft,
 
Operatoren können überladen werden,( +,-,*,/,~,!,++,true,false,&,^,<,<= usw ). Die überladung geht durch
"public static Rückgabetyp operator Operator(Operand1,Operand2)".Oftmals ist es möglich wenn sie nur Paarweiße überladen werden können, wird == überladen muss dies auch mit != geschehen. Die überladung kann genutzt werden um zb auf einfache Art objekte mit >= zu vergleichen. public static bool operator >=(Klasse1 obj1, Klasse1 obj2) { code }
 
Auch Wertetypen wie int oder double könnenüberladen werden bei implicit braucht es kein boxing bei explicit schon.
“public static implicit operator Zieldatentyp(Eingabedatentyp){ return intWert; }”. Auruf: ( int x = obj ) bzw ( int x =(int)obj )
Dies gilt auch für die übergabe von Objekten von selbst definierten Klassen “public static implicit operator Klasse1(Klasse2 obj1)”. Bei der Konvertierung durch implizit können datenverluste auftreten bei explizit nicht.

Standards

Mathematische Befehle:
Math.Round(x,3); // Rundet x auf 3 Nachkommastellen
Math.Sqrt(x); Math.Pow(x, y); // Wurzel von x bzw x^y
Math.Exp(x); Math.Log(x);// e^x bzw log(x)
Math.Abs(x);// Absolut –> betrag -=+ und +=+
 
 
Strings:
StringBuilder str = new StringBuilder(“Das ist”); // Erstellt Objekt von Stringbuilder: s2
str.Append(” ein”); // Reiht ” ein” an
str.Append(” String”);// Reiht ” String” an
str[0] = ‘h’; // Setzt erste stelle von s2 auf “h” ( char mit ”)

static StringBuilder[] str = { new StringBuilder(“XXX”), new StringBuilder(“XXX”), }; //zb zugriff mit str[0][1]

str2 = String.Copy(str1); // Kopiert str1 in str2
str = str.Insert(3,”asdf”); // fügt ab der 3ten(3 exkludet) stelle asdf ein
str = str.Remove(3,4); // Löscht ab der 3ten(3 exkludet stelle 4 Zeichen
str2 = str.Substring(3); //Kopiert in str2 alles ab dem 3ten(3 exkludet) Zeichen
str1 = “hallo”; str2 = ” Welt”; str3 = str1 + str2; //str3 = “hallo Welt”

StreamReader sr = new StreamReader(fname); //Erstellt SR auf file
String str = sr.ReadToEnd(); // Liest ganze datei ein
int indexGBP = str.IndexOf(“GBP”); //erstellt die nummer des zu suchenden
String temp = str.Substring(indexGBP); // schneidet alles VOR der nummer weg!
String[] temp_array = temp.Split(‘\”); // Erstellt array nach jedem \
sr.Close();
double x = Convert.ToDouble(temp_array[2].Replace(“.”, “,”)); //hohlt sich das 2te raus! und ersetzt . durch, !
string[] woerter; // Inhalt wort für wort ausgeben !
woerter = string.Split(new char[] { ‘ ‘ });
foreach (string w in woerter)
Console.WriteLine(w);

Arrays:
int [] g = {1,3,4,5,1,2,3,5} //erstellt array g mit festen Werten
int [] f = new int[100]; //erstellt array f mit 100 Werten
double[] [] matrix = new double [3][]; //erstellt array maxtrix
matrix.GetLengh(0) //gibt die länge der 1. Dimension

Foreach:
foreach (int x in f) // Schleife: durchläuft den Array, gibt in x den Wert der jeweiligen Stelle aus.
foreach (char c in s2) ; //Schleife: durchläuft s2, gibt in c das Zeichen der jeweiligen Stelle aus.
Random:
Random rnd = new Random();
x = rnd.Next(); // Zufallswert ( von 0-999999)
x = rnd.Next(10);// Zufallswert ( von 0-9)
x = rnd.NextDouble();// Zufallswert (0,00… – 0,99….)
Zeit:
DateTime t1 = DateTime.Now; // Start Initialisierung
DateTime t2 = new DateTime(1987, 1, 21, 24,00,00); // jjjj,dd,mm,hh,mm,ss(oder einfach nur jjjj,dd,mm)
Console.WriteLine(“Zeit: ” + (DateTime.Now – t1)); // Ausgabe der Rechenzeit
Stopwatch sw = new Stopwatch(); // legt objekt an
sw.Start(); sw.Stop(); // start bzw stop
Console.WriteLine(sw.ElapsedMilliseconds); // Ausgabe

Boxing
double x = 99.99; int y = (int)x; //Überführt den Double in int ( Keine Rundung –> y=99)

Schleifen:
break; // Springt komplett aus der schleife hinaus
continue;// Springt zum Schleifenkopf ( unterbricht nur den einen durchgang)

Ausgabe:
Console.WriteLine(“1.Zahl{0:D8}, 2.Zahl{1}, 3.Zahl{2}”, x, y, z); // D8 Lässt die leern stellen mit 0 auffüllen ( 8 ziff.)
Console.WriteLine(“1.Zahl{0:F3}, 2.Zahl{1}, 3.Zahl{2}”, x, y, z); // F3 Lässt 3 stellen nach dem Komma noch da
 
 

Switch & einfache if ( ?:) :
 
y=(x==0? 1:x); // wenn x == 0 dann y = 1 sonst y=x
switch (i)
{ case ‘A’: Console.WriteLine(“\tSie haben A gewählt”); break;
case ‘B’: Console.WriteLine(“\tSie haben B gewählt”); break;
default: Console.WriteLine(“\tFalsche Eingabe”); break; }
 
LOAD SAVE:
FileStream fs1 = new FileStream(“Text.txt”, FileMode.Create);
StreamWriter w = new StreamWriter(fs1);
w.WriteLine(“Hallo”);
w.Close();
FileStream y = new FileStream(“Text.txt”, FileMode.Open);
StreamReader r = new StreamReader(y);
Console.WriteLine(r.ReadLine());
r.Close();
File.Exists(“Artikel.txt”)

REGEX:
using System.Text.RegularExpressions;
Regex numcheck = new Regex(“^[0-9]*$”);
int x;
bool isnum = numcheck.IsMatch(XX.Text);
if(isnum)
x = Convert.ToInt32(XX.Text);
else
zb: MessageBox.Show(“keine zahl!”)

Allgemeines
Die Grundsätze, also Befehle die man hin und wieder braucht. Manches wie das #region, will ich dem ein oder anderen nur mal wieder ins Gedächtniss rufen.
(more…)