In diesem Artikel möchte ich eine kleine Einführung in C#.NET geben und kurz und bündig erklären, was C#.NET ist; Besonderheiten und Ähnlichkeiten zu anderen Sprachen sind auch mit ein Thema.
Wirklich neu:
• Referenz- und Output-Parameter
• Rectangular Arrays
• Unified type system
• Versionierung
Alle Typen sind kompatibel zu "Object". Ebenso können alle Typen Variablen vom Typ Object zugewiesen werden und es sind alle Objekt-Operationen auf sie anwendbar.
Unterschied zwischen Werttypen (value types) und Referenztypen (reference types):
Werttypen:
Werttypen enthalten Werte, die in ihnen gespeichert werden. Sie werden auf dem Stack gespeichert. Bei einer Zuweisung wird der Wert kopiert. Die Initialisierung von Werttypen kann wie folgt aussehen:
C# Code:
int n = 0;
// oder bool b = false;
//z.B.: int i = 99;
int j = i;
C# Code:
int n = 0;
// oder bool b = false;
//z.B.: int i = 99;
int j = i;
C# Code:
int n = 0;
// oder bool b = false;
//z.B.: int i = 99;
int j = i;
Referenztypen:
Im Gegenteil zu Werttypen werden in Referenztypen, wie der Name schon sagt, Referenzen zu Objekten gespeichert. Bei Zuweisungen wird ebenfalls die Referenz kopiert, keine Werte. Referenzen werden auch nicht auf dem Stack, sondern auf dem Heap gespeichert und werden immer mit null initialisiert.
C# Code:
string s = "cool";
string s1 = s;
C# Code:
string s = "cool";
string s1 = s;
C# Code:
string s = "cool";
string s1 = s;
3 Enumerationen
Liste von namenhaften Konstanten, deren Deklaration direkt im Namespace geschieht.
Beispiel:
C# Code:
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
enum Farbe{rot, gelb, blau, gruen, lila} // hier sind die Variablen automatisch 0, 1, 2... enum WochenTage_mit_d{dienstag=2,donnerstag=4}
enum WochenTage_mit_d:byte{dienstag=2,donnerstag=4}
//Verwendung:
Farbe c = Farbe.blau;
WochenTage_mit_d WTmd = WochenTage_mit_d.dienstag | WochenTage_mit_d.donnerstag;
if ((WochenTage_mit_d.dienstag & WTmd) != 0)
Console.WriteLine("Wochentag ist mit D!");
C# Code:
1 2 3 4 5 6 7 8 9
enum Farbe{rot, gelb, blau, gruen, lila} // hier sind die Variablen automatisch 0, 1, 2... enum WochenTage_mit_d{dienstag=2,donnerstag=4}
enum WochenTage_mit_d:byte{dienstag=2,donnerstag=4}
//Verwendung:
Farbe c = Farbe.blau;
WochenTage_mit_d WTmd = WochenTage_mit_d.dienstag | WochenTage_mit_d.donnerstag;
if ((WochenTage_mit_d.dienstag & WTmd) != 0)
Console.WriteLine("Wochentag ist mit D!");
C# Code:
1 2 3 4 5 6 7 8 9
enum Farbe{rot, gelb, blau, gruen, lila} // hier sind die Variablen automatisch 0, 1, 2... enum WochenTage_mit_d{dienstag=2,donnerstag=4}
enum WochenTage_mit_d:byte{dienstag=2,donnerstag=4}
//Verwendung:
Farbe c = Farbe.blau;
WochenTage_mit_d WTmd = WochenTage_mit_d.dienstag | WochenTage_mit_d.donnerstag;
if ((WochenTage_mit_d.dienstag & WTmd) != 0)
Console.WriteLine("Wochentag ist mit D!");
Was kann man mit Enumerationen machen?
Die Operatoren sind:
C# Code:
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11 12
// Vergleichsoperatoren ==; <=; >=; <; > if(c == Farbe.blau)//... if(c > Farbe.gelb && c < Farbe.lila)//...
//weitere sind +; -; ++; --;
c = c+2;
c--;
//oder gleich
c++;
// dann noch &; |; ~ if ((c & Farbe.rot) == 0)// ...
c = c | Farbe.blau;
c = ~ Farbe.rot;
C# Code:
1 2 3 4 5 6 7 8 9 10 11 12
// Vergleichsoperatoren ==; <=; >=; <; > if(c == Farbe.blau)//... if(c > Farbe.gelb && c < Farbe.lila)//...
//weitere sind +; -; ++; --;
c = c+2;
c--;
//oder gleich
c++;
// dann noch &; |; ~ if ((c & Farbe.rot) == 0)// ...
c = c | Farbe.blau;
c = ~ Farbe.rot;
C# Code:
1 2 3 4 5 6 7 8 9 10 11 12
// Vergleichsoperatoren ==; <=; >=; <; > if(c == Farbe.blau)//... if(c > Farbe.gelb && c < Farbe.lila)//...
//weitere sind +; -; ++; --;
c = c+2;
c--;
//oder gleich
c++;
// dann noch &; |; ~ if ((c & Farbe.rot) == 0)// ...
c = c | Farbe.blau;
c = ~ Farbe.rot;
Der Compiler prüft nicht, ob der Enum-Typ einen gültigen Wert annimmt.
Enumerationen können Integern nur nach explizitem Cast zugewiesen werden!
Enumerationen erben vom Typ Object, somit: Equals, ToString, ...
Die Klasse System.Enum unterstützt Operationen wie GetName, Format, GetValues, ...
4 Felder (Arrays)
Eindimensionale Arrays:
C# Code:
int[] a = new int[3];
C# Code:
int[] a = new int[3];
C# Code:
int[] a = new int[3];
Mehrdimensionale Felder:
"ausgefranzte":
C# Code:
int[][] ausgefr = new int[5][];
ausgefr[0] = new int[3];
a[1] = new int[4];
C# Code:
int[][] ausgefr = new int[5][];
ausgefr[0] = new int[3];
a[1] = new int[4];
C# Code:
int[][] ausgefr = new int[5][];
ausgefr[0] = new int[3];
a[1] = new int[4];
Solche Felder sind nicht sehr schnell und brauchen mehr Speicher als
rechteckige Felder:
C# Code:
int[,] re = new int[2, 3];
C# Code:
int[,] re = new int[2, 3];
C# Code:
int[,] re = new int[2, 3];
Hier sind die Zugriffe effizienter und die Felder kompakter.
5 Boxing und Unboxing
Boxing ist das Stichwort zur Umwandlung von Structs, Enums oder primitiven Datentypen in ein Objekt. Objekten können somit andere Typen zugewiesen werden. Das könnte dann so aussehen:
C# Code:
int nZahl=5;
object obj = nZahl;
C# Code:
int nZahl=5;
object obj = nZahl;
C# Code:
int nZahl=5;
object obj = nZahl;
Unboxing ist genau das Gegenteil, nämlich aus einem Objekt einen Werttyp machen. Das sieht dann so aus:
C# Code:
int Zahl_aus_obj = (int)obj;
C# Code:
int Zahl_aus_obj = (int)obj;
C# Code:
int Zahl_aus_obj = (int)obj;
und schon hat man aus dem Objekt einen Integer gemacht.
6 Overflow Checks
Standardmäßig werden Overflows nicht abgefangen, somit kann es zu unerwünschtem Verhalten kommen. Da es aber auch sein kann, dass man mit Overflows arbeitet (Zufallszahlen) kann man manuell Overflows abfangen.
C# Code:
int grosse_Zahl = 999999;
grosse_Zahl *= grosse_Zahl;
// ergibt nicht mathematisch richtiges Ergebnis aber auch keinen Fehler
// wenn man es abfangen will, sollte man es besser so machen:
grosse_Zahl = checked(grosse_Zahl*grosse_Zahl);
//wirft OverflowException
C# Code:
int grosse_Zahl = 999999;
grosse_Zahl *= grosse_Zahl;
// ergibt nicht mathematisch richtiges Ergebnis aber auch keinen Fehler
// wenn man es abfangen will, sollte man es besser so machen:
grosse_Zahl = checked(grosse_Zahl*grosse_Zahl);
//wirft OverflowException
C# Code:
int grosse_Zahl = 999999;
grosse_Zahl *= grosse_Zahl;
// ergibt nicht mathematisch richtiges Ergebnis aber auch keinen Fehler
// wenn man es abfangen will, sollte man es besser so machen:
grosse_Zahl = checked(grosse_Zahl*grosse_Zahl);
//wirft OverflowException
Man kann aber nicht nur einzelne Operationen mit checked prüfen, man kann auch ganze Blöcke prüfen:
C# Code:
checked{
grosse_Zahl *= grosse_Zahl;
}
//wirft ebenso Overflow Exception
C# Code:
checked{
grosse_Zahl *= grosse_Zahl;
}
//wirft ebenso Overflow Exception
C# Code:
checked{
grosse_Zahl *= grosse_Zahl;
}
//wirft ebenso Overflow Exception
Wenn man allerdings das komplette Assembly geprüft ausführen will, kann man checked als Compiler-Parameter angeben.
csc /checkedTest.cs
7 Deklarationen
Folgende Grafik soll zeigen, wie Dateneinheiten deklariert werden können.
Variablen sind in niederen Deklarationsräumen verfügbar. Es dürfen somit keine Variablennamen aus höheren verwendet werden, da Namen nicht mehrfach in demselben Deklarationsraum benutzt werden dürfen. Zwei gleichnamige Namensräume in unterschiedlichen Files führen zu einem Deklarationsraum. Dies hat zur Folge, dass Variablen auch in diesen anderen Files verfügbar sind. Andere Namespaces müssen importiert oder spezifiziert werden. So benutzt man z.B. meist
C# Code:
using System;
C# Code:
using System;
C# Code:
using System;
8 Anweisungen (Statements)
Die gelisteten Ausdrücke dürften aus anderen Programmiersprachen bekannt sein, deshalb sind sie nur sehr karg kommentiert. Es soll mehr eine Beispielsammlung sein.
//Zuweisungen
z += 58*R;
//Methodenaufrufe string str = "h.e.l.l.o";
string[] geteilt = s.Split('.');
s = String.Join(" ",geteilt);
//if-Abfragen if(x>=0 && x<=10)
x++;
else if (x>=20 && x<=30)
x +=5;
else
x=0;
//switch switch(Font)
{
case "Überschrift 1": "Heading 1":
Fontsize = 24;
break;
case "Überschrift 2": "Heading 2":
Fontsize = 20;
break;
case null:
Console.WriteLine("Kein Schema angegeben");
break;
default:
Console.WriteLine("Kenne die Grösse nicht");
break;
}
//auch gotos sind in switch-Anweisungen möglich
//Schleifen while (i>n)
{
sum+=i;
i--;
}
do
{
sum += a[ i ];
i++;
}
while (i<n);
for (int i=0; i<n; i++)
sum+=i;
// Schleife für Arrays (z.B. auch Strings) int[] x = {1,2,3,4,5,6,7,8,9};
foreach (int z in x) sum +=z;
9 Klassen und Strukturen
- Klassen:
• Objekte liegen auf dem Heap (Referenztypen)
• Erzeugung von Objekten mit new
C# Code:
Stack s = new Stack(255);
C# Code:
Stack s = new Stack(255);
C# Code:
Stack s = new Stack(255);
• können erben, vererben und Interfaces implementieren (alle Klassen von object abgeleitet)
• dürfen Destruktor besitzen
Konstruktoren:
Konstruktoraufruf erzeugt neues Objekt auf dem Heap und initialisiert es
• überladbar
• this ruft anderen Konstruktor auf (im Kopf des Konstruktors)
• erst Initialisierungen, dann Konstruktoren
• kein Konstruktor => parameterloser Default-Konstruktor (nur dann)
- Strukturen:
• Objekte liegen auf dem Stack (Werttypen)
• Können mit new erzeugt werden (ohne new sind Felder nicht initialisiert)
• Felder dürfen bei der Deklaration nicht initialisiert werden
C# Code:
struct rechteck
{
int laenge = 0;// Compiler-Fehler int breite;//OK
...
}
C# Code:
struct rechteck
{
int laenge = 0;// Compiler-Fehler int breite;//OK
...
}
C# Code:
struct rechteck
{
int laenge = 0;// Compiler-Fehler int breite;//OK
...
}
• Konstruktoren müssen mindestens einen Parameter besitzen
• können Interfaces implementieren (aber nicht erben oder vererben)
• dürfen keinen Destruktor besitzen
Konstruktoren:
Konstruktor-Aufruf erzeugt neues Objekt auf dem Stack!
• haben immer einen parameterlosen Default-Konstruktor
• => keinen eigenen parameterlosen Konstruktor anlegen
Es gibt keine anonymen Klassen (wie in Java)
Es gibt keine Templates (wie in C++)
10 Referenz
Die . NET-Technologie. Grundlagen und Anwendungsprogrammierung. von Wolfgang Beer, u. a. Dpunkt Verlag (Oktober 2002)
die Einführung gilt nur für .NET 1.x. Im .NET Framework 2.0 gibt es sehr wohl Templates sowie anonyme Methoden.
Außerdem stimmt folgendes nicht ganz:
Polofreak schrieb:
Konstruktor-Aufruf erzeugt neues Objekt auf dem Stack!
• haben immer einen parameterlosen Default-Konstruktor
• => keinen eigenen parameterlosen Konstruktor anlegen
wenn man in einer Klasse folgendes macht:
C# Code:
public class TestClass
{
public TestClass(int a)
{
}
}
C# Code:
public class TestClass
{
public TestClass(int a)
{
}
}
C# Code:
public class TestClass
{
public TestClass(int a)
{
}
}
Hat die Klasse KEINEN!!! parameterlosen Default-Konstruktor mehr. Dann muss man einen eigenen parameterlosen Default-Konstruktor anlegen:
Nein, in C# 2.0 gibt es keine Templates, sondern nur Generics. Dazwischen besteht ein deutlicher Unterschied.
Was heißt nur. C++ Templates sind zwar first class, haben aber auch einige Nachteile. Sie können einen ziemlichen code bloat verursachen. Binaries von Programen die intensiv dieses Feature nutzen werden nämlich recht fett. Ein Problem das ich leider gerade habe ...
Auch kannst du mit .NET Generics andere nette Dinge machen, die mit C++ Templates nicht funktionieren. z.B Typ-Parametrisierte virtuelle Methoden.
Solche Felder sind nicht sehr schnell und brauchen mehr Speicher als
rechteckige Felder:
C# Code:
int[,] re = new int[2, 3];
C# Code:
int[,] re = new int[2, 3];
C# Code:
int[,] re = new int[2, 3];
Hier sind die Zugriffe effizienter und die Felder kompakter.
Das ist falsch, jagged Arrays sind - zumindest bislang - schneller als MD-Arrays (ja, trotz doppelter Indirektion). Kann man ganz leicht selber testen. Oder eben nachlesen, z.B.:
Nächstes Thema anzeigen Vorheriges Thema anzeigen
Sie können keine Beiträge in dieses Forum schreiben. Sie können auf Beiträge in diesem Forum antworten. Sie können Ihre Beiträge in diesem Forum nicht bearbeiten. Sie können Ihre Beiträge in diesem Forum nicht löschen. Sie können an Umfragen in diesem Forum nicht mitmachen.
c++.de ist Teilnehmer des Partnerprogramms von Amazon Europe S.à.r.l. und Partner des Werbeprogramms, das zur Bereitstellung eines Mediums
für Websites konzipiert wurde, mittels dessen durch die Platzierung von Werbeanzeigen und Links zu amazon.de
Werbekostenerstattung verdient werden kann.
Die Vervielfältigung der auf den Seiten www.c-plusplus.de, www.c-plusplus.info, www.c-sar.de, www.c-plusplus.net und www.baeckmann.de
enthaltenen Informationen ohne eine schriftliche Genehmigung des Seitenbetreibers ist untersagt
(vgl. §4 Urheberrechtsgesetz). Die Nutzung und Änderung der vorgestellten Strukturen und Verfahren in
privaten und kommerziellen Softwareanwendungen ist ausdrücklich erlaubt, soweit keine Rechte Dritter verletzt werden.
Der Seitenbetreiber übernimmt keine Gewähr für die Funktion einzelner Beiträge oder Programmfragmente, insbesondere
übernimmt er keine Haftung für eventuelle aus dem Gebrauch entstehenden Folgeschäden.
Twitter
Facebook
Der Compiler prüft nicht, ob der Enum-Typ einen gültigen Wert annimmt.
Es gibt keine anonymen Klassen (wie in Java)
