Richtig einsteigen: Programmieren lernen mit Visual C# 2013

Richtig einsteigen: Programmieren lernen mit Visual C# 2013

by Dirk Louis
Released December 2013
Publisher(s): Microsoft Press Deutschland
ISBN: 97833866452213

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Lernen Sie programmieren mit Visual C# 2013.

Table of contents

  1. A Note Regarding Supplemental Files
  2. I. Erste Schritte
    1. 1. Einleitung
      1. 1.1 Aufbau dieses Buches
      2. 1.2 Konventionen in diesem Buch
      3. 1.3 Software und Beispielsammlung
        1. Arbeiten mit der Beispielsammlung
          1. Beispielprojekte öffnen und ausführen
        2. Einstellungen aus Beispielprojekten ablesen
          1. Welche Projektvorlage wurde verwendet?
          2. Wie wurde eine Komponente konfiguriert?
          3. Mit welchem Ereignisbehandlungscode wurde eine Komponente verbunden?
          4. Wie sieht der Code des Formulars aus?
          5. Wie ist das Layout eines Formulars aufgebaut?
    2. 2. Das erste Programm – das Projektgerüst
      1. 2.1 Von der Idee zum Programm
        1. Fallbeispiel: Eine verbesserte Fotoanzeige
        2. Programmierung erfolgt in Zyklen
      2. 2.2 Willkommen bei Visual Studio
      3. 2.3 Ein neues Projekt beginnen
        1. Schritt 1: Ein Projekt anlegen
        2. Schritt 2: Das Projekt speichern
        3. Schritt 3: Das Programm erstellen und ausführen
      4. 2.4 Quelltext – der erste Kontakt!
        1. Program.cs
        2. class Program
        3. void Main()
        4. Application.Run()
        5. Studie 1: Fenstertitel und Fehlerkorrektur
        6. Studie 2: Syntaxfehler
        7. Form1.cs und Form1.Designer.cs
          1. public partial class Form1 : Form
          2. public Form1()
        8. namespace und using
      5. 2.5 Übungen zu diesem Kapitel
        1. Übung 2.1
        2. Übung 2.2
        3. Übung 2.3
    3. 3. Das erste Programm – die Benutzeroberfläche
      1. 3.1 Die Designer-Umgebung
        1. Der Windows Forms-Designer
        2. Der Werkzeugkasten
        3. Das Eigenschaftenfenster
        4. Das Menü Format
      2. 3.2 Komponenten aufnehmen
      3. 3.3 Komponenten konfigurieren
      4. 3.4 Ereignisse bearbeiten
      5. 3.5 Eigenschaften zur Laufzeit ändern
      6. 3.6 Die Eigenschaft Name
      7. 3.7 Was tut sich auf der Festplatte?
      8. 3.8 Anwendungen außerhalb von Visual Studio aufrufen
        1. Aufruf über den Windows Explorer
        2. Aufruf über Start/Ausführen bzw. Start/<Suche starten>
        3. Aufruf über Start- oder Desktop-Link
      9. 3.9 Übungen zu diesem Kapitel
        1. Übung 3.1
        2. Übung 3.2
  3. II. Grundkurs C#
    1. 4. Grundkurs: Datenverarbeitung
      1. 4.1 Datentypen und Variablen
        1. Der »Wert« der Variablen
        2. Variablen bei der Definition initialisieren
        3. Werte von Variablen abfragen
          1. Studie 3: Bauen Sie das Programm Demo_Variablen nach und führen Sie es aus
        4. Die elementaren Datentypen
        5. Strings
          1. String-Konstanten
          2. Escape-Sequenzen
          3. Zeilenumbrüche und Aneinanderreihung von Strings
          4. String-Variablen
          5. Strings vergleichen
          6. Weitere Methoden der String-Klasse
        6. Typumwandlung
          1. Umwandlung von Zahlen in Strings
          2. Umwandlung von Strings in Zahlen – Teil 1
          3. Umwandlung von Strings in Zahlen – Teil 2
          4. Umwandlung von Gleitkommazahlen in Ganzzahlen
        7. C# für Pedanten
      2. 4.2 Variablen kontra Konstanten
      3. 4.3 Operatoren
        1. Die verschiedenen Operatoren
        2. Verwendung der trigonometrische Methoden
        3. Division
      4. 4.4 Objekte und Klassen
        1. C# für Philosophen
        2. Objekte und alte Datentypen
        3. Klassen definieren
          1. Felder von Klassen
          2. Methoden von Klassen
          3. Konstruktoren von Klassen
        4. Mit Klassen programmieren
          1. Instanzen werden mit new gebildet
          2. Variablen von Klassentypen sind Referenzen
          3. Zugriff auf Instanzen
          4. Vorsicht, Objektvariable ohne Verweis!
      5. 4.5 Arrays
        1. Arrays definieren
        2. Auf Array-Elemente zugreifen
        3. Arrays initialisieren
      6. 4.6 Vordefinierte Klassen und Namespaces
      7. 4.7 Übungen zu diesem Kapitel
        1. Übung 4.1
        2. Übung 4.2
        3. Übung 4.3
        4. Übung 4.4
        5. Übung 4.5
        6. Übung 4.6
        7. Übung 4.7
        8. Übung 4.8
        9. Übung 4.9
        10. Übung 4.10
        11. Übung 4.11
        12. Übung 4.12
        13. Übung: 4.13
        14. Übung: 4.14
    2. 5. Grundkurs: Modularisierung und Programmsteuerung
      1. 5.1 Modularisierung durch Klassen und Methoden
        1. Teilprobleme in Methoden implementieren I
        2. Teilprobleme in Methoden implementieren II
        3. Teilprobleme in Klassen implementieren
          1. Klassen als Methodensammlungen
        4. Eigene Bibliotheken
          1. Bibliotheken anlegen
          2. Bibliotheken verwenden
      2. 5.2 Kontrollstrukturen
        1. Bedingungen: if-else
        2. Bedingungen und boolesche Ausdrücke
        3. Praxisbeispiel: Rechenmeister
          1. Der Operator und das Problem der Benutzereingaben
          2. Die Berechnung
        4. Mehrfachbedingungen: switch
        5. Die Schleifen for, while und foreach
          1. Die for-Schleife
          2. Die while-Schleife
          3. Die foreach-Schleife
        6. Schleifenvariablen und Abbruchbedingungen
        7. Schleifen und Arrays
        8. Zauber mit Schleifen, Zahlen und Kaninchen
        9. Änderung des Programmflusses
      3. 5.3 Fehlerbehandlung durch Ausnahmen
        1. Ausnahmen abfangen
        2. Mehrere catch-Blöcke
        3. Die Ausnahme-Parameter
        4. Eigene Ausnahmen
      4. 5.4 Selbstkontrolle
        1. Wie geht man vor, wenn man vor einem Problem steht, für das man keine direkte Lösung weiß?
        2. Die Übungsaufgabe
        3. Tipps und Lösung
      5. 5.5 Übungen zu diesem Kapitel
        1. Übung 5.1
        2. Übung 5.2
        3. Übung 5.3
        4. Übung 5.4
        5. Übung 5.5
        6. Übung 5.6
        7. Übung 5.7
        8. Übung 5.8
        9. Übung 5.9
        10. Übung 5.10
        11. Übung 5.11
    3. 6. Rundgang durch Visual Studio für Fortgeschrittene
      1. 6.1 Tour-Start
      2. 6.2 Die Projektverwaltung
        1. Ein Projekt anlegen
        2. Projekte speichern, schließen und öffnen
        3. Mit Projekten arbeiten
        4. Projekteigenschaften festlegen
          1. Seite Anwendung
          2. Seite Erstellen
          3. Seite Debuggen
        5. Projektmappen
          1. Projekte und Projektmappen
          2. Projektmappen mit mehreren Projekten
          3. Verweise
          4. Abhängigkeiten
      3. 6.3 Der Editor
        1. Syntax-Hervorhebung
        2. Automatische Einrückung
        3. IntelliSense
        4. Zusammenarbeit mit Compiler und Debugger
        5. Weitere Funktionen
      4. 6.4 Der Windows Forms-Designer
        1. Komponenten hinzufügen und löschen
        2. Komponenten auswählen
        3. Komponenten dimensionieren
        4. Komponenten ausrichten
        5. Komponenten kopieren
        6. Das Eigenschaftenfenster
      5. 6.5 Der Compiler
      6. 6.6 Der Debugger
        1. Fehler und Debugging
        2. Ablauf von Debug-Sitzungen
        3. Vorbereitungen zum Debuggen
        4. Programm in Debugger laden und starten
        5. Programm anhalten
          1. Haltepunkte setzen
          2. Haltepunkte löschen
        6. Programm schrittweise ausführen
        7. Die Debug-Fenster
          1. Das Fenster Lokal
          2. Das Fenster Überwachen
          3. QuickInfo
          4. Das Fenster Aufrufliste
      7. 6.7 Hilfe
        1. Die Online-Hilfe
          1. Die C#-Referenz und die Bibliotheksdokumentation
        2. Die lokale Hilfe
      8. 6.8 Konfiguration
        1. Mit letztem Projekt statt mit Startseite starten
        2. Anzahl der zuletzt geöffneten Projekte
        3. Einzüge im Editor
        4. Zeilennummern
      9. 6.9 Übungen zu diesem Kapitel
        1. Übung 6.1
  4. III. Aufbaukurs C#
    1. 7. Eigene Klassen
      1. 7.1 Statische und nicht-statische Klassenelemente
        1. Nicht-statische Elemente
          1. Nicht-statische Felder (Instanzvariablen)
          2. Nicht-statische Methoden
          3. this
        2. Statische Elemente
          1. Statische Felder (Klassenvariablen)
          2. Statische Methoden
      2. 7.2 Methoden
        1. Definition von Methoden
        2. Rückgabewerte von Methoden – return
        3. Parameterübergabe
          1. ref-Parameter
          2. Arrays als Parameter
        4. Überladung
      3. 7.3 Zugriff und Zugriffbeschränkung
        1. Gültigkeit
        2. Lokale Variablen und Verdeckung
        3. Die Zugriffsmodifizierer
        4. Studie 4: Zugreifbarkeit auf Formularebene
      4. 7.4 Eigenschaften
        1. Nur-Lesen- und Nur-Schreiben-Eigenschaften
        2. Eigenschaften ohne private Felder
      5. 7.5 Übungen zu diesem Kapitel
        1. Übung 7.1
        2. Übung 7.2
        3. Übung 7.3
    2. 8. Klassen und Vererbung
      1. 8.1 Vererbung
        1. Der grundlegende Mechanismus
          1. Wann ist Vererbung gerechtfertigt?
          2. Vererbung kontra Einbettung
          3. Geerbte Elemente bilden Unterobjekte
        2. Der Zugriffsmodifizierer protected
        3. Aufruf des Basisklassenkonstruktors
        4. Verbergen und Überschreiben geerbter Methoden
          1. Geerbte Elemente verbergen
          2. Geerbte Methoden überschreiben
      2. 8.2 Polymorphie
        1. Rückverwandlung
        2. Vorteile der Polymorphie
      3. 8.3 Object
        1. ToString() überschreiben
        2. Boxing
      4. 8.4 Schnittstellen (Interfaces)
        1. Schnittstellen definieren
        2. Schnittstellen implementieren
      5. 8.5 Übungen zu diesem Kapitel
        1. Übung 8.1
        2. Übung 8.2
        3. Übung 8.3
        4. Übung 8.4
    3. 9. Nützliche .NET-Klassen
      1. 9.1 Textausgaben formatieren
        1. Einfache Ausgabe via Text
        2. Formatierte Zahlenausgabe
          1. Gesamtbreite und Genauigkeit
          2. Eigene Formate
        3. Ausgabe mittels Platzhaltern
      2. 9.2 Datum und Uhrzeit
        1. Datum und Uhrzeit ermitteln
          1. Eigene DateTime-Objekt erzeugen
          2. Datums- und Uhrzeitangaben vom Anwender abfragen
        2. Datums- und Zeitangaben manipulieren
        3. Datums- und Zeitangaben ausgeben
        4. Zeitspannen messen
      3. 9.3 Zufallszahlen
      4. 9.4 Die Auflistungsklassen
        1. Historisches
        2. Die Auflistungen im Vergleich
        3. ArrayList
          1. Nach bestimmten Elementen suchen
          2. Auf Elemente zugreifen
        4. List<T>
          1. Von ArrayList zu List&lt;T&gt;
        5. Dictionary<TKey, TValue>
        6. Stack<T>
      5. 9.5 Dateien
        1. In Dateien schreiben
        2. Lesen aus Dateien
          1. Dateien zeilenweise einlesen
          2. Codierung
        3. Informationen über Dateien und Verzeichnisse
          1. Die Klasse File
          2. Prüfen, ob eine zu öffnende Datei existiert
          3. Die Klasse Directory
          4. Verzeichnisse anlegen
          5. Verzeichnisse auflisten
      6. 9.6 Studie 5: Reaktionstester
        1. Ausgangspunkt
        2. Periodisch wiederkehrende Aufgaben mit Timer
        3. Einen Zähler verwenden
          1. Wie gut ist die switch-Lösung?
        4. Was hat das Redesign gebracht?
        5. Doppelbelegung der Schaltfläche
        6. Den Reaktionstest starten
        7. Den Reaktionstest auswerten
        8. Verbesserungen
          1. Thread.Sleep() eliminieren
          2. Doppelklicks verhindern
          3. Kleine Laufzeitverbesserung
          4. Variationen
      7. 9.7 Übungen zu diesem Kapitel
        1. Übung 9.1
        2. Übung 9.2
        3. Übung 9.3
        4. Übung 9.4
        5. Übung 9.5
  5. IV. Windows Forms-Anwendungen
    1. 10. Formulare und Steuerelemente
      1. 10.1 Zusammengefasst: Was sind Windows-Anwendungen?
        1. Das Windowing-System
        2. Die grafische Oberfläche
        3. Die Ereignisbehandlung
      2. 10.2 Fenster, Hauptfenster und Formulare
        1. Nachgefragt, was ist eigentlich ein Fenster?
          1. Was ist ein Hauptfenster?
          2. Wie werden Fenster angezeigt?
        2. Das Fenster konfigurieren
          1. Größe und Position
          2. Unveränderliche Größe
          3. Titelleiste
          4. Rahmen und Funktionalität
          5. Farben und Hintergrundbilder
        3. Anwendungssymbol
          1. Symbole erstellen
          2. Symbole verwenden
      3. 10.3 Steuerelemente
        1. Programmieren mit Steuerelementen
        2. Beschriftungsfelder
        3. Schaltflächen
          1. Klassische Schaltflächen
          2. Schaltflächen deaktivieren
        4. Kontrollkästchen
        5. Optionsfelder und GroupBox
          1. Gruppierung
        6. Eingabefelder
          1. Mehrzeilige Eingabefelder
          2. Passworteingaben
        7. Listenfelder
          1. Elemente hinzufügen
          2. Ausgewählte Elemente abfragen
          3. Elemente löschen
        8. Kombinationsfelder
        9. Weitere Steuerelemente und weitere Informationen
      4. 10.4 Layout mit Containern
        1. Neutrale Container (Panel)
        2. Layout-Container
        3. Funktionale Container
      5. 10.5 Ereignisbehandlung
        1. Ereignisbehandlung einrichten
        2. Welches Ereignis soll ich abfangen und bearbeiten?
      6. 10.6 Übungen zu diesem Kapitel
        1. Übung 10.1
        2. Übung 10.2
    2. 11. Menüs und Symbolleisten
      1. 11.1 Menüleisten
        1. Aufbau einer Menüleiste
        2. Ereignisbehandlung für Menüelemente
          1. Dateien neu anlegen, öffnen, speichern
          2. Anwendung beenden
          3. Zwischenablage unterstützen
        3. Menüelemente konfigurieren
      2. 11.2 Symbolleisten
        1. Bilder für Symbolleistenschalter
        2. Ereignisbehandlung
        3. QuickInfo
      3. 11.3 Kontextmenüs
      4. 11.4 Übungen zu diesem Kapitel
        1. Übung 11.1
    3. 12. Dialogfelder
      1. 12.1 Was sind Dialogfelder?
      2. 12.2 Dialogfelder aufbauen und konfigurieren
        1. Das Formular anlegen
        2. Formulare in Dialogfelder verwandeln
      3. 12.3 Dialogfelder erzeugen und anzeigen
        1. Modale und nicht-modale Dialoge
      4. 12.4 Einstellungen aus Dialogfeldern abfragen
      5. 12.5 Standarddialoge
        1. Meldungsfenster
        2. Dateien öffnen
      6. 12.6 Übungen zu diesem Kapitel
        1. Übung 12.1
    4. 13. Grafik
      1. 13.1 Das Arbeitsmaterial des Künstlers
        1. Text zeichnen
        2. Rekonstruktion von Zeichnungen – Das Paint-Ereignis
        3. Zeichenmethoden – Graphics
        4. Pinsel, Stift und Schrift
          1. Stift (Pen)
          2. Pinsel (Brush)
          3. Schrift (Font)
      2. 13.2 In Panels zeichnen
        1. Die Benutzeroberfläche
        2. Die Auswahl der Funktionen
        3. Die Funktionen zeichnen
      3. 13.3 Freihandlinien
        1. Konzept für Freihandlinien
        2. Eigene Graphics-Objekte erzeugen
          1. CreateGraphics()
          2. Graphics-Objekte mit Dispose() entsorgen
          3. Keine automatische Rekonstruktion
          4. Der Code
      4. 13.4 Bilder anzeigen
        1. Bilder aus Bilddateien laden
        2. Bilder anzeigen
        3. Studie 6: Ein Bildbetrachter
      5. 13.5 Übungen zu diesem Kapitel
        1. Übung 13.1
        2. Übung 13.2
        3. Übung 13.3
        4. Übung 13.4
        5. Übung 13.5
  6. V. Datenbanken und Bildschirmschoner
    1. 14. Datenbankzugriff (ADO.NET)
      1. 14.1 Relationale Datenbanken und SQL
        1. Aufbau einer Tabelle
      2. 14.2 SQL-Grundlagen
        1. Tabellen anlegen – CREATE TABLE
        2. Datensätze einfügen – INSERT
        3. Datensätze ändern – UPDATE
        4. Datensätze löschen – DELETE
        5. Datensätze suchen – SELECT
      3. 14.3 Zugriff auf eine SQL Server-Datenbank
        1. Die Datenbank
          1. Schritt 1: Den SQL-Client starten
          2. Schritt 2: Eine neue Datenbank anlegen
          3. Schritt 3: Eine Tabelle anlegen
          4. Schritt 4: Datensätze eintragen
          5. Schritt 5: Verbindung trennen
        2. Die Anwendung
          1. Die Benutzeroberfläche
          2. Vorbereitung und allgemeine Vorgehensweise
          3. Verbindung zur Datenbank herstellen
          4. Daten abfragen
          5. Daten lesen und aufbereiten
          6. Navigation durch die Datensätze
      4. 14.4 Zugriff auf eine Microsoft Access-Datenbank
        1. Projekt kopieren
        2. Datenbank erstellen
        3. Quelltext für Datenbankzugriff anpassen
          1. Klassennamen ändern
          2. Verbindungsstring ändern
          3. Neu erstellen
      5. 14.5 Datensätze bearbeiten
        1. Das Ausgangs-Projekt
        2. Das Zusammenspiel der Datenbankklassen
        3. Der Code
      6. 14.6 Übungen zu diesem Kapitel
        1. Übung 14.1
    2. 15. Bildschirmschoner
      1. 15.1 Was unterscheidet Bildschirmschoner von anderen Windows-Anwendungen?
      2. 15.2 Ein Ticker als Bildschirmschoner
        1. Konfiguration des Fensters
          1. Bildschirmschoner testen
        2. Beenden bei Mausklick
        3. Aufrufargumente auswerten
        4. Die Animation
          1. Der Zeitgeber
          2. Animieren mit einem Zeitgeber
          3. Flackern unterbinden
        5. Den Bildschirmschoner einrichten
      3. 15.3 Übungen zu diesem Kapitel
        1. Übung 15.1
        2. Übung 15.2
    3. 16. Wie geht es weiter?
  7. VI. Anhänge
    1. A. Lösungen zu den Übungen
      1. Übung 2.1
      2. Übung 2.2
      3. Übung 2.3
      4. Übung 3.1
      5. Übung 3.2
      6. Übung 4.1
      7. Übung 4.2
      8. Übung 4.3
      9. Übung 4.4
      10. Übung 4.5
      11. Übung 4.6
      12. Übung 4.7
      13. Übung 4.8
      14. Übung 4.9
      15. Übung 4.10
      16. Übung 4.11
      17. Übung 4.12
      18. Übung: 4.13
      19. Übung: 4.14
      20. Übung 5.1
      21. Übung 5.2
      22. Übung 5.3
      23. Übung 5.4
      24. Übung 5.5
      25. Übung 5.6
      26. Übung 5.7
      27. Übung 5.8
      28. Übung 5.9
      29. Übung 5.10
      30. Übung 5.11
      31. Übung 6.1
      32. Übung 7.1
      33. Übung 7.2
      34. Übung 7.3
      35. Übung 8.1
      36. Übung 8.2
      37. Übung 8.3
      38. Übung 8.4
      39. Übung 9.1
      40. Übung 9.2
      41. Übung 9.3
      42. Übung 9.4
      43. Übung 9.5
      44. Übung 10.1
      45. Übung 10.2
      46. Übung 11.1
      47. Übung 12.1
      48. Übung 13.1
      49. Übung 13.2
      50. Übung 13.3
      51. Übung 13.4
      52. Übung 13.5
      53. Übung 14.1
      54. Übung 15.1
      55. Übung 15.2
    2. B. Installation der Visual Studio Express Edition
      1. B.1 Systemvoraussetzungen
      2. B.2 Download
      3. B.3 Installation
      4. B.4 Starten
    3. C. Weitergabe von Programmen
      1. C.1 Vorarbeiten
      2. C.2 Der Setup-Assistent
      3. C.3 Woran hakt es?
        1. Das .NET Framework
        2. Bilder
        3. Externe Dateien
        4. DLLs
    4. D. .NET Framework und C#-Compiler
      1. D.1 Das .NET Framework
      2. D.2 Die Komponenten des .NET Frameworks
      3. D.3 Bezugsquellen
      4. D.4 Geschichte und Motivation
        1. .NET und Java
          1. .NET, COM und das babylonische Sprachengewirr
          2. .NET, das Internet und alles andere
    5. E. Konsolenanwendungen
      1. E.1 Das Grundgerüst
        1. Konsolenanwendungen in Visual Studio
        2. Write(), WriteLine()
        3. Lesen von Tastatur
        4. Konsolenanwendungen außerhalb von Visual Studio ausführen
  8. Stichwortverzeichnis
  9. Copyright

Product information

  • Title: Richtig einsteigen: Programmieren lernen mit Visual C# 2013
  • Author(s): Dirk Louis
  • Release date: December 2013
  • Publisher(s): Microsoft Press Deutschland
  • ISBN: 97833866452213