Kompaktkurs C# 6.0

 
 
dpunkt (Verlag)
  • 1. Auflage
  • |
  • erschienen am 9. März 2016
  • |
  • 330 Seiten
 
E-Book | ePUB mit Wasserzeichen-DRM | Systemvoraussetzungen
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-86491-917-6 (ISBN)
 
Das Buch beschreibt in kompakter Form den gesamten Sprachumfang von C# mit den neuen Sprachmerkmalen von C# 6.0. Es richtet sich an Leser, die bereits Erfahrung mit einer anderen Programmiersprache wie Java oder C++ haben und sich rasch in C# einarbeiten wollen, um damit produktiv zu werden.

Neben der Sprache C# behandelt das Buch auch diverse Anwendungen und Fallstudien im .NETFramework.

Themen:
- Datenstrukturen und Anweisungen
- Klassen, Structs, Interfaces und Vererbung
- Properties, Indexer und Iteratoren
- Delegates und Events
- Exception Handling
- Threads und Synchronisation
- Generische Bausteine
- Attribute und Reflection
- Assemblies als Softwarekomponenten
- Lambda-Ausdrücke
- Erweiterungsmethoden
- Anonyme Typen
- Query-Ausdrücke in LINQ
- Asynchrone Methoden und Parallelität
- Auszug aus der .NET-Klassenbibliothek
- Fallstudien mit ASP.NET und Web-Services
- Interoperabilität mit COM
- Grammatik von C#

Zahlreiche Beispiele und weit über 100 Übungsaufgaben mit Musterlösungen machen das Buch sowohl für den Einsatz im Unterricht als auch für das Selbststudium geeignet.

Die Musterlösungen sowie begleitende Materialien zu diesem Buch findet man unter http://dotnet.jku.at.
  • Deutsch
  • Heidelberg
  • |
  • Deutschland
  • 8,62 MB
978-3-86491-917-6 (9783864919176)
3864919177 (3864919177)
weitere Ausgaben werden ermittelt
Hanspeter Mössenböck ist Professor für Informatik an der Universität Linz und Leiter des Instituts für Systemsoftware. Er beschäftigt sich vor allem mit Programmiersprachen, Compilern und Systemsoftware. Als ehemaliger Mitarbeiter von Prof. Niklaus Wirth an der ETH Zürich war er Mitglied des Oberon-Teams, in dem ein Pascal-Nachfolger samt innovativem Betriebssystem entwickelt wurde. Ferner ist er Autor des Compiler-Generators Coco/R, der heute weltweit als Public-Domain-Software eingesetzt wird. Neben einem Forschungsaufenthalt bei Sun Microsystems in Kalifornien hatte er Gastprofessuren in Oxford und Budapest inne. Er ist Verfasser der Bücher »Sprechen Sie Java?« und »Objektorientierte Programmierung in Oberon-2« sowie Mitverfasser der Bücher »Die .NET-Technologie« und »Ein Compiler-Generator für Mikrocomputer«.
1 - Geleitwort [Seite 5]
2 - Vorwort [Seite 7]
3 - Inhalt [Seite 9]
4 - 1 C# und das .NET-Framework [Seite 15]
4.1 - 1.1 Ähnlichkeiten zwischen C# und Java [Seite 15]
4.2 - 1.2 Unterschiede zwischen C# und Java [Seite 17]
4.3 - 1.3 Das .NET-Framework [Seite 18]
4.4 - 1.4 Übungsaufgaben [Seite 24]
5 - 2 Erste Schritte [Seite 25]
5.1 - 2.1 Hello World [Seite 25]
5.2 - 2.2 Gliederung von Programmen [Seite 26]
5.3 - 2.3 Symbole [Seite 27]
5.4 - 2.4 Übungsaufgaben [Seite 30]
6 - 3 Typen [Seite 31]
6.1 - 3.1 Einfache Typen [Seite 32]
6.2 - 3.2 Enumerationen [Seite 33]
6.3 - 3.3 Arrays [Seite 34]
6.4 - 3.4 Strings [Seite 37]
6.5 - 3.5 Structs [Seite 38]
6.6 - 3.6 Klassen [Seite 39]
6.7 - 3.7 object [Seite 40]
6.8 - 3.8 Boxing und Unboxing [Seite 41]
6.9 - 3.9 Übungsaufgaben [Seite 42]
7 - 4 Ausdrücke [Seite 45]
7.1 - 4.1 Arithmetische Ausdrücke [Seite 45]
7.2 - 4.2 Vergleichsausdrücke [Seite 46]
7.3 - 4.3 Boolesche Ausdrücke [Seite 47]
7.4 - 4.4 Bit-Ausdrücke [Seite 47]
7.5 - 4.5 Shift-Ausdrücke [Seite 47]
7.6 - 4.6 Überlaufprüfung [Seite 48]
7.7 - 4.7 typeof [Seite 48]
7.8 - 4.8 sizeof [Seite 49]
7.9 - 4.9 Übungsaufgaben [Seite 49]
8 - 5 Deklarationen [Seite 51]
8.1 - 5.1 Deklarationen in Namensräumen [Seite 52]
8.2 - 5.2 Deklarationen in Klassen, Structs und Interfaces [Seite 53]
8.3 - 5.3 Deklarationen in Enumerationstypen [Seite 54]
8.4 - 5.4 Deklarationen in Blöcken [Seite 54]
8.5 - 5.5 Übungsaufgaben [Seite 56]
9 - 6 Anweisungen [Seite 57]
9.1 - 6.1 Leeranweisung [Seite 57]
9.2 - 6.2 Zuweisung [Seite 57]
9.3 - 6.3 Methodenaufruf [Seite 58]
9.4 - 6.4 if-Anweisung [Seite 58]
9.5 - 6.5 switch-Anweisung [Seite 59]
9.6 - 6.6 while-Anweisung [Seite 60]
9.7 - 6.7 do-while-Anweisung [Seite 60]
9.8 - 6.8 for-Anweisung [Seite 60]
9.9 - 6.9 foreach-Anweisung [Seite 61]
9.10 - 6.10 break- und continue-Anweisungen [Seite 62]
9.11 - 6.11 goto-Anweisung [Seite 62]
9.12 - 6.12 return-Anweisung [Seite 63]
9.13 - 6.13 Übungsaufgaben [Seite 64]
10 - 7 Ein-/Ausgabe [Seite 65]
10.1 - 7.1 Ausgabe auf den Bildschirm [Seite 65]
10.2 - 7.2 Formatierte Ausgabe [Seite 65]
10.3 - 7.3 Ausgabe auf eine Datei [Seite 68]
10.4 - 7.4 Eingabe von der Tastatur [Seite 69]
10.5 - 7.5 Eingabe von einer Datei [Seite 69]
10.6 - 7.6 Lesen der Kommandozeilenparameter [Seite 70]
10.7 - 7.7 Übungsaufgaben [Seite 71]
11 - 8 Klassen und Structs [Seite 73]
11.1 - 8.1 Sichtbarkeitsattribute [Seite 74]
11.2 - 8.2 Felder [Seite 76]
11.3 - 8.3 Methoden [Seite 77]
11.4 - 8.4 Konstruktoren [Seite 84]
11.5 - 8.5 Destruktoren [Seite 86]
11.6 - 8.6 Properties [Seite 87]
11.7 - 8.7 Indexer [Seite 90]
11.8 - 8.8 Überladene Operatoren [Seite 92]
11.9 - 8.9 Kurzform für Methoden [Seite 95]
11.10 - 8.10 Geschachtelte Typen [Seite 96]
11.11 - 8.11 Partielle Typen [Seite 97]
11.12 - 8.12 Partielle Methoden [Seite 98]
11.13 - 8.13 Statische Klassen [Seite 99]
11.14 - 8.14 Unterschiede zu Java [Seite 99]
11.15 - 8.15 Übungsaufgaben [Seite 100]
12 - 9 Vererbung [Seite 103]
12.1 - 9.1 Deklaration von Unterklassen [Seite 103]
12.2 - 9.2 Kompatibilität zwischen Klassen [Seite 105]
12.3 - 9.3 Überschreiben und Verdecken von Elementen [Seite 106]
12.4 - 9.4 Dynamische Bindung [Seite 109]
12.5 - 9.5 Konstruktoren in Ober- und Unterklasse [Seite 112]
12.6 - 9.6 Abstrakte Klassen [Seite 113]
12.7 - 9.7 Versiegelte Klassen [Seite 114]
12.8 - 9.8 Die Klasse Object [Seite 115]
12.9 - 9.9 Übungsaufgaben [Seite 117]
13 - 10 Interfaces [Seite 119]
13.1 - 10.1 Deklaration und Verwendung von Interfaces [Seite 119]
13.2 - 10.2 Operationen auf Interfaces [Seite 121]
13.3 - 10.3 Erweiterung von Interfaces [Seite 122]
13.4 - 10.4 Namenskonflikte [Seite 123]
13.5 - 10.5 Interface IDisposable [Seite 124]
13.6 - 10.6 Übungsaufgaben [Seite 125]
14 - 11 Delegates und Events [Seite 127]
14.1 - 11.1 Einfache Delegates [Seite 127]
14.2 - 11.2 Multicast-Delegates [Seite 128]
14.3 - 11.3 Erzeugen von Delegate-Werten [Seite 128]
14.4 - 11.4 Ereignisse (Events) [Seite 130]
14.5 - 11.5 Anonyme Methoden [Seite 131]
14.6 - 11.6 Übungsaufgaben [Seite 133]
15 - 12 Ausnahmen [Seite 135]
15.1 - 12.1 try-Anweisung [Seite 135]
15.2 - 12.2 Ausnahmeklassen [Seite 137]
15.3 - 12.3 Auslösen von Ausnahmen [Seite 138]
15.4 - 12.4 Ausnahmen in aufgerufenen Methoden [Seite 140]
15.5 - 12.5 Ausnahmen in Multicast-Delegates [Seite 140]
15.6 - 12.6 Übungsaufgaben [Seite 141]
16 - 13 Namensräume und Assemblies [Seite 143]
16.1 - 13.1 Namensräume [Seite 143]
16.2 - 13.2 Assemblies [Seite 146]
16.2.1 - 13.2.1 Assemblies und Module [Seite 146]
16.2.2 - 13.2.2 Versionierung von Assemblies [Seite 147]
16.2.3 - 13.2.3 Assemblies versus Namensräume [Seite 150]
16.3 - 13.3 Übungsaufgaben [Seite 151]
17 - 14 Generische Bausteine [Seite 153]
17.1 - 14.1 Generische Typen [Seite 154]
17.2 - 14.2 Constraints [Seite 155]
17.3 - 14.3 Vererbung bei generischen Typen [Seite 156]
17.4 - 14.4 Generische Methoden [Seite 158]
17.5 - 14.5 Generische Delegates [Seite 159]
17.6 - 14.6 Nullwerte [Seite 161]
17.7 - 14.7 Ko- und Kontravarianz bei generischen Typen [Seite 161]
17.8 - 14.8 Was geschieht hinter den Kulissen? [Seite 165]
17.9 - 14.9 Unterschiede zu Java [Seite 165]
17.10 - 14.10 Übungsaufgaben [Seite 166]
18 - 15 Threads [Seite 169]
18.1 - 15.1 Die Klasse Thread [Seite 169]
18.2 - 15.2 Zustände eines Threads [Seite 172]
18.3 - 15.3 Abbrechen eines Threads [Seite 173]
18.4 - 15.4 Thread-Synchronisation [Seite 174]
18.5 - 15.5 Übungsaufgaben [Seite 179]
19 - 16 Iteratoren [Seite 181]
19.1 - 16.1 Allgemeine Iteratoren [Seite 181]
19.2 - 16.2 Spezifische Iteratoren [Seite 183]
19.3 - 16.3 Übungsaufgaben [Seite 186]
20 - 17 Attribute [Seite 187]
20.1 - 17.1 Schreibweise von Attributen [Seite 187]
20.2 - 17.2 Parameter von Attributen [Seite 188]
20.3 - 17.3 Attribute für spezifische Programmelemente [Seite 189]
20.4 - 17.4 Attribut Serializable [Seite 190]
20.5 - 17.5 Attribut Conditional [Seite 192]
20.6 - 17.6 Attribut DllImport [Seite 193]
20.7 - 17.7 Deklaration eigener Attribute [Seite 194]
20.8 - 17.8 Übungsaufgaben [Seite 195]
21 - 18 Dokumentationskommentare [Seite 197]
21.1 - 18.1 XML-Elemente [Seite 197]
21.2 - 18.2 Erzeugte XML-Datei [Seite 199]
21.3 - 18.3 Übungsaufgaben [Seite 200]
22 - 19 Auszug aus der .NET-Klassenbibliothek [Seite 201]
22.1 - 19.1 Hilfsklassen [Seite 202]
22.2 - 19.2 Collections [Seite 205]
22.3 - 19.3 Ein-/Ausgabe [Seite 214]
22.4 - 19.4 Reflection [Seite 220]
22.5 - 19.5 Übungsaufgaben [Seite 224]
23 - 20 LINQ [Seite 227]
23.1 - 20.1 Motivation [Seite 227]
23.2 - 20.2 Lambda-Ausdrücke [Seite 228]
23.3 - 20.3 Erweiterungsmethoden [Seite 232]
23.4 - 20.4 Objektinitialisierer [Seite 234]
23.5 - 20.5 Anonyme Typen [Seite 236]
23.6 - 20.6 Query-Ausdrücke [Seite 238]
23.7 - 20.7 LINQ und XML [Seite 245]
23.8 - 20.8 Übungsaufgaben [Seite 247]
24 - 21 Asynchrone Methoden und Parallelität [Seite 249]
24.1 - 21.1 Asynchronität [Seite 249]
24.2 - 21.2 Tasks [Seite 250]
24.3 - 21.3 Asynchrone Methoden [Seite 252]
24.4 - 21.4 Explizite Parallelität [Seite 258]
24.5 - 21.5 Übungsaufgaben [Seite 260]
25 - 22 Interoperabilität mit COM [Seite 261]
25.1 - 22.1 COM-Objekte von .NET aus ansprechen [Seite 262]
25.2 - 22.2 .NET-Assemblies von COM aus ansprechen [Seite 265]
25.3 - 22.3 Übungsaufgaben [Seite 267]
26 - 23 Dynamisch getypte Variablen [Seite 269]
26.1 - 23.1 Typ dynamic [Seite 269]
26.2 - 23.2 Operationen auf dynamic-Variablen [Seite 271]
27 - 24 Diverses [Seite 273]
27.1 - 24.1 Null-fähige Werttypen [Seite 273]
27.2 - 24.2 Bedingter Zugriff über Referenzen [Seite 276]
27.3 - 24.3 using static [Seite 277]
28 - 25 Fallstudien [Seite 279]
28.1 - 25.1 Anwendungen mit grafischer Benutzeroberfläche [Seite 279]
28.2 - 25.2 Ein Web-Service für Börsenkurse [Seite 288]
28.3 - 25.3 Dynamische Webseiten mit ASP.NET [Seite 293]
28.4 - 25.4 Übungsaufgaben [Seite 299]
29 - A Anhang [Seite 301]
29.1 - A.1 Compileroptionen [Seite 301]
29.2 - A.2 Werkzeuge unter .NET [Seite 304]
29.2.1 - A.2.1 ildasm [Seite 304]
29.2.2 - A.2.2 Globaler Assembly-Cache [Seite 305]
29.3 - A.3 Grammatik von C# [Seite 308]
29.4 - A.4 Unicode und ASCII [Seite 315]
30 - Literatur [Seite 317]
31 - Index [Seite 319]
32 - www.dpunkt.de [Seite 0]

1 C# und das .NET-Framework


C# (sprich: see sharp) ist eine von Microsoft entwickelte Programmiersprache für die .NET-Plattform ([HTWG10]). Obwohl man .NET-Programme in ganz verschiedenen Sprachen schreiben kann (unter anderem in C++, Visual Basic, Java, Cobol oder Eiffel), hat Microsoft mit C# eine neue »Haussprache« geschaffen, um damit die Mächtigkeit von .NET voll auszureizen. C# ist eine objektorientierte Sprache, die sich äußerlich stark an Java anlehnt, aber in ihrer Mächtigkeit deutlich darüber hinausgeht. Sie besitzt all jene Eigenschaften, die man benötigt, um Programme nach dem neuesten Stand der Softwaretechnik zu entwickeln.

C# ist keine revolutionäre Sprache. Sie ist vielmehr eine Kombination aus Java, C++ und Visual Basic, wobei man versucht hat, von jeder Sprache die bewährten Eigenschaften zu übernehmen und die komplexen Eigenschaften zu vermeiden. C# wurde von einem kleinen Team unter der Leitung von Anders Hejlsberg entworfen. Hejlsberg ist ein erfahrener Sprachdesigner. Er war bei Borland Chefentwickler von Delphi und ist dafür bekannt, seine Sprachen auf die Bedürfnisse von Praktikern zuzuschneiden.

In diesem Kapitel geben wir einen Überblick über die wichtigsten Eigenschaften von C#. Aufgrund der Ähnlichkeiten zu Java stellen wir dabei die Merkmale von C# denen von Java gegenüber, wobei wir davon ausgehen, dass der Leser bereits programmieren kann und eine Sprache wie Java oder C++ beherrscht. Da man als C#-Entwickler nicht umhinkommt, auch die Grundkonzepte von .NET zu kennen, gehen wir am Ende dieses Kapitels auch kurz auf .NET ein.

1.1 Ähnlichkeiten zwischen C# und Java


Auf den ersten Blick sehen C#-Programme wie Java-Programme aus. Jeder Java-Programmierer sollte daher in der Lage sein, C#-Programme zu lesen. Neben der fast identischen Syntax wurden folgende Konzepte aus Java übernommen:

  • Objektorientierung

    C# ist wie Java eine objektorientierte Sprache mit einfacher Vererbung. Klassen können nur von einer einzigen Klasse erben, aber mehrere Schnittstellen (Interfaces) implementieren.

  • Typsicherheit

    C# ist eine typsichere Sprache. Viele Programmierfehler, die durch inkompatible Datentypen in Anweisungen und Ausdrücken entstehen, werden bereits vom Compiler abgefangen. Zeigerarithmetik oder ungeprüfte Typumwandlungen wie in C++ sind in Anwendungsprogrammen verboten. Zur Laufzeit wird sichergestellt, dass Array-Indizes im erlaubten Bereich liegen, dass Objekte nicht durch uninitialisierte Zeiger referenziert werden und dass Typumwandlungen zu einem definierten Ergebnis führen.

  • Garbage Collection

    Dynamisch erzeugte Objekte werden vom Programmierer nie selbst freigegeben, sondern von einem Garbage Collector automatisch eingesammelt, sobald sie nicht mehr referenziert werden. Das beseitigt viele unangenehme Fehler, die z.B. in C++-Programmen auftreten können.

  • Namensräume

    Was in Java Pakete sind, nennt man in C# Namensräume. Ein Namensraum ist eine Sammlung von Deklarationen und ermöglicht es, gleiche Namen in unterschiedlichem Kontext zu verwenden.

  • Threads

    C# unterstützt leichtgewichtige parallele Prozesse in Form von Threads. Es gibt wie in Java Mechanismen zur Synchronisation und Kommunikation zwischen Prozessen.

  • Generizität

    Sowohl Java als auch C# kennen generische Typen und Methoden. Damit kann man Bausteine herstellen, die mit anderen Typen parametrisierbar sind (z.B. Listen mit beliebigem Elementtyp).

  • Reflection

    Wie in Java kann man auch in C# zur Laufzeit auf Typinformationen eines Programms zugreifen, Klassen dynamisch zu einem Programm hinzuladen, ja sogar Objektprogramme zur Laufzeit zusammenstellen.

  • Attribute

    Der Programmierer kann beliebige Informationen an Klassen, Methoden oder Felder hängen und sie zur Laufzeit mittels Reflection abfragen. In Java heißt dieser Mechanismus Annotationen.

  • Bibliotheken

    Viele Typen der C#-Bibliothek sind denen der Java-Bibliothek nachempfunden. So gibt es vertraute Typen wie Object, String, ICollection oder Stream, meist sogar mit den gleichen Methoden wie in Java.

Auch aus C++ wurden einige Dinge übernommen, zum Beispiel das Überladen von Operatoren, die Zeigerarithmetik in systemnahen Klassen (die als unsafe gekennzeichnet sein müssen) sowie einige syntaktische Details z.B. im Zusammenhang mit Vererbung. Aus Visual Basic stammt beispielsweise die foreach-Schleife.

1.2 Unterschiede zwischen C# und Java


Neben diesen Ähnlichkeiten weist C# aber wie alle .NET-Sprachen auch einige Merkmale auf, die in Java fehlen:

  • Referenzparameter

    Parameter können nicht nur durch call by value übergeben werden, wie das in Java üblich ist, sondern auch durch call by reference. Dadurch sind nicht nur Eingangs-, sondern auch Ausgangs- und Übergangsparameter realisierbar.

  • Objekte am Keller

    Während in Java alle Objekte am Heap liegen, kann man in C# Objekte auch am Methodenaufrufkeller anlegen. Diese Objekte sind leichtgewichtig und belasten den Garbage Collector nicht.

  • Blockmatrizen

    Für numerische Anwendungen ist das Java-Speichermodell mehrdimensionaler Arrays zu ineffizient. C# lässt dem Programmierer die Wahl, mehrdimensionale Arrays entweder wie in Java anzulegen oder als kompakte Blockmatrizen, wie das in C, Fortran oder Pascal üblich ist.

  • Einheitliches Typsystem

    Im Gegensatz zu Java sind in C# alle Datentypen (auch int oder char) vom Typ object abgeleitet und erben die dort deklarierten Methoden.

  • goto-Anweisung

    Die viel geschmähte goto-Anweisung wurde in C# wieder eingeführt, allerdings mit Einschränkungen, so dass man mit ihr kaum Missbrauch treiben kann.

  • Versionierung

    Bibliotheken werden bei der Übersetzung mit einer Versionsnummer versehen. So kann eine Bibliothek gleichzeitig in verschiedenen Versionen vorhanden sein. Jede Applikation verwendet immer diejenige Version der Bibliothek, mit der sie übersetzt und getestet wurde.

Schließlich hat C# noch eine ganze Reihe von Eigenschaften, die zwar die Mächtigkeit der Sprache nicht erhöhen, aber bequem zu benutzen sind. Sie fallen unter die Kategorie »syntactic sugar«, d.h., man kann mit ihnen Dinge tun, die man auch in anderen Sprachen realisieren könnte, nur dass es in C# eben einfacher und eleganter geht. Dazu gehören:

  • Properties und Events

    Diese Eigenschaften dienen der Komponententechnologie. Properties sind spezielle Felder eines Objekts. Greift man auf sie zu, werden automatisch get- und set-Methoden aufgerufen. Mit Events kann man Ereignisse definieren, die von Komponenten ausgelöst und von anderen behandelt werden.

  • Indexer

    Ein Index-Operator wie bei Array-Zugriffen kann durch get- und set-Methoden selbst definiert werden.

  • Delegates

    Delegates sind im Wesentlichen das, was man in Pascal Prozedurvariablen und in C Function Pointers nennt. Sie sind allerdings etwas mächtiger. Zum Beispiel kann man mehrere Prozeduren in einer einzigen Delegate-Variablen speichern.

  • foreach-Schleife

    Damit kann man bequem über Arrays, Listen oder Mengen iterieren.

  • Iteratoren

    Man kann spezielle Iterator-Methoden schreiben, die eine Folge von Werten liefern, welche dann mit foreach durchlaufen werden kann.

  • Lambda-Ausdrücke

    Lambda-Ausdrücke sind parametrisierte Codestücke, die man an Variablen zuweisen und später aufrufen kann. Sie sind eine Kurzform für namenlose Methoden.

  • Query-Ausdrücke

    Sie erlauben SQL-ähnliche Abfragen auf Hauptspeicherdaten wie Arrays oder Listen.

1.3 Das .NET-Framework


Wer in C# programmiert, kommt früher oder später nicht umhin, sich auch in die Grundlagen des .NET-Frameworks einzuarbeiten, für das C# entwickelt wurde. Das .NET-Framework ist eine Schicht, die auf Windows (und später vielleicht auch einmal auf anderen Betriebssystemen) aufsetzt (siehe Abb. 1-1) und vor allem zwei Dinge hinzufügt:

  • Eine Laufzeitumgebung (die Common Language Runtime), die automatische Speicherbereinigung (garbage collection), Sicherheitsmechanismen, Versionierung und vor allem Interoperabilität zwischen verschiedenen Programmiersprachen bietet.

  • Eine objektorientierte Klassenbibliothek mit umfangreichen Funktionen für grafische Benutzeroberflächen (Windows Forms), Web-Oberflächen (ASP.NET), Datenbankanschluss (ADO.NET), Web-Services, Collection-Klassen, Threads, Reflection und vieles mehr. Sie ersetzt in vielen Fällen das bisherige Windows-API und geht weit über dieses hinaus.

Abb. 1-1 Grobarchitektur des .NET-Frameworks

Obwohl .NET von Microsoft entwickelt wurde, basiert es auf offenen Standards. Der ECMA-Standard 335 definiert zum Beispiel die Common Language Runtime und Teile der Klassenbibliothek, der ECMA-Standard 334 beschreibt die Sprache C#, und auch in Web-Services werden...

Dateiformat: EPUB
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie eine Lese-Software, die das Dateiformat EPUB verarbeiten kann: z.B. Adobe Digital Editions oder FBReader - beide kostenlos (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nicht Kindle)

Das Dateiformat EPUB ist sehr gut für Romane und Sachbücher geeignet - also für "fließenden" Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

23,99 €
inkl. 19% MwSt.
Download / Einzel-Lizenz
ePUB mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
Hinweis: Die Auswahl des von Ihnen gewünschten Dateiformats und des Kopierschutzes erfolgt erst im System des E-Book Anbieters
E-Book bestellen

Unsere Web-Seiten verwenden Cookies. Mit der Nutzung dieser Web-Seiten erklären Sie sich damit einverstanden. Mehr Informationen finden Sie in unserem Datenschutzhinweis. Ok