Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 6. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Das Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Strukturen und Enumerationen
7 Fehlerbehandlung und Debugging
8 Auflistungsklassen (Collections)
9 Generics – Generische Datentypen
10 Weitere C#-Sprachfeatures
11 LINQ
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 XML
15 Multithreading und die Task Parallel Library (TPL)
16 Einige wichtige .NET-Klassen
17 Projektmanagement und Visual Studio 2012
18 Einführung in die WPF und XAML
19 WPF-Layout-Container
20 Fenster in der WPF
21 WPF-Steuerelemente
22 Elementbindungen
23 Konzepte von WPF
24 Datenbindung
25 Weitere Möglichkeiten der Datenbindung
26 Dependency Properties
27 Ereignisse in der WPF
28 WPF-Commands
29 Benutzerdefinierte Controls
30 2D-Grafik
31 ADO.NET – Verbindungsorientierte Objekte
32 ADO.NET – Das Command-Objekt
33 ADO.NET – Der SqlDataAdapter
34 ADO.NET – Daten im lokalen Speicher
35 ADO.NET – Aktualisieren der Datenbank
36 Stark typisierte DataSets
37 Einführung in das ADO.NET Entity Framework
38 Datenabfragen des Entity Data Models (EDM)
39 Entitätsaktualisierung und Zustandsverwaltung
40 Konflikte behandeln
41 Plain Old CLR Objects (POCOs)
Stichwort

Download:
- Beispiele, ca. 62,4 MB

Buch bestellen
Ihre Meinung?

Spacer
Visual C# 2012 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2012

Visual C# 2012
Rheinwerk Computing
1402 S., 6., aktualisierte und erweiterte Auflage 2013, geb., mit DVD
49,90 Euro, ISBN 978-3-8362-1997-6
Pfeil 2 Grundlagen der Sprache C#
Pfeil 2.1 Konsolenanwendungen
Pfeil 2.1.1 Allgemeine Anmerkungen
Pfeil 2.1.2 Ein erstes Konsolenprogramm
Pfeil 2.2 Grundlagen der C#-Syntax
Pfeil 2.2.1 Kennzeichnen, dass eine Anweisung abgeschlossen ist
Pfeil 2.2.2 Anweisungs- und Gliederungsblöcke
Pfeil 2.2.3 Kommentare
Pfeil 2.2.4 Die Groß- und Kleinschreibung
Pfeil 2.2.5 Die Struktur einer Konsolenanwendung
Pfeil 2.3 Variablen und Datentypen
Pfeil 2.3.1 Variablendeklaration
Pfeil 2.3.2 Der Variablenbezeichner
Pfeil 2.3.3 Der Zugriff auf eine Variable
Pfeil 2.3.4 Ein- und Ausgabemethoden der Klasse »Console«
Pfeil 2.3.5 Die einfachen Datentypen
Pfeil 2.3.6 Typkonvertierung
Pfeil 2.4 Operatoren
Pfeil 2.4.1 Arithmetische Operatoren
Pfeil 2.4.2 Vergleichsoperatoren
Pfeil 2.4.3 Logische Operatoren
Pfeil 2.4.4 Bitweise Operatoren
Pfeil 2.4.5 Zuweisungsoperatoren
Pfeil 2.4.6 Stringverkettung
Pfeil 2.4.7 Sonstige Operatoren
Pfeil 2.4.8 Operator-Vorrangregeln
Pfeil 2.5 Datenfelder (Arrays)
Pfeil 2.5.1 Die Deklaration und Initialisierung eines Arrays
Pfeil 2.5.2 Der Zugriff auf die Array-Elemente
Pfeil 2.5.3 Mehrdimensionale Arrays
Pfeil 2.5.4 Festlegen der Array-Größe zur Laufzeit
Pfeil 2.5.5 Bestimmung der Array-Obergrenze
Pfeil 2.5.6 Die Gesamtanzahl der Array-Elemente
Pfeil 2.5.7 Verzweigte Arrays
Pfeil 2.6 Kontrollstrukturen
Pfeil 2.6.1 Die »if«-Anweisung
Pfeil 2.6.2 Das »switch«-Statement
Pfeil 2.7 Programmschleifen
Pfeil 2.7.1 Die »for«-Schleife
Pfeil 2.7.2 Die »foreach«-Schleife
Pfeil 2.7.3 Die »do«- und die »while«-Schleife

Galileo Computing - Zum Seitenanfang

2.6 KontrollstrukturenZur nächsten Überschrift

Es gibt sicherlich kein Programm, das ohne die Steuerung des Programmablaufs zur Laufzeit auskommt. Das Programm muss Entscheidungen treffen, die vom aktuellen Zustand oder von den Benutzereingaben abhängen. Jede Programmiersprache kennt daher Kontrollstrukturen, um den Programmablauf der aktuellen Situation angepasst zu steuern. In diesem Abschnitt werden Sie die Möglichkeiten kennenlernen, die Sie unter C# nutzen können.


Galileo Computing - Zum Seitenanfang

2.6.1 Die »if«-AnweisungZur nächsten ÜberschriftZur vorigen Überschrift

Die if-Anweisung bietet sich an, wenn bestimmte Programmteile nur beim Auftreten einer bestimmten Bedingung ausgeführt werden sollen. Betrachten wir dazu das folgende Beispiel:

static void Main(string[] args) {
Console.Write("Geben Sie Ihren Namen ein: ");
string name = Console.ReadLine();
if(name == "")
Console.WriteLine("Haben Sie keinen Namen?");
else
Console.WriteLine("Ihr Name ist \'{0}\'",name);
Console.ReadLine();
}

Listing 2.20 Einfache »if«-Anweisung

Das Programm fordert den Anwender dazu auf, seinen Namen einzugeben. Die Benutzereingabe wird von der Methode ReadLine der Klasse Console entgegengenommen und als Rückgabewert des Aufrufs der Variablen name zugewiesen. Um sicherzustellen, dass der Anwender überhaupt eine Eingabe vorgenommen hat, die aus mindestens einem Zeichen besteht, wird der Inhalt der Stringvariablen name mit

if (name == "")

überprüft. Wenn name einen Leerstring enthält, wird an der Konsole

Haben Sie keinen Namen?

ausgegeben. Beachten Sie, dass die zu prüfende Bedingung hinter dem Schlüsselwort if grundsätzlich immer einen booleschen Wert, also true oder false, zurückliefert. Hat der Anwender eine Eingabe gemacht, wird die Eingabe mit einem entsprechenden Begleittext an der Konsole ausgegeben.

Das Kernkonstrukt der Überprüfung ist die if-Struktur, deren einfachste Variante wie folgt beschrieben wird:

if (Bedingung)
[...]
[else
[...]

Die if-Anweisung dient dazu, in Abhängigkeit von der Bedingung entweder die Anweisung1 oder die Anweisung2 auszuführen. Ist die Bedingung wahr, wird die Anweisung1 ausgeführt, ansonsten die Anweisung2 hinter dem else-Zweig – falls ein solcher angegeben ist, denn der else-Zweig ist optional.

Beachten Sie, dass es sich bei der Bedingung in jedem Fall um einen booleschen Ausdruck handelt. Diese Anmerkung ist wichtig, denn wenn Sie bereits mit einer anderen Programmiersprache wie beispielsweise C/C++ gearbeitet haben, werden Sie wahrscheinlich zum Testen einer Bedingung einen von 0 verschiedenen Wert benutzt haben. In C# funktioniert das nicht! Nehmen wir an, Sie möchten feststellen, ob eine Zeichenfolge leer ist, dann müssten Sie die Bedingung wie folgt definieren:

// Deklaration und Initialisierung der Variablen myText

string text = "";
[...]
if(0 != text.Length)
Console.Write("Inhalt der Variablen = {0}", text);

Length liefert, wenn sie auf die Variable einer Zeichenfolge aufgerufen wird, die Anzahl der Zeichen zurück.

Da es in C# keine Standardkonvertierung von einem int in einen bool gibt, wäre es falsch, die Bedingung folgendermaßen zu formulieren:

// ACHTUNG: In C# nicht zulässig

if (text.Length)...

In einer if-Bedingung können Sie beliebige Vergleichsoperatoren einsetzen, auch in Kombination mit den logischen Operatoren. Das kann zu verhältnismäßig komplexen Ausdrücken führen, beispielsweise:

if (a <= b && c != 0)...
if ((a > b && c < d)||(e != f && g < h))...

Bisher sind wir vereinfachend davon ausgegangen, dass unter einer bestimmten Bedingung immer nur eine Anweisung ausgeführt wird. Meistens müssen jedoch mehrere Anweisungen abgearbeitet werden. Um mehrere Anweisungen beim Auftreten einer bestimmten Bedingung auszuführen, müssen diese lediglich in einen Anweisungsblock zusammengefasst werden, beispielsweise:

static void Main(string[] args) {
Console.Write("Geben Sie eine Zahl zwischen 0 und 9 ein: ");
int zahl = Convert.ToInt32(Console.ReadLine());
if(zahl > 9 || zahl < 0) {
Console.WriteLine("Ihre Zahl ist unzulässig");
Console.Write("Versuchen Sie es erneut: ");
zahl = Convert.ToInt32(Console.ReadLine());
}
else {
Console.WriteLine("Korrekte Eingabe.");
Console.WriteLine("Sie beherrschen das Zahlensystem!");
}
Console.WriteLine("Die Eingabe lautet:{0}", zahl);
Console.ReadLine();
}

Listing 2.21 Mehrere Anweisungen zusammengefasst in einem Anweisungsblock

Eingebettete »if«-Statements

if-Anweisungen dürfen ineinander verschachtelt werden, d. h., dass innerhalb eines äußeren if-Statements eine oder auch mehrere weitere if-Anweisungen eingebettet werden können. Damit stehen wir aber zunächst vor einem Problem, wie im folgenden Codefragment gezeigt wird:

Console.Write("Geben Sie eine Zahl zwischen 0 und 9 ein: ");
int zahl=Convert.ToInt32(Console.ReadLine());
if(zahl >= 0 && zahl <= 9)
if(zahl <= 5)
Console.Write("Die Zahl ist 0,1,2,3,4 oder 5");
else
Console.Write("Die Zahl ist unzulässig.");

Listing 2.22 Eingebettetes »if«-Statement

Um die ganze Problematik anschaulich darzustellen, wurde auf sämtliche Tabulatoreinzüge verzichtet, denn Einzüge dienen nur der besseren Lesbarkeit des Programmcodes und haben keinen Einfluss auf die Interpretation der Ausführungsreihenfolge.

Die Frage, die aufgeworfen wird, lautet, ob else zum inneren oder zum äußeren if-Statement gehört. Wenn wir den Code betrachten, sind wir möglicherweise geneigt zu vermuten, else mit der Meldung

Die Zahl ist unzulässig.

dem äußeren if zuzuordnen, wenn eine Zahl kleiner 0 oder größer 9 eingegeben wird. Tatsächlich werden wir aber mit dieser Meldung genau dann konfrontiert, wenn eine Zahl zwischen 6 und 9 eingegeben wird, denn der Compiler interpretiert den Code wie folgt:

if(zahl >= 0 && zahl <= 9) 
{
if(zahl <= 5)
Console.Write("Die Zahl ist 0,1,2,3,4 oder 5");
else
Console.Write("Die Zahl ist unzulässig.");
}

Listing 2.23 Listing 2.22 nun mit Tabulator-Einzügen

Das war natürlich nicht unsere Absicht, denn rein logisch soll die else-Klausel der äußeren Bedingungsprüfung zugeordnet werden. Um das zu erreichen, müssen wir in unserem Programmcode das innere if-Statement als Block festlegen:

if(zahl >= 0 && zahl <= 9) {
if(zahl <= 5)
Console.Write("Die Zahl ist 0,1,2,3,4 oder 5");
}
else
Console.Write("Die Zahl ist unzulässig.");

Listing 2.24 Richtige Zuordnung des »else«-Zweigs

Unsere Erkenntnis können wir auch in einer allgemeingültigen Regel formulieren:

Eine else-Klausel wird immer an das am nächsten stehende if gebunden. Dies kann nur durch das ausdrückliche Festlegen von Anweisungsblöcken umgangen werden.

Das eben geschilderte Problem der else-Zuordnung ist unter dem Begriff dangling else bekannt, zu Deutsch »baumelndes else«. Es führt zu logischen Fehlern, die nur sehr schwer aufzuspüren sind.

Es kommt in der Praxis sehr häufig vor, dass mehrere Bedingungen der Reihe nach ausgewertet werden müssen. Unter Einbeziehung der Regel über die Zuordnung der else-Klausel könnte eine differenzierte Auswertung einer eingegebenen Zahl beispielsweise wie folgt lauten:

Console.Write("Geben Sie eine Zahl zwischen 0 und 9 ein: ");
int zahl = Convert.ToInt32(Console.ReadLine());
if(zahl == 0)
Console.WriteLine("Die Zahl ist 0");
else
if(zahl == 1)
Console.WriteLine("Die Zahl ist 1");
else
if(zahl == 2)
Console.WriteLine("Die Zahl ist 2");
else
if(zahl == 3)
Console.WriteLine("Die Zahl ist 3");
else
Console.WriteLine("Zahl > 3");

Listing 2.25 Komplexeres »if«-Statement (1)

Um jedes else eindeutig zuordnen zu können, weist dieses Codefragment entsprechende Einzüge auf, die keinen Zweifel aufkommen lassen. Das täuscht dennoch nicht darüber hinweg, dass die Lesbarkeit des Codes mit wachsender Anzahl der zu testenden Bedingungen unübersichtlich wird. Unter C# bietet es sich daher an, im Anschluss an das Schlüsselwort if sofort ein else anzugeben, wie im folgenden identischen Codefragment, das wesentlich überschaubarer wirkt und damit auch besser lesbar ist:

if(zahl == 0)
Console.WriteLine("Die Zahl ist 0");
else if(zahl == 1)
Console.WriteLine("Die Zahl ist 1");
else if(zahl == 2)
Console.WriteLine("Die Zahl ist 2");
else if(zahl == 3)
Console.WriteLine("Die Zahl ist 3");
else
Console.WriteLine("Zahl > 3");

Listing 2.26 Komplexeres »if«-Statement (2)

Bedingte Zuweisung mit dem »?:«-Operator

Manchmal sehen wir uns mit der Aufgabe konfrontiert, eine Bedingung nur auf ihren booleschen Wert hin zu prüfen und in Abhängigkeit vom Testergebnis eine Zuweisung auszuführen. Eine if-Anweisung könnte dazu wie nachfolgend gezeigt aussehen:

int x, y;
Console.Write("Geben Sie eine Zahl ein: ");
x = Convert.ToInt32(Console.ReadLine());
if(x == 0)
y = 1;
else
y = x;

Gibt der Anwender die Zahl 0 ein, wird der Variablen y der Wert 1 zugewiesen. Weicht die Eingabe von 0 ab, ist der Inhalt der Variablen x mit der Variablen y identisch.

In diesem Beispiel kann auch ein von C# angebotener, spezieller Bedingungsoperator eingesetzt werden. Sehen wir uns zunächst dessen Syntax an:

<Variable> = <Bedingung> ? <Wert1> : <Wert2>

Zuerst wird die Bedingung ausgewertet. Ist deren Ergebnis true, wird Wert1 der Variablen zugewiesen, andernfalls Wert2. Damit können wir das Beispiel von oben vollkommen äquivalent auch anders implementieren:

int x, y;
Console.Write("Geben Sie eine Zahl ein: ");
x = Convert.ToInt32(Console.ReadLine());
y = x == 0 ? 1 : x;

Im ersten Moment sieht der Code schlecht lesbar aus. Wenn wir allerdings zusätzliche Klammern setzen, wird die entsprechende Codezeile schon deutlicher:

y = (x == 0 ? 1 : x);

Zuerst wird die Bedingung

x == 0 

geprüft. Ist das Ergebnis true, wird y die Zahl 1 zugewiesen. Ist das Ergebnis false, werden die beiden Variablen gleichgesetzt.


Galileo Computing - Zum Seitenanfang

2.6.2 Das »switch«-StatementZur nächsten ÜberschriftZur vorigen Überschrift

Mit der if-Anweisung können durchaus Bedingungen auf Basis sowohl verschiedener Vergleichsoperatoren als auch verschiedener Operanden formuliert werden. In der Praxis muss jedoch häufig derselbe Operand überprüft werden. Nehmen wir beispielsweise an, eine Konsolenanwendung bietet dem Anwender eine Auswahl diverser Optionen an, mit der der weitere Ablauf des Programms gesteuert werden kann:

static void Main(string[] args) {
string message = "Treffen Sie eine Wahl:\n\n";
message += "(N) - Neues Spiel\n";
message += "(A) - Altes Spiel fortsetzen\n";
message += "(E) - Beenden\n";
Console.WriteLine(message);
Console.Write("Ihre Wahl lautet: ");
string choice = Console.ReadLine().ToUpper();
if(choice == "N") {
Console.Write("Neues Spiel...");

// Anweisungen, die ein neues Spiel starten

}
else if(choice == "A") {
Console.Write("Altes Spiel laden ...");

// Anweisungen, die einen alten Spielstand laden

}
else if(choice == "E") {
Console.Write("Spiel beenden ...");

// Anweisungen, um das Spiel zu beenden

}
else {
Console.Write("Ungültige Eingabe ...");

// weitere Anweisungen

}
Console.ReadLine();
}

Listing 2.27 Komplexe Bedingungsprüfung

Der Ablauf des Programms wird über die Eingabe »N«, »A« oder »E« festgelegt. Stellvertretend wird in unserem Fall dazu eine Konsolenausgabe angezeigt. Vor der Eingabeüberprüfung sollten wir berücksichtigen, dass der Anwender möglicherweise der geforderten Großschreibweise der Buchstaben keine Beachtung schenkt. Um diesem Umstand Rechnung zu tragen, wird die Eingabe mit

string choice = Console.ReadLine().ToUpper();

in jedem Fall in einen Großbuchstaben umgewandelt. Verantwortlich dafür ist die Methode ToUpper der Klasse String, die direkt auf dem Rückgabewert aufgerufen wird.

Alternativ zur if-Struktur könnte die Programmlogik auch mit einer switch-Anweisung realisiert werden. Im obigen Beispiel müsste der if-Programmteil dann durch den folgenden ersetzt werden:

// Beispiel: ..\Kapitel 2\SwitchSample

[...]
switch(strWahl) {
case "N":
Console.Write("Neues Spiel...");

// Anweisungen, die ein neues Spiel starten

break;
case "A":
Console.Write("Altes Spiel laden...");

// Anweisungen, die einen alten Spielstand laden

break;
case "E":
Console.Write("Spiel beenden...");

// Anweisungen, um das Spiel zu beenden

break;
default:
Console.Write("Ungültige Eingabe...");
// weitere Anweisungen

break;
}
[...]

Listing 2.28 Das »switch«-Statement

Sehen wir uns nun die allgemeine Syntax der switch-Anweisung an:

// Syntax der switch-Anweisung

switch(Ausdruck) {
case Konstante1 :

// Anweisungen

Sprunganweisung;
case Konstante2 :

// Anweisungen

Sprunganweisung;
...
[default:

// Anweisungen

Sprunganweisung;]
}

Mit der switch-Anweisung lässt sich der Programmablauf ähnlich wie mit der if-Anweisung steuern. Dabei wird überprüft, ob der hinter switch aufgeführte Ausdruck, der entweder eine Ganzzahl oder eine Zeichenfolge sein muss, mit einer der hinter case angegebenen Konstanten übereinstimmt. Nacheinander wird dabei zuerst mit der Konstante1 verglichen, danach mit der Konstante2 usw. Stimmen Ausdruck und Konstante überein, werden alle folgenden Anweisungen bis zur Sprunganweisung ausgeführt. Wird zwischen dem Ausdruck und einer der Konstanten keine Übereinstimmung festgestellt, werden die Anweisungen hinter der default-Marke ausgeführt – falls eine solche angegeben ist, denn default ist optional. Achten Sie auch darauf, hinter jeder Konstanten und hinter default einen Doppelpunkt zu setzen.

Eine Sprunganweisung ist in jedem Fall erforderlich, wenn hinter dem case-Statement eine oder mehrere Anweisungen codiert sind, ansonsten meldet der Compiler einen Syntaxfehler. Die break-Anweisung signalisiert, die Programmausführung mit der Anweisung fortzusetzen, die dem switch-Anweisungsblock folgt.

Auf die Sprunganweisung kann man verzichten, wenn mehrere case-Anweisungen direkt hintereinanderstehen. Die Folge ist dann, dass die Kette so lange durchlaufen wird, bis ein break erscheint. Daher wird im folgenden Codefragment die erste Ausgabeanweisung ausgeführt, wenn value den Wert 1, 2 oder 3 hat.

int value = ...;
switch(value) {
case 1:
case 2:
case 3:
Console.Write("value = 1, 2 oder 3");
break;
case 4:
Console.Write("value = 4");
break;
}

Neben break gibt es mit goto noch eine weitere Sprunganweisung, hinter der eine Marke angegeben werden kann, beispielsweise:

goto case "E";

Die goto-Anweisung bietet sich insbesondere an, wenn für mehrere Konstanten dieselben Anweisungsfolgen ausgeführt werden müssen, z. B.:

int value = ...;
switch(value) {
case 1:
Console.WriteLine("Im case 1-Zweig");
goto case 3;
case 2:
case 3:
Console.Write("value = 1, 2 oder 3");
break;
case 4:
Console.Write("value = 4");
break;
}

Nehmen wir an, value hätte den Wert »1«. Das Programm reagiert wie folgt: Zuerst wird der case 1-Zweig ausgeführt und danach die Steuerung des Programms an den case 3-Zweig übergeben. Zwei Konsolenausgaben sind also die Folge:

Im case 1-Zweig
value = 1, 2 oder 3

Einschränkungen der »switch«-Anweisung

In C# gibt es keine Möglichkeit, einen zusammenhängenden Konstantenbereich hinter dem case-Statement anzugeben, wie es in einigen anderen Sprachen möglich ist. Wollen Sie beispielsweise für einen Ausdruck alle Zahlen im Bereich von 0 bis 10 gleichermaßen behandeln, müssen Sie für jede einzelne eine case-Anweisung implementieren. In solchen Fällen empfiehlt es sich, anstelle der switch-Anweisung das if-Statement zu verwenden.

Die »goto«-Anweisung

Die goto-Anweisung kann nicht nur innerhalb eines switch-Blocks angegeben, sondern auch generell dazu benutzt werden, eine beliebige Marke im Code anzusteuern. Solche Sprünge werden auch als unbedingte Sprünge bezeichnet, weil sie an keine besondere Bedingung geknüpft sind. Eine Marke ist ein Bezeichner, der mit einem Doppelpunkt abgeschlossen wird. Im folgenden Beispiel wird die Marke meineMarke definiert. Trifft das Programm zur Laufzeit auf das goto-Statement, verzweigt es zu den Anweisungen, die sich hinter der benutzerdefinierten Marke befinden.

static void Main(string[] args) {
int value = 4711;
Console.WriteLine("Programmstart");
goto meineMarke;
Console.WriteLine("value = {0}",value);
meineMarke:
Console.WriteLine("Programmende");
Console.ReadLine();
}

Listing 2.29 Allgemeine Verwendung von »goto«

In diesem Listing wird es niemals zu der Ausgabe des Variableninhalts von value kommen. Das ist natürlich kein Fehler, sondern mehr eine programmiertechnische Unsauberkeit, die der Compiler sogar erkennt und im Fenster Fehlerliste als Warnhinweis anzeigt.

Neben der Möglichkeit, eine Sprunganweisung innerhalb einer switch-Anweisung zu codieren, bietet sich die goto-Anweisung auch dazu an, tief verschachtelte Schleifen zu verlassen (mehr dazu im folgenden Abschnitt). In allen anderen Fällen sollten Sie jedoch prinzipiell auf goto verzichten, denn es zeugt im Allgemeinen von einem schlechten Programmierstil.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.

>> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2012

Visual C# 2012
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo





Copyright © Rheinwerk Verlag GmbH 2013
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de