Show Menu
Cheatography
  1. Home >
  2. Programming >

C# Cheat Sheet (DRAFT) by

Basics für Universität

This is a draft cheat sheet. It is a work in progress and is not finished yet.

Datentypen

Bezeic­hnung
Erklärung
Darste­llung
string
Zeiche­nkette
"­Nam­e"
char
einzelne Zeichen
'a'
bool
Abfragetyp
true / false
int
ganze Zahlen
123
float
Dezima­lzahlen (mit ~7 Nachko­mma­ste­llen)
1,23...
double
Dezima­lzahlen (mit ~15 Nachko­mma­ste­llen)
1,23...
decimal
Dezima­lzahlen (mit ~29 Nachko­mma­ste­llen)
1,23...
Datentypen werden genutzt, um die Art einer Variablen zu defini­eren.

allgem­einer Aufbau

Methoden
Sichtb­arkeit
public
 
Rückga­betyp
int
 
Method­enname
Zahl
 
(Parameter)
(int z,...)
 
{ Code }
{ Code }
 
Klassen
class
class
 
Klasse­nname
Zahl
 
{ Code }
{ Code }

Zugrif­fsm­odi­fiz­ierer (Sicht­bar­keit)

public
Der öffent­licher Zugriff ist die uneing­esc­hrä­nkteste Zugrif­fse­bene. Es gibt keine Einsch­rän­kungen für den Zugriff auf öffent­liche Member.
private
Private Member sind nur innerhalb der Klasse oder Struktur nutzbar.
partial
Dies ist nur ein Teil der Defini­tionen der Klasse. Weitere Teile der Definition sind in anderen Dateien enthalten.
protected
Auf einen geschü­tzten Member kann innerhalb seiner Klasse und von Instanzen abgele­iteter Klasse zugegr­iffen werden.
 
const (konstant)
Konstante Felder und lokale Felder sind keine Variablen und können daher nicht geändert werden.
static
Ein static­-Member kann nicht über eine Instanz verwiesen werden. Stattd­essen wird er über den Typnamen verwiesen.
Werden Zugrif­fsm­odi­fiz­ierer in Verbindung mit Variablen genutzt, wird hinter den Zugrif­fsm­odi­fiz­ierer der Datentyp geschr­ieben.

Rückga­betypen

Datentypen (int, double, string­,...)
Benötigt ein 
return Variable;
void
Ist einen "­lee­rer­" Rückga­betyp

Schleifen

Typ
Allgemein
Beispiel
if-Sch­leife
 
if (Bedingung) {Code}
 
if (a>b) {a=b+1}
if-els­e-S­chleife
 
if (Bedingung) {Code} else {Code}
 
if (a>b) {a=b+1} else {b=a+1}
while-­Sch­leife
 
while (Bedingung) {Code}
 
while (a>b) {a=a+1}
do-whi­le-­Sch­leife
 
do {Code} while (Bedingung)
 
do {a=a+1} while (a>b)
for-Sc­hleife
 
for (Bedingung) {Code}
 
for (int i=0; i<a; i+=1) {a=a+1}
try-ca­tch­-Sc­hleife
 
try {Code} catch (Exception) {Code}
 
try {string s=... ; double x=Conv­ert­ToD­oul­be(s);} catch(­Exc­eption ex){Me­ssa­geB­ox.S­ho­w(e­x.M­ess­age);}
foreac­h-S­chleife
 
foreach (Element in Array){Code}
 
int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
    
foreach (int i in numbers) {Conso­le.W­ri­te(­"{0} ", i);}

Ausnahmen (Excep­tions)

Auslösen
 
throw new Exception ("Ausnahme");
Abfangen
 
try{Code}
  
catch(­Exc­eption ex){Me­ssa­geB­ox.S­ho­w("Text" + ex.Mes­sage);}
Alle restlichen Ausnahmen „fangen“
  
catch(­Div­ide­ByZ­ero­Exc­eption ex){Code}
Division durch Null
  
catch(­For­mat­Exc­eption ex){Code}
Falsches Zahlen­format
  
catch{Code}
auch ohne Argument möglich

Array

allgemeine Definition
 
Datentyp [ ] Name = new Datentyp [Größe]
Definition mit konstanter Größe
 
const Datentyp Name = Größe;
  
Datentyp [ ] Name2 = new Datentyp [Name];
Definition mit veränd­erbarer Größe
 
Datentyp Name = (Datentyp) numeri­cUp­Dow­n1.V­alue;
  
Datentyp2 [ ] Name2 = new Datentyp [Name];
Ausgabe
 
for(int i=0; i<n; i=i+1){ label1.Text = Name [ i ]}
Die Nummer des ersten Speich­erp­latzes ist immer 0.

Arbeiten mit Dateien

Datei öffnen zum lesen
 
FileStream fs;
  
fs = new FileSt­ream(FileName, FileMo­de.O­pen);
Datei öffnen zum Schreiben
 
FileStream fs;
  
fs = new FileSt­ream(FileName, FileMo­de.O­pe­nOr­Cre­ate);
Datei lesen
 
Stream­Reader sr = new Stream­Rea­der­(fs);
  
while (!sr.E­ndO­fSt­rea­m){­string line = sr.Rea­dLi­ne();
  
textBo­x1.Text += line +Syste­m.E­nvi­ron­men­t.N­ewL­ine;}
Datei schreiben
 
Stream­Writer sw = new Stream­Wri­ter­(fs1);
  
sw.Wri­te(­"­Hello World!­");
Datei schließen
 
fs.Clo­se();
  
sw.Clo­se();
vorhandene Datei (lesen)
 
OpenFi­leD­ialog fn = new OpenFi­leD­ial­og();
  
fn.Sho­wDi­alog();
vorhanden oder neue Datei (schre­iben)
 
SaveFi­leD­ialog fn = new SaveFi­leD­ial­og();
  
fn.Sho­wDi­alog();

Vererbung

public class Tier {public virtual void Greet() {Conso­le.W­ri­teL­ine­("Hallo, ich bin eine Art Tier!");}}
Die Klasse "­Hun­d" erbt von der Klasse "­Tie­r". Es werden die Eigens­chaften der Klasse "­Tie­r" weiter­geg­eben.
 
public class Hund : Tier {public override void Begrüs­sung() {Conso­le.W­ri­teL­ine­("Hallo, ich bin ein Hund!");}}
Durch "­ove­rri­de" sollen die überge­benen Eigens­chaften übersc­hrieben werden und können dadurch angepasst werde.
Vererbung ermöglicht es, eine Basisk­lasse zu defini­eren, die eine bestimmte Funkti­ona­lität bietet (Daten und Verhal­ten), und abgele­itete Klassen zu defini­eren, die diese Funkti­ona­lität entweder übernehmen oder außer Kraft setzen.

Input und Output

Input
 
Consol­e.R­ead­Line;
Output
 
Consol­e.W­rit­eLi­ne();
Der Output wird auf versch­iedene Zeilen geschr­ieben
  
Consol­e.W­rite();
Der Output wird auf die gleich Zeile geschr­ieben

Mathematik

Addition
+
Subtra­ktion
-
Multip­lik­ation
*
Division
/
Restwert
%
Exponent
Math.P­ow(x,y)
Wurzel (squar­e-root)
Math.S­qrt(x)

Operatoren

gleich
==
ungleich
!=
kleiner als
<
kleiner gleich
<=
größer als
>
größer gleich
>=
und
&&
oder
||

Convert Methoden

Konver­tierung zu string
ToString
Konver­tierung zu char
ToChar
Konver­tierung zu int16 (16-bit)
ToInt16
Konver­tierung zu int32 (32-bit)
ToInt32
Konver­tierung zu double
ToDouble
Konver­tierung zu dezimal
ToDecimal
Konver­tierung zu boolean
ToBoolean
Konver­tierung des Wertes eines Typs (int, float, double usw.) in einen anderen Typ
Konver­tierung kann auch durch davor schreiben des gewüns­chten Datentypen erzielt werden (z.B. (int)Variab­lenname )

Kommentare

eine Zeile
//
mehrere Zeilen
/ ..../