Windows-Schulaufgabe/readme.md

Fragenkatalog IT12/ AE, Schuljahr 2020/2021

Theorie:
**Windows Grundlagen:**

1. Welche Bedeutung hatte die Einführung grafischer Benutzeroberflächen für die Verbreitung von PCs?

	- Die PCs wurden damit für die Massen einfach zu benutzen und verbreiteten sich deshalb sehr gut seit es GUIs gibt

	
2. Nennen Sie drei Merkmale von Windowsprogrammen!
	
	- Oft mit .NET, C++, C# programmiert
	- Benutzen die WindowsAPI
	- Alle Benutzereingaben werden zuerst von Windows abgefangen und dann an das Programm gesendet für das es bestimmt war

	
3. Erläutern Sie den Unterschied zwischen einem Programm und einem Prozess!

	- Ein Prozess kann Bestandteil eines Programms sein, es ist die bestimmte Aufgabe, die ausgeführt wird
	- Ein Programm ist eine passive Entität, z.b. eine ausführbare Datei
	- Ein Programm ist eine Bündelung vieler Prozesse um Funktionalität zu bieten

	
4. Was versteht man unter einer „Instanz eines Programms“?

    - Jedes mal beim ausführen eines Programms, wird eine "Instanz" des Programms gestartet
    - Beispielsweise: Visual Studio 2x öffnen => 2 voneinander unabhängige Instanzen von Visual Studio laufen 

	
5. Beschreiben Sie die Aufgaben des Windows Betriebssystems, wenn eine neue Anwendung gestartet wird!
	- zuerst wird in WinMain eine Fensterklasse während der Initialisierung erstellt
	- Fensterklasse (als Structure vordefiniert) muss mit Infos zum Fenster und zu der Fensterfunktion gefüllt werden
	- Fenster wird mit CreateWindow() erzeugt und mit ShowWindow() angezeigt
	- UpdateWindow() aktualisiert die Anzeige
	
	
6. Beschreiben Sie die Aufgaben des Windows Betriebssystems, wenn eine  Anwendung geschlossen wird!
	- Benutzereingabe bekommt einen Eintrag in der Application-Queue
	- Message Loop verarbeitet die Eingabe
	- Windows wird angewiesen die Logik zur Programmbeendung auszuführen (Fenster schließen, 
      Programminstanz beenden, Speicher freigeben...)


7. Weshalb können unterschiedliche Anwendungen in Win32 nicht über Zeiger auf die gleiche Speicheradresse miteinander kommunizieren?
	
	- Weil jeder Prozess seinen eigenen „Speicherraum“ besitzt und nicht auf Speicher eines anderen Prozesses zugreifen kann (Sandbox)

	
8. Welche Vorteile bieten multithreadingfähige Systeme?

	- Abarbeitung mehrer Prozesse „gleichzeitig“
	- „schneller“ (Effektiver Einsatz der CPU)
	- Schnelle (low-latency) Kommunikation zwischen mehreren Prozessen eines Programms

	
	--> https://docs.oracle.com/cd/E19455-01/806-3461/6jck06gqj/index.html
	--> https://zone.ni.com/reference/de-XX/help/371361R-0113/lvconcepts/benefits_multi_apps/

	
9. Unterschied zwischen kooperativem und Preemptivem Multitasking?

	Kooperatives Multitasking:
		- gibt die volle CPU-Kontrolle an den auszuführenden Prozess ab und erhält sie erst
          nach erfolgreicher abarbeitung des Prozesses wieder. (Crash-Problem z.B. unter DOS)

	Preemptives Multitasking:
		- System kann jederzeit (nach Ausführung jedes CPU-Befehls) die Kontrolle 
          über die CPU entziehen

		
10. Warum können „abgestürzte“ DOS-Programme das ganze OS Lahmlegen?
	- wegen kooperativem Multitasking, das die volle Kontrolle der CPU an den Prozess abgibt

	
11. Abarbeitung einer Tastatureingabe über die Message Loop:
```
	1. User drückt Taste
	2. Eintrag des Ereignisses in die System-Queue
	3. Eintrag in die Application-Queue
	4. Message Loop verarbeitet das Ereignis
	5. Windows wird angewiesen, die Fensterfunkton aufzurufen
	6. Fensterfunktion reagiert auf die Tastatureingabe
```
	
12. Welche Aufgabe erfüllt die Fensterfunktion WinProc()?
	
	Eine Art Event-Handler des Fensters der die eingehenden Botschaften empfängt und verarbeitet
	- Z.B. die Botschaft WM_DESTROY -> Fenster schließen
	- jedes Fenster definiert seine eigene Fensterfunktion

	
13. Beschreiben Sie den grundsätzlichen Aufbau einer Fensterfuktion unter Win32?

	- Switch-Case mit verschiedenen Cases um die übergebenen Events zu verarbeiten


14. Bedeutung von Botschaften in ereignisgesteuerten Systemen

	- Eventlistener greifen die Botschaften auf und entscheiden dann 
      anhand der Botschaft den weiteren Ablauf des Programms/Prozesses


15. Nennen Sie vier Schnittstellen für Windows - Programmierer und deren spezielles Anwendungsgebiet?

	- WinInet - Windows Internet API
	- GDI - Graphics Device Interface
	- WinSock - API zum Zugriff auf Rechnernetz über Sockets
	- TAPI - Telephone API (Fax, ...)
	- COM-API - Für den Zugriff auf COM Schnittstellen 

	
16. Welche Bedeutung hat die API für den Programmierer?

	- Eine API bietet den Zugriff auf bestimmte vorgefertigte Funktionen an
	- z.b. die CoinAPI zum Abgreifen von Kryptowährungs-Daten

		
17. Erläutern Sie, welches Wissen ein Windows - Anwendungsentwickler zusätzlich zur Kenntnis der Programmiersprache benötigt

	- Windows API
	- Fensterfunktion
	- Message Loop
	- .NET
	- COM


18. Die vier Parameter der WinMain()

```
	HINSTANCE hInstance,     /* handle to current instance */
  	HINSTANCE hPrevInstance, /* handle to previous instance */
  	LPSTR lpCmdLine,         /* pointer to command line */
  	int nCmdShow             /* show state of window */
```

19. Die Windows API Fensterklasse:

	- wird zum Beschreiben/Stylen des Fensters benutzt


20. Die Inhalte der Windows Fensterklasse

```
	- style 			Style des Fensters
	- lpfnWndProc		Zeiger auf die Fensterfunktion (WndProc())
	- hInstance			Handle zur jetzigen Instanz
	- hCursor			Handle zu einer Cursor-Resource für Mouse-Moves 
	- hbrBackground		Hintergrundfarbe des Fensters
	- lpszClassName		Pointer zum Klassennamen oder einem Alias dafür
```
	
	
	
**Grundlagen des .NET Frameworks**
21. Zweck der Common Language Runtime

```
    - Die CLR übersetzt den MSIL-Code in nativen Code
    - Memory Mangement
    - Code Access security
    - Garbage Collection
    - JIT Compilation
    - Exception Handling 
```
    
22. Wozu dient Garbage Collection

    - löscht nicht mehr benötigte Objekte/Zeiger zur Laufzeit
    - befreit Speicher vom Prozess und beugt somit Memory Leaks vor
    
    
23. Weg vom Quellcode zur Ausführung in .NET

    - Umwandlung des Code in MSIL
    - Hinzufügen von Metadaten (wird in der gleichen Datei gespeichert)
    - Vor der Ausführung wird MSIL durch den JIT Compiler der CLR in nativen Code übersetzt
    
    Logische Schritte:
                Compilation                 --->            Execution
    Source-Code -> Language-Compiler -> MSIL + Metadaten -> JIT Compiler -> Native Code
  
  
24. Zweck der MSIL hinsichtlich hinsichtlich Programmiersprachen übergreifender Entwicklung von Software

    Um möglichst viele Programmiersprachen/Techniken zu unterstützen wird der Code in MSIL als Zwischen-
    sprache übersetzt. 
    
    - Da gewisse Teile des .NET Framework offen sind, ist es Drittherstellern möglich eigene Compiler
      für ihre Programmiersprache zu erstellen
    - Somit können in der Theorie alle Programmiersprachen, welche die Vorgaben von 
      MSIL (definiert in CLR) einhalten
   
   
25. Unterschied Klassenbezeichnung und Namensraum

    Klassenbezeichnung:
    
    Die Klassenbezeichnung ist der Name einer Klasse, die Klasse wird anhand der Klassenbezeichnung
    im Quellcode als Objekt instanziiert. 
    
    Namensraum:
    
    Ein Namensraum (engl. Namespace) ist ein Raum, der mehrere mehrere Klassen in ein Paket 
    zusammenfasst, um im Code Struktur und Ordnung zu gewährleisten. Diese Namensräume können 
    somit importiert werden um gewisse Teile des Codes voneinander abzugrenzen.
    
    
26. Zugriff auf eine bestimmte Klasse in einem Namensraum

    - Anhand des Schlüsselworts "using" wird ein Namespace im Code eingebunden
    - Auf die Klasse wird dann zugegriffen, wenn ein neues Objekt aus ihr instanziiert wird
    
    Beispiel:
    
    Import des Namespace: using System.IO.File;
    
    Instanziierung der Klasse als Objekt: File datei = new File();
    
    
27. Basisklasse aller .NET Klassen

    - Object
    
    
28. Zwei Arten von Datentypen unter .NET

    - Char
    - Ganzzahl (int)
    
    
29. Unterschied zwischen Reference- und Value-Types

    - Ein Value-Type ist ein Datentyp, der die Werte direkt speichert
    - Ein Reference-Type speichert nicht direkt Werte, sondern speichert die Adresse des Wertes im Arbeitsspeicher 
      z.B. Pointer oder String
      
      
30. Was ist Boxing/Unboxing

    - Beim Boxing wird ein Child-Objekt in sein Parent-Objekt umgewandelt
    - Beim Unboxing wird ein Parent-Objekt in eines seiner Child Objekt umgewandelt

    Beispiel: 
    int i = 1;
    object o = i; // boxing
    int j = (int)o; // unboxing
    
    
31. Zweck der CLS
    
    - Die CLS definiert die Regeln die von jeder Sprache im .NET Framework befolgt werden müssen
    - Die Sprachen, die CLS befolgen sind CLS Compliant
    -> CLS ermöglicht die Integration und Interoperabilität mehrerer Programmiersprachen im selben Projekt
    
    
32. Arten von Assemblies

    - Private assembly (.dll and .exe are at the same place)
    - Shared assembly(.dll and .exe are at different places)
    - Dynamic assembly (dynamically create)
    - Distributed assembly (in different parts)
    - Satellite assembly (on the network)
    
    
33. Was ist der Global Assembly Cache

    - Der GAC ist ein Verfahren des .NET Frameworks um Versionskonflikte in Programmen vorzubeugen
    - Speichert alle Assemblies mit Name, Versionsnummer und einzigartigem Token
    -> das gleiche Assembly kann mehrere Male gespeichert werden
    
    
34. Welche Informationen sind in einer Assembly gespeichert

    - Name
    - Versionsnummer
    - Token
    
    
35. Was ist Side By Side Installation

    - Mehrere Installationen des selben Assemblies
    
    
36. Was ist Probing im .NET Framework
    
    - Gibt Anwendungen das Basisverzeichnis für die Common Language Runtime an,
      die beim Laden des Assembly gesucht werden soll
    
    
**ADO.NET**
    
37. Connected <> Disconnected Modell
```
    Connected:
    
    - Beständige Verbindung zur Datenbank
    - Daten sind immer aktuell
    - DataReader versichert die beständige Verbindung
    - Mehr Netzwerkauslastung beim Server
    
    Disconnected:
    
    - Verbindung zur Datenbank nur bei Zugriff
    - mehr Auslastung beim Client, da Daten im Arbeitsspeicher 
    - Benutzen von DataSet beim Datenbankzugriff
``` 
    
38. DataProvider und DataSet aus ADO.NET
```
    DataProvider:
        - wird zum Herstellen der Verbindung mit einer Datenbank benutzt
        - führt Befehle auf der Datenbank aus
        - wird im Connected Modell benutzt um Daten aus der Datenbank zu lesen/schreiben
    
    DataSet:
        - Kommt beim Disconnected Modell zum Einsatz
        - Bildet die Datenbank ab
        - Dient als Lokaler Speicher der Datenbank auf dem Client
        - ist als Cache für die Daten zu betrachten
```     
        
39. Nachteile der OLE-DB und ODBC.NET DataProvider

        - Langsamer als native Datenbanktreiber
        - benötigt mehr CPU-Ressourcen
        - weitere Schicht zwischen Programm und Datenbank -> höhere Fehleranfälligkeit
        - Viele OLE und ODBC Treiber in .NET stammen aus der COM zeit und sind veraltet


40. Vor- und Nachteile des Connected- bzw Disconnected Modells
```
    Connected:
        Vorteile:
            - Daten sind immer aktuell
            - Einfachere Wartung
        Nachteile:
            - Mehr Netzwerkauslastung beim Server
            - Ständige Netzwerkverbindung erforderlich
            
    
    Disconnected:
        Vorteile:
            - Keine Ständige Netzwerkverbindung erforderlich
            - Weniger Netzwerkauslastung
            - Skalierbarkeit und Performance
        Nachteile:
            - Daten sind nicht aktuell
            - Daten müssen beim Client im Arbeitsspeicher abgelegt werden
            - Konkurrierende Zugriffe 
```         
    
41. Einsatzbeispiele von Disconnected- und Connected Modells:
```
    Connected:
        - Warenwirtschaftssystem
        - Büro/Office Umgebungen
        
    Disconnected:
        - Smartphone Apps
        - Außendienstmitarbeiter 
```     

42. Aufgaben des Connection Objects, Command Objects, Parameter Objects und des DataReader Objects
```
    Connection Object:
        - stellt eindeutige Verbindung/Sitzung zum Datenbankserver/Datenquelle dar
        - Verbindung mit Server
        
    Command Object:
        - eine SQL-Anweisung oder gespeicherte Prozedur die in einer Datenbank ausgeführt werden soll
        
    Parameter Object:
        - SQL-Injection Mitigation
        - damit kann man parameterisierte Abfragen erstellen, die WHERE statements obsolet machen
        
    DataReader Object:
        - stellt Verfahren zum Lesen eines Vorwärtsstreams von Zeilen in einer Datenbank bereit
```

43. Einschränkungen beim benutzen eines DataReaders:

    - ReadOnly / ForwardOnly Zugriff
    - nur für schnelles, einmaliges Lesen geeignet
    
    
44. Zusammenarbeit von DataAdapter, DataSet und DataTables im Disconnected Modell:
``` 
    - DataAdapter verfügt über SELECT command - Object welches Daten aus der DB holt
    - die Fill-Methode des DataAdapter erwartet als Parameter ein DataSet 
      und einen Namen für das zu erstellende DataTable Objects
    - erzeugung im jeweils übergebenen DataSet ein DataTable Object
    - beim Update der DB wird je nach Änderung das INSERT, UPDATE oder DELETE Command des DataAdapters aufgerufen
    - DataAdapter stellt das Bindeglied zwischen DataSet Tabelle und DB dar
    - pro DataTable eines DataSets gibt es idR. einen DataAdapter
``` 
    
45. Die 4 Command Objecte eines DataAdapters

    SELECT Command-Object:
        - Lesen von Daten aus der DB
    UPDATE Command-Object:
        - Ändern von Datensätzen
    INSERT Command-Object:
        - Einfügen neuer Datensätze
    DELETE Command-Object:
        - Löschen von Daten
        
        
46. Collections und Objekte eines DataSets

    - Tables
    - Columns
    - Constraints
    - Rows
    - Relations
    
    
***SEE SHARP PROGRAMMIERUNG***

47. Abfangen von Ereignissen unter C#
    
    - Eventhandler registrieren um auf Ereignisse zu reagieren
    - Delegate Prinzip (objektorientierte Variante von Methodenzeigern)


48. Eventhandling unter .NET am Beispiel eines Klicks auf einen Button
     
                        EVENT(click)
    Button BtnBeispiel      ->         Delegate -> Handler-Methode


49. Syntax von c# Eventhandling unter .NET

    BtnBeispiel.click() += new System.EventHandler(BtnBeispiel_Click);

    private void BtnBeispiel_Click(object sender, System.EventArgs e) {
        // do Button shit
    }  


50. Parameter einer Handler - Methode:
```
        Object sender:
            - der sender des Events (der Button in unserem Beispiel)
            - Komplettes Button Objekt inkl seiner Eigenschaften usw.

        System.EventArgs e:
            - Eigenschaften des Events
            - z.B.: Koordinaten des Klick Events f
```

51. Events eines Windows Forms:

    - Click
    - FormClosing
    - Touch 

52. Parameter der Show Methode von MessageBox
```
    - owner         | Implementierung von IWin32Window, wird Besitzer des Dialogfeldes
    - text          | Text im Fenster
    - caption       | Titel in der Fensterleiste
    - buttons       | Ja/Nein/Abbrechen etc. buttons
    - icon          | Symbol im Meldungsfenster
    - defaultButton | Standardbutton von buttons 
    - options       | Anzeige- und Zuordnungsoptionen
    - helpFilePath  | Pfad für die Hilfedatei, wenn auf "Hilfe" geklickt wird
    - keyword       | Hilfestichwort 
```

53. Einsatz der FileSystemWatcher Komponente

    - Überwachung von Dateien bzw. Ordnerstrukturen
    - Löst ein Ereignis aus bei Änderungen

    ->  Übergabe von verschiedenen Eventhandlern an den FileSystemWatcher
        Beispielsweise Changed, Created, Deleted, Renamed

54. Eigenschaften und Methoden eines Exception Objekt
```
    - Das Exception Objekt wird in try - catch Blöcken verwendet 
      und wird zum Behandeln von Ausnahmen in der Programmlogik verwendet

    Eigenschaften:
    - Stacktrace
    - Message
    
    Methoden:
    - GetBaseException  | Gibt Exception zurück bei einem von Exception abgeleitetem Objekt wie z.B. IOException
    - GetObjectData     | Setzt die SerializationInfo 
    - GetType           | Gibt den Typ der Exception zurück wie z.B. IOException
    - ToString          | Gibt die Exception Message als String zurück
``` 

55. Exception Handling Erklärung

    - Mit try - catch kann man eine Exception abfangen
    - Im try Block ist der Code, der möglicherweise eine Ausnahme auslöst und wird in catch abgefangen
    - Der catch Block wird üblicherweise zum Logging der Exception verwendet, oder die Exception wird weiterverarbeitet 
    - mit *throw new Exception()* kann man absichtlich eine Exception auslösen


56. Eigene Exception erstellen

- Klasse von Exception (oder abgeleiteter Exception Klasse) ableiten
- Konstruktor der Basisklasse für die Fehlermeldung nutzen

public class myException: System.Exception
{
	public myException():base(“Spezielle Fehlermeldung”)
	{
		...
	}
}       


57. Vorteile des Structured Exception Handling

    - Trennung von Programm und Fehlerlogik
    - genaue Fehlerbeschreibung inkl Zusatzinformationen
    - abfangen mehrerer Exceptions möglich


58. Serialisierung/Deserialisierung 
```
    Unter Serialisierung versteht man das Speichern eines Objektes auf einem beständigen Speichermedium und das Wiederherstellen des Objektes anhand seiner Daten im Programm.
    (Deserialisierung)

    -> https://stackoverflow.com/questions/3042665/what-is-the-meaning-of-serialization-in-programming-languages
```

59. Unterschiede zwischen Binary und XML Serialisierung

    XML:
    - Overhead durch XML Tags
    - lesbarer Code -> flexibel
    - nur public Elemente werden serialisiert

    Binary:
    - schnell lesbar, klare Datei
    - Binärformat ist unflexibel
    - private Elemente werden mitserialisiert


60. Erstellung einer serialisierten Klasse

   [Serializable]
   public class SerializableClass {
        public int Aersche = 15;
        public int x = 0;
        public String str = null; 
   } 


61. Umsetzung der binären Serialisierung | https://www.guru99.com/c-sharp-serialization.html

    - Serializable Klasse erstellen
    - Objekt von Serializable Klasse erstellen und den Attributen Werte zuweisen
    - BinaryFormatter erstellen
    - Beispielszenario: Stream öffnen zum Lesen der Datei die serialisiert werden soll
    - Mit BinaryFormatter.Serialize eingelesenen Stream und Serializable Objekt serialisieren
    - Stream schließen mit .Close()


62. Implementierung von XML Serialisierung
```
    MyClass obj1 = new MyBeispiel( );
    XmlSerializer s = new XmlSerializer(typeof(MyBeispiel));
    FileStream fs;

    // Serialisieren
    fs = new FileStream(@"C:\test.txt", FileMode.Create);
    s.Serialize(fs, obj1);
    fs.Close( );

    // Deserialisierung
    fs = new FileStream(@"C:\test.txt", FileMode.Open);
    MyClass obj2 = (MyClass) s.Deserialize(fs);
    fs.Close( );
```


63. DataBindingSource Objekt 

    Die BindingSource Komponente dient vielen Zwecken. 
    Das Binden von Steuerelementen in einem Formular an Daten wird vereinfacht,
    indem Währungsverwaltung, Änderungs Benachrichtigung und andere Dienste zwischen 
    Windows Forms Steuerelementen und Datenquellen bereitgestellt werden.

    DataSetTabelle --- DataBindingSource Objekt --- Steuerelement    


64. Simple und Complex Binding von Steuerelementen 

    Beim simple binding bindet man nur eine Eigenschaft an einen 
    Datensatz (z.B. die Text-Property eines Textfeldes an den Namen des Personenobjekts).
    Verwendet man das complex binding, so werden mehrere Datensätze an ein Steuerelement 
    gebunden (z.B. alle Daten mehrerer Datensätze an ein DataGrid oder alle Namen an eine ComboBox).


65. BindingNavigator Objekt 

    The BindingNavigator control represents a standard way
    to navigate and manipulate data on a form. It is a special-purpose 
    ToolStrip control for navigating and manipulating controls on the Windows Form.

    In most cases, a BindingNavigator is combined with a BindingSource control to 
    move through data records on a Windows Form. It is easy to modify the 
    BindingNavigator component if you want to add additional or alternative 
    commands for the user.

    A BindingNavigator is:

    - a VCR (video-cassette recorder) control which is used with BindingSource.
    - based on ToolStrip.
    - extensible and pluggable. 


66. Zweck einer DAO Klasse
```
DAO - Klasse    (Data Access Object):
    - Entwurfsmuster das den Zugriff auf unterschiedliche Arten von Datenquellen
    - Muster für die Gestaltung von APIs
    - Datenadapter der Applikation
    - speichert z.b. Daten in einer privaten List Collection
    - ist für die Serialisierung und Deserialisierung zuständig
    - meist werden Methoden wie SaveData() ausprogrammiert

    ->  Data Access Object Klassen kapseln die Serialisierung/ Deserialisierung von Objekten.
        Programmlogik und Datenverwaltung sind getrennt!
```


67. Aufgabe des Gerätekontextes beim Druck in C#

    - Graphics Eigenschaft der Klasse PrintPageEventArgs
    - Informiert den Drucker welche Art von Grafiken gedruckt werden
```
    private void printDocument1_PrintPage(object sender,
    System.Drawing.Printing.PrintPageEventArgs e)  
    {  
           e.Graphics.FillRectangle(Brushes.Blue,
             new Rectangle(100, 150, 250, 250));  
    } 
```

    Der Gerätekontext stellt eine einheitliche Schnittstelle zur Ausgabe von Daten auf Ausgabegeräte
    bereit („virtuelle Zeichenleinwand“). Somit wird eine hardwareunabhängige Ausgabelogik im
    Programm möglich.


68. Warum funktioniert die Druckvorschau ohne installierten Drucker nicht?

    Weil kein Druckertreiber verfügbar ist.


69. Prinzipieller Druckvorgang unter C#

    Druckvorgang:
    SIEHE "Zusammenfassung zum Adressbuch3 TA.pdf"

    1 PrintDocument Object erzeugen
    ```
    	 PrintPage Event -> Handler-Methode für Drucklogik
     		PrintPageEventArgs:
    		PageSettings Property des PrintDocuments (Seiteneinstellungen)
     		Graphics Object (Device Context)
     		HasMorePages Property (true setzen, wenn noch weitere Seiten gedruckt werden sollen…)```
    2 Seitenränder setzen
    	-> PageSattings Objekt -> Margins… (Left, Rightt, Top, Bottom) setzen.
    3 Bedruckbaren Bereich ermitteln
    	-> PrintPageEventArgs e -> MarginBounds… (Left, Rightt, Top, Bottom) nutzen.

    4 Schriftarten erstellen 
    	-> Im .NET Framework nutzt man die Font Klasse zum Erstellen von Schriften:
    		```
    		Font headerFont = new Font ("Arial",18, FontStyle.Bold);
    		```
    
    5 Schriftarten messen zur Positionsberechnung
    	-> Über das Graphics Objekt können Schriften gemessen werden.
    	    MeasureString(String text, Font font)… (Width, Height)
    
    	    ```
    	    float headerWidth = g.MeasureString(header, headerFont).Width;
    	    ```

    6 DrawString(...) des Graphics Objects
    	-> Zeichnet einen String an die angegebene Position auf den Device Context.
    		```
    		g.DrawString(text, schrift, brush, xPosition, yPosition);
    		```


70. Welche Elemente sind in PrintPageEventArgs

    Eigenschaften:
    - Cancel
    - Graphics
    - HasMorePages
    - MarginBounds
    - PageBounds
    - PageSettings

    Methoden:
    - Equals(Object)
    - GetHashCode()
    - GetType()
    - MemberwiseClone()
    - ToString()


71. Benutzerdialoge zur Druckunterstützung

    - PrintDialog
    - PrintPreviewDialog
    - PageSetupDialog


72. Einrichten von Seitenränder

    Seitenränder setzen
    	-> PageSettings Objekt -> Margins… (Left, Right, Top, Bottom) setzen


73. Vorgehensweise zum Ermitteln des bedruckbaren Bereichs

    Bedruckbaren Bereich ermitteln
    	-> PrintPageEventArgs e -> MarginBounds… (Left, Right, Top, Bottom) nutzen


74. Initialisierung einer Schriftart

    Schriftarten erstellen 
    	-> Im .NET Framework nutzt man die Font Klasse zum Erstellen von Schriften:
    		```
    		Font headerFont = new Font ("Arial",18, FontStyle.Bold);
    		```


75. Höhe und Breite eines Textes zur Textpositionierung berechnen

    - Graphics.MeasureString() verrechnet Font mit String
    ->This method returns a SizeF structure that represents 
    the size, in the units specified by the PageUnit property, 
    of the string specified by the text parameter as drawn 
    with the font parameter.


76. DrawString Funktionsweise

    Draws the specified text string at the specified location with the specified Brush and Font objects.
```
    Parameter:
    String s    | String der gezeichnet werden soll
    Font font   | Text Format des Strings
    Brush brush | Farbe und Textur des gezeichneten Text
    Single x    | x Koordinate des Text
    Single y    | Y Koordinate des Text
```


Legende: 

    - MSIL : Microsoft Intermediate Language (auch CIL - Common Intermediate Language)
    - CLR  : Common Language Runtime
    - CLS  : Common Language Specification
    - JIT  : Just in Time
    - COM  : Component Object Model
    - DAO  : Data Access Object