Hollowpoint186
/
Windows-Schulaufgabe
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Windows-Schulaufgabe/readme.md

772 lines
25 KiB
Markdown
Raw Permalink Blame History

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
Reference in New Issue View Git Blame Copy Permalink