10.1 Beispiel
Das folgende Beispiel entspricht genau dem Java-Beispiel von Kap. 6.1:
-
- Ein Schülerobjekt ("Datensatz") besteht aus 3 Attributen ("Datenfeldern") - einer Zeichenkette mit beliebig vielen Zeichen (Name des Schülers), einem
float-Wert (Notendurchschnitt) und einer Zeichenkette mit einer fixen Anzahl von Zeichen (Klasse des Schülers - die Klassenbezeichnung besteht in diesem Beispiel aus genau 7 Zeichen).
- Zu den Klassen:
- Model-Klasse Schueler
- DAO-Klassen
- DAOerfassenSchueler
- DAOschreibenSchueler
- DAOlesenSchueler
- DAOausgebenSchueler
- Zu den Anwendungsprogrammen:
- Programmklassen
- Anwendungsklasse ErfassenSchreiben
- Anwendungsklasse LesenAusgeben
10.1.1 Model-Klasse Schueler für Daten
| Klasse Schueler |
|---|
| /*
* Schueler.cs
*/
using System;
using System.Text;
namespace Beringer.oopBuch.ModelKlassen
{
/**
<summary>
Datenklasse ('Model'-Klasse) für eine Datenstruktur mit 3 Datenfeldern.
<p>
Diese Klasse dient als 'Model'-Klasse für die Demo-Programme zur
Verarbeitung von Dateien und Datenbanken.
Objekte dieser Klasse (genauer: deren Attribute) werden als Datensätze in
einer Datei bzw. als Zeilen in einer Datenbank-Tabelle gespeichert.
</p>
<p>
Jede Instanz dieser Klasse repräsentiert einen Schüler mit
<ul>
<li>Name</li>
<li>Notendurchschnitt</li>
<li>Klassenbezeichnung</li>
</ul>
</p>
<p>
Das 1. Datenfeld (Name) beinhaltet eine Zeichenkette, die beliebig lang sein
kann (d.h. die Zeichenkette hat eine variable Länge). <br />
Das 2. Datenfeld (Notendurchschnitt) beinhaltet einen float-Wert. <br />
Das 3. Datenfeld (Klassenbezeichnung) beinhaltet eine Zeichenkette mit einer
fixen Anzahl von Zeichen - in diesem Fall die Klassenbezeichnung mit immer
genau 7 Zeichen (d.h. die Zeichenkette hat eine fixe Länge).
</p>
<p>
Der Einfachheit halber ist die 'toString'-Methode nicht internationalisiert.
</p>
<p>
Seit: November 2004 <br />
Änderung: Juni 2006 (Methode 'ToString' überschreiben) <br />
Änderung: August 2014 (neue Namensbereiche 'ModelKlassen' und 'DaoKlassen')
</p>
<seealso cref="Beringer.oopBuch.DaoKlassen.DAOerfassenSchueler" />
<seealso cref="Beringer.oopBuch.DaoKlassen.DAOschreibenSchueler" />
<seealso cref="Beringer.oopBuch.DaoKlassen.DAOlesenSchueler" />
<seealso cref="Beringer.oopBuch.DaoKlassen.DAOausgebenSchueler" />
Autor: Beringer Alfred
</summary>
*/
public class Schueler
{
// ---------------------------------------------------------------------
// Klassenkonstante
// ---------------------------------------------------------------------
/**
<summary>
Zeichenkette mit einer fixen Anzahl von Leerzeichen. Sie dient zum
Auffüllen einer zu kurzen Zeichenkette mit Leerzeichen.
</summary>
<remarks>
Die Initialisierung erfolgt im Klassenkonstruktor.
</remarks>
*/
public static readonly String KLASSELEER;
// ---------------------------------------------------------------------
// Instanzattribute
// ---------------------------------------------------------------------
private String name; // Zeichenkette mit variabler Länge
private float notenschnitt;
private String klasse; // Zeichenkette mit fixer Länge
// ---------------------------------------------------------------------
// Klassenkonstruktor
// ---------------------------------------------------------------------
/**
<summary>
Klassenkonstruktor (Klassen-Initialisierungsblock).
</summary>
<remarks>
Die Werte für nicht initialisierte Klassenkonstante könnten von externen
Datenquellen geholt werden (z.B. von einer Datei, einer Datenbank oder
von einer lokalisierten Resource-Datei).
<p>
Der Einfachheit halber werden die Werte fix vorgegeben - in diesem Fall
eine Zeichenkette mit genau 7 Leerzeichen.
</p>
</remarks>
*/
static Schueler()
{
KLASSELEER = " "; // Zeichenkette mit genau 7 Leerzeichen
}
// ---------------------------------------------------------------------
// Properties
// ---------------------------------------------------------------------
/**
<summary>
Property für das erste Datenfeld (Name) - eine Zeichenkette mit
variabler Länge.
</summary>
*/
public String Name
{
get
{
return name;
}
set
{
name = value;
}
}
// ---------------------------------------------------------------------
/**
<summary>
Property für das zweite Datenfeld (Notendurchschnitt) - ein float-Feld.
</summary>
*/
public float Notenschnitt
{
get
{
return notenschnitt;
}
set
{
notenschnitt = value;
}
}
// ---------------------------------------------------------------------
/**
<summary>
Property für das dritte Datenfeld (Klassenbezeichnung) - eine
Zeichenkette fixer Länge.
</summary>
<remarks>
Die Set-Methode kontrolliert auch gleichzeitig die Länge dieses
Feldes. <br />
Eine zu kurze Zeichenkette wird mit Leerzeichen aufgefüllt, eine zu
lange wird einfach abgeschnitten..
</remarks>
*/
public String Klasse
{
get
{
return klasse;
}
set
{
// mit Leerzeichen erweitern:
klasse = value + KLASSELEER;
// kürzen auf fixe Länge:
klasse = klasse.Substring(0, KLASSELEER.Length);
}
}
// ---------------------------------------------------------------------
// Methode 'ToString'
// ---------------------------------------------------------------------
/**
<summary>
Überschreiben der Methode 'String Object.ToString()'.
</summary>
<remarks>
Liefert eine beschreibende Text-Darstellung einer Instanz der Klasse:
<pre>
Schueler[ Name = ... (Länge = ...),
Notendurchschnitt = ...,
Klassenbezeichnung = *...* ]
</pre>
<p>
Die Texte sind der Einfachheit halber Literale.
</p>
</remarks>
<seealso cref="System.Object#toString() />
<returns>
Zeichenkette, die eine Instanz beschreibt
</returns>
*/
override public String ToString()
{
StringBuilder text = new StringBuilder(this.GetType().Name);
text.Append(
"[ Name = " ).Append(name ).Append(
" (Länge = " ).Append(name.Length ).Append(
"), Notendurchschnitt = " ).Append(notenschnitt).Append(
", Klassenbezeichnung = *").Append(klasse ).Append("* ]");
return text.ToString();
}
}
}
|
10.1.2 DAO-Klassen
10.1.2.1 Klasse DAOerfassenSchueler für Datenerfassung (Standardeingabe)
| Klasse DAOerfassenSchueler |
|---|
| /*
* DAOerfassenSchueler.cs
*/
using System;
using System.IO;
using Beringer.oopBuch.ModelKlassen;
namespace Beringer.oopBuch.DaoKlassen
{
/**
<summary>
DAO-Klasse für das Erfassen von Schülerdaten von der
Standardeingabe (= Tastatur).
<p>
Die Schülerdaten werden in 'Schueler'-Objekten aufbereitet.
</p>
<p>
Methoden 'oeffnen' und 'schliessen' sind nicht notwendig, weil
Console.In (= Standardeingabe Tastatur) standardmäßig immer geöffnet ist.
</p>
<p>
Seit: November 2004 <br />
Änderung: Juni 2007 (Refaktorierung) <br />
Änderung: September 2012 (Refaktorierung - lesenEingabe) <br />
Änderung: August 2014 (neue Namensbereiche 'ModelKlassen' und 'DaoKlassen')
</p>
<seealso cref="Schueler" />
<seealso cref="DAOschreibenSchueler" />
<seealso cref="DAOlesenSchueler" />
<seealso cref="Beringer.oopBuch.EinAusgabe.ErfassenSchreiben" />
Autor: Beringer Alfred
</summary>
<remarks>
<ul>
<li>Der Einfachheit halber ist die Fehlerbearbeitung sehr primitiv!</li>
<li>'^Z' (= 'Strg' + 'Z') beendet die Eingabe (EOF) und liefert 'null' für
die Eingabe zurück.</li>
<li>Umgekehrt wird 'null' nur bei '^Z' als Eingabe zurückgegeben.</li>
<li>EOF ist also äquivalent zur Eingabe von '^Z'.</li>
<li>Achtung: 'EndOfStreamException' tritt bei der Standardeingabe nicht
ein.</li>
<li>Zusätzlich wird auch die Eingabe der Zeichenfolge "EOF" als EOF
interpretiert (gleichbedeutend mit der Eingabe von '^Z').</li>
<li>Bei einem allgemeinen Eingabefehler ('IOException') wird 'null' als
Eingabe definiert (das ist gleichbedeutend mit EOF).</li>
</ul>
</remarks>
*/
public class DAOerfassenSchueler
{
// ---------------------------------------------------------------------
// Klassenkonstante
// ---------------------------------------------------------------------
/**
<summary>
Zeichenkette, die das Ende der Tastatureingabe definiert.
</summary>
<remarks>
Dient als zusätzliche EOF-Kennzeichnung
(zusätzlich zur Eingabe von '^Z')
</remarks>
*/
private static readonly String EOF = "EOF";
// ---------------------------------------------------------------------
// Instanzattribute
// ---------------------------------------------------------------------
/// Datenobjekt für die zu erfassenden Daten
private Schueler schueler;
private bool eof = false;
// ---------------------------------------------------------------------
// Properties
// ---------------------------------------------------------------------
/**
<summary>
Get-Property für die Daten des erfassten Datensatzes.
</summary>
*/
public Schueler SchuelerDaten
{
get
{
return schueler;
}
}
// ---------------------------------------------------------------------
/**
<summary>
Get-Property für EOF (= "Ende der Datei") - nachdem alle Datensätze
erfasst wurden.
<returns>
true, wenn das Ende der Datenerfassung erreicht wurde
</returns>
*/
public bool Eof
{
get
{
return eof;
}
}
// ---------------------------------------------------------------------
// Instanzmethoden für Dateiverarbeitung
// ---------------------------------------------------------------------
/**
<summary>
Liest den nächsten Datensatz.
<p>
Die Datenfelder werden (entsprechend dem Satzaufbau) der Reihe nach über
die Tastatur eingegeben (erfasst) und - soweit möglich - geprüft.<br />
Bei einem Fehler wird kein Datensatz erstellt und die Datenerfassung
abgebrochen.
</summary>
<returns>
true, wenn die Erfassung des Datensatzes erfolgreich war
</returns>
*/
public bool Lesen()
{
String eingabe;
String name;
float notenschnitt;
String klasse;
// --------------------
// 1. Datenfeld (Name - Zeichenkette mit variabler Länge)
eingabe = lesenEingabe("Bitte Schülernamen eingeben (Ende: "
+ EOF + " oder ^Z):");
if (eof)
{
return true; // EOF ist kein Fehler
}
name = eingabe;
// --------------------
// 2. Datenfeld (Notendurchschnitt - Zahl)
eingabe = lesenEingabe("Bitte Notendurchschnitt eingeben:");
if (eof)
{
// Bei zu frühem EOF wird kein Datensatz erstellt
return true; // EOF ist kein Fehler
}
try
{
notenschnitt = float.Parse(eingabe);
}
catch (FormatException fehler)
{
Console.WriteLine("Falscher Notendurchschnitt: " + eingabe);
return false;
}
// --------------------
// 3. Datenfeld (Klassenbezeichnung - Zeichenkette fixer Länge)
eingabe = lesenEingabe("Bitte Klasse eingeben (max. "
+ Schueler.KLASSELEER.Length + " Zeichen):");
if (eof)
{
// Bei zu frühem EOF wird kein Datensatz erstellt
return true; // EOF ist kein Fehler
}
klasse = eingabe;
// --------------------
// Erfasste Daten sind korrekt -> Objekt für Datensatz instanzieren
schueler = new Schueler();
schueler.Name = name;
schueler.Notenschnitt = notenschnitt;
schueler.Klasse = klasse;
return true;
}
// ---------------------------------------------------------------------
// Private Instanzmethoden
// ---------------------------------------------------------------------
/**
<summary>
Liest eine Zeile von der Tastatur.
<p>
Eingabe: alle Zeichen bis zur 'Return'- bzw. 'Enter'-Taste.
</p>
<p>
Ende der Eingabe durch die Zeichenfolge "EOF" oder
durch '^Z' (= 'Strg' + 'Z').
</p>
</summary>
<remarks>
<ul>
<li>'EndOfStreamException' tritt bei der Standardeingabe nicht
ein!</li>
<li>'^Z' = EOF-Kennung bei Konsoleneingabe, d.h.:
EOF ist äquivalent zur Eingabe von '^Z'.</li>
<li>Eingabe von '^Z' liefert 'null' für die Eingabe.</li>
<li>EOF ist also gleichbedeutend mit 'null' für die Eingabe.</li>
</ul>
</remarks>
<param name="eingabeaufforderung">
Eingabeaufforderung
</param>
<returns>
eingegebene Daten oder 'null' (bei Eingabe von '^Z')
</returns>
*/
private String lesenEingabe(String eingabeaufforderung)
{
String eingabe;
Console.WriteLine(eingabeaufforderung);
try
{
eingabe = Console.ReadLine();
}
catch (IOException fehler)
{
eingabe = null; // Datenerfassung beenden (EOF setzen)
Console.WriteLine("Fehler beim Erfassen: " + fehler.Message);
}
// EOF prüfen:
if ( (eingabe == null) || (eingabe == EOF) )
{
eof = true;
Console.WriteLine("EOF"); // diese Ausgabe dient nur zum Testen
}
return eingabe;
}
}
}
|
10.1.2.2 Klasse DAOschreibenSchueler für Speichern von Daten in einer Datei
| Klasse DAOschreibenSchueler |
|---|
| /*
* DAOschreibenSchueler.cs
*/
using System;
using System.IO;
using System.Text;
using Beringer.oopBuch.ModelKlassen;
namespace Beringer.oopBuch.DaoKlassen
{
/**
<summary>
DAO-Klasse für das Schreiben von Schülerdaten in eine Datei
(Nichtstandarddatei).
<p>
Die Schülerdaten sind die Attribute eines 'Schueler'-Objekts.
</p>
<p>
Seit: November 2004 <br />
Änderung: Juni 2007 (Refaktorierung) <br />
Änderung: Juli 2012 (FileStream-Objekt als lokale Variable) <br />
Änderung: August 2014 (neue Namensbereiche 'ModelKlassen' und 'DaoKlassen')
</p>
<seealso cref="Schueler" />
<seealso cref="DAOerfassenSchueler" />
<seealso cref="DAOausgebenSchueler" />
<seealso cref="Beringer.oopBuch.EinAusgabe.ErfassenSchreiben" />
Autor: Beringer Alfred
</summary>
<remarks>
<ul>
<li>Der Einfachheit halber ist die Fehlerbearbeitung sehr primitiv!</li>
<li>Die Konsolausgaben bei Fehlern dienen nur zur Kontrolle und sollten
durch Erzeugung eigener Fehlerobjekte ersetzt werden.</li>
</ul>
</remarks>
*/
public class DAOschreibenSchueler
{
// ---------------------------------------------------------------------
// Instanzattribute
// ---------------------------------------------------------------------
/// Datenobjekt für die zu schreibenden Daten
private Schueler schueler;
/// Verbindungsobjekt zur Datei
private BinaryWriter ausgabesatz;
// ---------------------------------------------------------------------
// Properties
// ---------------------------------------------------------------------
/**
<summary>
Set-Property für die Daten des zu schreibenden Datensatzes.
</summary>
*/
public Schueler SchuelerDaten
{
set
{
schueler = value;
}
}
// ---------------------------------------------------------------------
// Instanzmethoden für Dateiverarbeitung
// ---------------------------------------------------------------------
/**
<summary>
Öffnet eine (Nichtstandard-)Datei zum Schreiben.
</summary>
<param name="dateiname">
Name der zu öffnenden Datei (als Zeichenkette)
</param>
<returns>
true, wenn das Öffnen der Datei erfolgreich war
</returns>
*/
public bool Oeffnen(String dateiname)
{
FileStream ausgabedatei; // entfällt bei Schachtelung
try
{
ausgabedatei = new FileStream(dateiname, FileMode.Create);
ausgabesatz = new BinaryWriter(ausgabedatei);
// Schachtelung ist möglich
// ausgabesatz = new BinaryWriter(
// new FileStream(dateiname, FileMode.Create));
}
catch (IOException fehler)
{
Console.WriteLine("Fehler beim Öffnen der Datei: "
+ fehler.Message); // nur zum Testen
return false;
}
return true;
}
// ---------------------------------------------------------------------
/**
<summary>
Schreibt einen neuen Datensatz in die Datei.
<p>
Die Datenfelder werden (entsprechend dem Satzaufbau) der Reihe nach in
die Datei geschrieben.
</p>
<p>
Satzaufbau für die Daten eines Schülers:
<ol>
<li>Länge (= Anzahl der Zeichen) des nachfolgenden
Namens (int-Zahl)</li>
<li>Name (Zeichenkette mit variabler Länge)</li>
<li>Notendurchschnitt (float-Zahl)</li>
<li>Klasse (Zeichenkette mit fixer Länge)</li>
</ol>
</p>
</summary>
<remarks>
<strong>
Die Speicherung von Zahlen erfolgt verkehrt (Little-Endian)!
</strong>
</remarks>
<returns>
true, wenn das Schreiben des Datensatzes erfolgreich war
</returns>
*/
public bool Schreiben()
{
byte [] bytes;
Encoding enc = Encoding.Default;
try
{
// Speichern der Länge des 1. Datenfeldes
ausgabesatz.Write( (int) schueler.Name.Length );
// 1. Datenfeld (Name - Zeichenkette mit variabler Länge)
bytes = enc.GetBytes(schueler.Name);
ausgabesatz.Write( bytes );
// 2. Datenfeld (Notendurchschnitt - Zahl)
ausgabesatz.Write( (float) schueler.Notenschnitt );
// 3. Datenfeld (Klassenbezeichnung - Zeichenkette fixer Länge)
bytes = enc.GetBytes(schueler.Klasse);
ausgabesatz.Write( bytes );
}
catch (IOException fehler)
{
Console.WriteLine("Fehler beim Schreiben des Datensatzes: "
+ fehler.Message); // nur zum Testen
return false;
}
return true;
}
// ---------------------------------------------------------------------
/**
<summary>
Schreibt einen neuen Datensatz in die Datei (im C#-Format).
<p>
Zeichenketten werden automatisch mit ihrer Länge in einem
C#-spezifischen Format geschrieben.
</p>
</summary>
<remarks>
<strong>
Die Speicherung von Zahlen erfolgt verkehrt (Little-Endian)!
</strong>
</remarks>
<returns>
true, wenn das Schreiben des Datensatzes erfolgreich war
</returns>
*/
public bool SchreibenCSproprietaer()
{
try
{
// 1. Datenfeld (Name - Zeichenkette mit variabler Länge)
ausgabesatz.Write( schueler.Name );
/*
schreibt zuerst die Anzahl der Zeichen
(pro 127 Zeichen 1 Byte!),
schreibt danach UTF-8-Zeichen (8 Bit)
*/
// 2. Datenfeld (Notendurchschnitt - Zahl)
ausgabesatz.Write( (float) schueler.Notenschnitt );
// 3. Datenfeld (Klassenbezeichnung - Zeichenkette fixer Länge)
ausgabesatz.Write( schueler.Klasse );
/*
schreibt zuerst die Anzahl der Zeichen
(pro 127 Zeichen 1 Byte!),
schreibt danach UTF-8-Zeichen (8 Bit)
*/
}
catch (IOException fehler)
{
Console.WriteLine("Fehler beim Schreiben des Datensatzes: "
+ fehler.Message); // nur zum Testen
return false;
}
return true;
}
// ---------------------------------------------------------------------
/**
<summary>
Schließt die Datei.
</summary>
<remarks>
Close löst keine Ausnahmen aus.
</remarks>
*/
public void Schliessen()
{
ausgabesatz.Close();
}
}
}
|
10.1.2.3 Klasse DAOlesenSchueler für Lesen von Daten aus einer Datei
| Klasse DAOlesenSchueler |
|---|
| /*
* DAOlesenSchueler.cs
*/
using System;
using System.IO;
using Beringer.oopBuch.ModelKlassen;
namespace Beringer.oopBuch.DaoKlassen
{
/**
<summary>
DAO-Klasse für das Lesen von Schülerdaten aus einer Datei
(Nichtstandarddatei).
<p>
Die Schülerdaten werden in 'Schueler'-Objekten aufbereitet.
</p>
<p>
Seit: November 2004 <br />
Änderung: Juni 2007 (Refaktorierung) <br />
Änderung: Juli 2012 (FileStream-Objekt als lokale Variable) <br />
Änderung: August 2014 (neue Namensbereiche 'ModelKlassen' und 'DaoKlassen')
</p>
<seealso cref="Schueler" />
<seealso cref="DAOausgebenSchueler" />
<seealso cref="DAOerfassenSchueler" />
<seealso cref="Beringer.oopBuch.EinAusgabe.LesenAusgeben" />
Autor: Beringer Alfred
</summary>
<remarks>
<ul>
<li>Der Einfachheit halber ist die Fehlerbearbeitung sehr primitiv!</li>
<li>Die Konsolausgaben bei Fehlern dienen nur zur Kontrolle und sollten
durch Erzeugung eigener Fehlerobjekte ersetzt werden.</li>
</ul>
</remarks>
*/
public class DAOlesenSchueler
{
// ---------------------------------------------------------------------
// Instanzattribute
// ---------------------------------------------------------------------
/// Datenobjekt für die zu lesenden Daten
private Schueler schueler;
private bool eof = false;
/// Verbindungsobjekt zur Datei
private BinaryReader eingabesatz;
// ---------------------------------------------------------------------
// Properties
// ---------------------------------------------------------------------
/**
<summary>
Get-Property für die Daten des gelesenen Datensatzes.
</summary>
*/
public Schueler SchuelerDaten
{
get
{
return schueler;
}
}
// ---------------------------------------------------------------------
/**
<summary>
Get-Property für EOF (= "Ende der Datei") - nachdem alle Datensätze
gelesen wurden.
<returns>
true, wenn das Ende der Datei erreicht wurde
</returns>
*/
public bool Eof
{
get
{
return eof;
}
}
// ---------------------------------------------------------------------
// Instanzmethoden für Dateiverarbeitung
// ---------------------------------------------------------------------
/**
<summary>
Öffnet eine (Nichtstandard-)Datei zum Lesen.
</summary>
<param name="dateiname">
Name der zu öffnenden Datei (als Zeichenkette)
</param>
<returns>
true, wenn das Öffnen der Datei erfolgreich war
</returns>
*/
public bool Oeffnen(String dateiname)
{
FileStream eingabedatei; // entfällt bei Schachtelung
try
{
eingabedatei = new FileStream(dateiname, FileMode.Open);
eingabesatz = new BinaryReader(eingabedatei);
// Schachtelung ist möglich
// eingabesatz = new BinaryReader(
// new FileStream(dateiname, FileMode.Open));
}
catch (IOException fehler)
{
Console.WriteLine("Fehler beim Öffnen der Datei: "
+ fehler.Message); // nur zum Testen
return false;
}
return true;
}
// ---------------------------------------------------------------------
/**
<summary>
Liest den nächsten Datensatz aus der Datei.
<p>
Die Datenfelder werden (entsprechend dem Satzaufbau) der Reihe nach aus
der Datei gelesen.<br />
Bei einem Fehler wird kein Datensatz erstellt.
</p>
<p>
Hinweis: Die Daten werden nicht mehr geprüft.
</p>
<p>
Satzaufbau für die Daten eines Schülers:
<ol>
<li>Länge (= Anzahl der Zeichen) des nachfolgenden
Namens (int-Zahl)</li>
<li>Name (Zeichenkette mit variabler Länge)</li>
<li>Notendurchschnitt (float-Zahl)</li>
<li>Klasse (Zeichenkette mit fixer Länge)</li>
</ol>
</p>
</summary>
<remarks>
<strong>
Zahlen sind verkehrt gespeichert (Little-Endian)!
</strong>
</remarks>
<returns>
true, wenn das Lesen des Datensatzes erfolgreich war
</returns>
*/
public bool Lesen()
{
String name;
float notenschnitt;
String klasse;
byte[] bytes;
char[] chars;
int anzahl;
try
{
// Länge des 1. Datenfeldes
anzahl = eingabesatz.ReadInt32();
// 1. Datenfeld (Name - Zeichenkette mit variabler Länge)
bytes = eingabesatz.ReadBytes(anzahl);
chars = new char[bytes.Length];
Array.Copy(bytes, chars, bytes.Length);
name = new String(chars);
// 2. Datenfeld (Notendurchschnitt - Zahl)
notenschnitt = eingabesatz.ReadSingle();
// 3. Datenfeld (Klassenbezeichnung - Zeichenkette fixer Länge)
bytes = eingabesatz.ReadBytes(Schueler.KLASSELEER.Length);
chars = new char[bytes.Length];
Array.Copy(bytes, chars, bytes.Length);
klasse = new String(chars);
}
catch (EndOfStreamException exc)
{
eof = true;
Console.WriteLine("EOF"); // diese Ausgabe dient nur zum Testen
return true; // EOF ist kein Fehler
}
catch (IOException fehler)
{
Console.WriteLine("Fehler beim Lesen des Datensatzes "
+ fehler.Message); // nur zum Testen
return false;
}
// --------------------
// Daten wurden korrekt gelesen -> Objekt für Datensatz instanzieren
schueler = new Schueler();
schueler.Name = name;
schueler.Notenschnitt = notenschnitt;
schueler.Klasse = klasse;
return true;
}
// ---------------------------------------------------------------------
/**
<summary>
Liest den nächsten Datensatz aus der Datei (im C#-Format).<br />
<p>
Die Datenfelder werden (entsprechend dem Satzaufbau) der Reihe nach aus
der Datei gelesen.<br />
Bei einem Fehler wird kein Datensatz erstellt.
</p>
<p>
Hinweis: Die Daten werden nicht mehr geprüft.
</p>
<p>
Zeichenketten sind entsprechend ihrer Länge in einem C#-spezifischen
Format gespeichert.
</p>
</summary>
<remarks>
<strong>
Zahlen sind verkehrt gespeichert (Little-Endian)!
</strong>
</remarks>
<returns>
true, wenn das Lesen des Datensatzes erfolgreich war
</returns>
*/
public bool LesenCSproprietaer()
{
String name;
float notenschnitt;
String klasse;
try
{
// 1. Datenfeld (Name - Zeichenkette mit variabler Länge)
name = eingabesatz.ReadString();
// 2. Datenfeld (Notendurchschnitt - Zahl)
notenschnitt = eingabesatz.ReadSingle();
// 3. Datenfeld (Klassenbezeichnung - Zeichenkette fixer Länge)
klasse = eingabesatz.ReadString();
}
catch (EndOfStreamException exc)
{
eof = true;
Console.WriteLine("EOF"); // diese Ausgabe dient nur zum Testen
return true; // EOF ist kein Fehler
}
catch (IOException fehler)
{
Console.WriteLine("Fehler beim Lesen des Datensatzes "
+ fehler.Message); // nur zum Testen
return false;
}
// --------------------
// Daten wurden korrekt gelesen -> Objekt für Datensatz instanzieren
schueler = new Schueler();
schueler.Name = name;
schueler.Notenschnitt = notenschnitt;
schueler.Klasse = klasse;
return true;
}
// ---------------------------------------------------------------------
/**
<summary>
Schließt die Datei.
</summary>
<remarks>
Close löst keine Ausnahmen aus.
</remarks>
*/
public void Schliessen()
{
eingabesatz.Close();
}
}
}
|
10.1.2.4 Klasse DAOausgebenSchueler für die Ausgabe von Daten (Standardausgabe)
Die Ausgabe erfolgt in ein Konsolenfenster am Bildschirm. Nach jeweils 20 Ausgabezeilen (einschließlich einer Überschrift und einer nachfolgenden Leerzeile) wird ein Seitenende angenommen und ein Vorschub auf eine neue Seite simuliert - durch Schreiben einer horizontalen Linie. (Eine tatsächliche Druckerausgabe auf Papier wird in diesem Buch nicht behandelt.)
| Klasse DAOausgebenSchueler |
|---|
| /*
* DAOausgebenSchueler.cs
*/
using System;
using Beringer.oopBuch.ModelKlassen;
namespace Beringer.oopBuch.DaoKlassen
{
/**
<summary>
DAO-Klasse für das Aufbereiten von Schülerdaten und für das Schreiben dieser
Daten auf die Standardausgabe (= Bildschirm).
<p>
Die Schülerdaten sind die Attribute eines 'Schueler'-Objekts.
</p>
<p>
Aufbereiten von Schülerdaten und formatiert ausgeben in 1 Zeile.
</p>
<p>
Methoden 'oeffnen' und 'schliessen' sind nicht notwendig, weil
'Console.Out' (= Standardausgabe Bildschirm) standardmäßig immer geöffnet
ist.
</p>
<p>
Seit: August 2009 <br />
Änderung: August 2014 (neue Namensbereiche 'ModelKlassen' und 'DaoKlassen')
</p>
<seealso cref="Schueler" />
<seealso cref="DAOlesenSchueler" />
<seealso cref="DAOerfassenSchueler" />
<seealso cref="Beringer.oopBuch.EinAusgabe.LesenAusgeben" />
Autor: Beringer Alfred
</summary>
<remarks>
<ul>
<li>Der Einfachheit halber ist die Fehlerbearbeitung sehr primitiv!</li>
<li>Der Einfachheit halber sind die auszugebenden Texte fix codiert
(d.h. keine Internationalisierung!).</li>
</ul>
</remarks>
*/
public class DAOausgebenSchueler
{
// ---------------------------------------------------------------------
// Klassenkonstante
// ---------------------------------------------------------------------
/// Maximale Anzahl Zeilen pro Seite
private static readonly int ZZMAX;
/// Simulieren "Vorschub auf neue Seite"
private static readonly String NEUESEITE;
/// Überschrift
private static readonly String UEBER;
/// Format für die Ausgabezeile
private static readonly String F_AB;
// ---------------------------------------------------------------------
// Instanzattribute
// ---------------------------------------------------------------------
/// Datenobjekt für die auszugebenden Daten
private Schueler schueler;
/// Zeilenzähler
private int zz;
// ---------------------------------------------------------------------
// Klassenkonstruktor
// ---------------------------------------------------------------------
/**
<summary>
Klassenkonstruktor (Klassen-Initialisierungsblock).
</summary>
<remarks>
Die Werte für nicht initialisierte Klassenkonstante könnten von externen
Datenquellen geholt werden (z.B. von einer Datei, einer Datenbank oder
von einer lokalisierten Resource-Datei).
<p>
Der Einfachheit halber werden die Werte jedoch fix vorgegeben.
</p>
</remarks>
*/
static DAOausgebenSchueler()
{
ZZMAX = 5; // Zum Testen mindestens 4 Datensätze erfassen
NEUESEITE = "___________________________________________________";
UEBER = "NAME NOTENDURCHSCHNITT KLASSE";
F_AB = "{0,-25} {1:f2} {2}";
}
// ---------------------------------------------------------------------
// Konstruktoren
// ---------------------------------------------------------------------
/**
<summary>
Standardkonstruktor.
</summary>
<remarks>
Am Beginn wird das Ende einer Seite simuliert, um auf einfache Art eine
Überschrift auf der ersten Seite zu erzwingen.
</remarks>
*/
public DAOausgebenSchueler()
{
zz = ZZMAX;
}
// ---------------------------------------------------------------------
// Properties
// ---------------------------------------------------------------------
/**
<summary>
Set-Property für die Daten des auszugebenden Datensatzes.
</summary>
*/
public Schueler SchuelerDaten
{
set
{
schueler = value;
}
}
// ---------------------------------------------------------------------
// Instanzmethoden für Dateiverarbeitung
// ---------------------------------------------------------------------
/**
<summary>
Schreibt 1 Zeile mit den gewünschten Schülerdaten.
<p>
Die Datenfelder werden formatiert ausgegeben.
Gegebenenfalls erfolgt ein (simulierter) Seitenvorschub und die Ausgabe
einer Überschrift.
</p>
</summary>
*/
public void SchreibenZeile()
{
if (zz >= ZZMAX)
{
Console.WriteLine(NEUESEITE);
Console.WriteLine();
Console.WriteLine(UEBER);
Console.WriteLine();
zz = 2;
}
Console.WriteLine(F_AB, schueler.Name,
schueler.Notenschnitt,
schueler.Klasse);
zz = zz + 1;
}
}
}
|
10.1.3 Anwendungsprogramme
| Programmklasse ProgrammErfassenSchreiben |
|---|
| /*
* ProgrammErfassenSchreiben.cs
*/
using System;
namespace Beringer.oopBuch.EinAusgabe
{
/**
<summary>
Programmklasse (Applikation) zum Testen der Klasse 'ErfassenSchreiben'.
<p>
Der Dateiname wird beim Aufruf als Parameter übergeben.
</p>
<p>
Seit: August 2007
</p>
<seealso cref="ErfassenSchreiben" />
Autor: Beringer Alfred
</summary>
*/
public class ProgrammErfassenSchreiben
{
/** --------------------------------------------------------------------
<summary>
Der Einstiegspunkt für die Anwendung.
</summary>
<param name="args">
Kommandozeilenparameter - Name der Ausgabedatei
</param>
*/
public static void Main(String[ ] args)
{
ErfassenSchreiben app = new ErfassenSchreiben();
app.Start(args[0]);
}
}
}
|
| Programmklasse ProgrammLesenAusgeben |
|---|
| /*
* ProgrammLesenAusgeben.cs
*/
using System;
namespace Beringer.oopBuch.EinAusgabe
{
/**
<summary>
Programmklasse (Applikation) zum Testen der Klasse 'LesenAusgeben'.
<p>
Der Dateiname wird beim Aufruf als Parameter übergeben.
</p>
<p>
Seit: August 2007
</p>
<seealso cref="LesenAusgeben" />
Autor: Beringer Alfred
</summary>
*/
public class ProgrammLesenAusgeben
{
/** --------------------------------------------------------------------
<summary>
Der Einstiegspunkt für die Anwendung.
</summary>
<param name="args">
Kommandozeilenparameter - Name der Eingabedatei
</param>
*/
public static void Main(String[] args)
{
LesenAusgeben app = new LesenAusgeben();
app.Start(args[0]);
}
}
}
|
10.1.3.1 Anwendungsklasse für Daten erfassen und speichern
| Klasse ErfassenSchreiben |
|---|
| /*
* ErfassenSchreiben.cs
*/
using System;
using Beringer.oopBuch.DaoKlassen;
namespace Beringer.oopBuch.EinAusgabe
{
/**
<summary>
Einfache Konsolenanwendung für Erfassen (Lesen) von Daten über die
Standardeingabe (= Tastatur) und Schreiben der Daten in eine Datei.
<p>
Der Dateiname wird beim Aufruf als Parameter übergeben.
</p>
<p>
Seit: November 2004 <br />
Version: August 2007 (eigene Programmklasse) <br />
Änderung: August 2014 (neuer Namensbereich 'DaoKlassen')
</p>
<seealso cref="DAOerfassenSchueler" />
<seealso cref="DAOschreibenSchueler" />
<seealso cref="LesenAusgeben" />
<seealso cref="ProgrammErfassenSchreiben" />
Autor: Beringer Alfred
</summary>
*/
public class ErfassenSchreiben
{
// ---------------------------------------------------------------------
// Instanzmethoden
// ---------------------------------------------------------------------
/**
<summary>
Öffentliche Methode zum Starten der Applikation.
</summary>
<param name="dateiname">
Name der Ausgabedatei (als Zeichenkette)
</param>
*/
public void Start(String dateiname)
{
DAOerfassenSchueler eingabedaten = new DAOerfassenSchueler();
DAOschreibenSchueler ausgabedaten = new DAOschreibenSchueler();
bool ok;
// Am Beginn der Applikation Datei öffnen
ok = ausgabedaten.Oeffnen(dateiname);
if (!ok)
{
Console.WriteLine("Fehler beim Öffnen der Datei " + dateiname);
return;
}
ok = eingabedaten.Lesen(); // Lesen Standardeingabe (Tastatur)
while (!eingabedaten.Eof)
{
if (ok)
{
// nur zum Testen:
Console.WriteLine(eingabedaten.SchuelerDaten);
// Daten übernehmen
// (d.h. Datenobjekt füllen mit den Eingabedaten)
ausgabedaten.SchuelerDaten = eingabedaten.SchuelerDaten;
ausgabedaten.Schreiben(); // Schreiben eines Datensatzes
// Schreiben eines Datensatzes im C#-Format:
// ausgabedaten.SchreibenCSproprietaer();
}
else
{
Console.WriteLine("Fehler beim Lesen");
}
ok = eingabedaten.Lesen(); // Lesen Standardeingabe (Tastatur)
}
// Am Ende der Applikation Datei schließen
ausgabedaten.Schliessen();
}
}
}
|
10.1.2.3 Anwendungsklasse für Daten lesen und ausgeben
| Klasse LesenAusgeben |
|---|
| /*
* LesenAusgeben.cs
*/
using System;
using Beringer.oopBuch.DaoKlassen;
namespace Beringer.oopBuch.EinAusgabe
{
/**
<summary>
Einfache Konsolenanwendung für Lesen von Daten aus einer Datei und
Ausgeben (Schreiben) der Daten auf die Standardausgabe (= Bildschirm).
<p>
Der Dateiname wird beim Aufruf als Parameter übergeben.
</p>
<p>
Seit: November 2004 <br />
Version: August 2007 (eigene Programmklasse) <br />
Änderung: August 2014 (neuer Namensbereich 'DaoKlassen')
</p>
<seealso cref="DAOlesenSchueler" />
<seealso cref="DAOausgebenSchueler" />
<seealso cref="ErfassenSchreiben" />
<seealso cref="ProgrammLesenAusgeben" />
Autor: Beringer Alfred
</summary>
*/
public class LesenAusgeben
{
// ---------------------------------------------------------------------
// Instanzmethoden
// ---------------------------------------------------------------------
/**
<summary>
Öffentliche Methode zum Starten der Applikation.
</summary>
<param name="dateiname">
Name der Eingabedatei (als Zeichenkette)
</param>
*/
public void Start(String dateiname)
{
DAOlesenSchueler eingabedaten = new DAOlesenSchueler();
DAOausgebenSchueler ausgabedaten = new DAOausgebenSchueler();
bool ok;
// Am Beginn der Applikation Datei öffnen
ok = eingabedaten.Oeffnen(dateiname);
if (!ok)
{
Console.WriteLine("Fehler beim Öffnen der Datei " + dateiname);
return;
}
ok = eingabedaten.Lesen(); // Lesen Datensatz
// Lesen eines Datensatzes im C#-Format:
// ok = eingabedaten.LesenCSproprietaer();
while (!eingabedaten.Eof)
{
if (ok)
{
// Daten übernehmen
// (d.h. Datenobjekt füllen mit den Eingabedaten)
ausgabedaten.SchuelerDaten = eingabedaten.SchuelerDaten;
ausgabedaten.SchreibenZeile(); // 1 Zeile schreiben
}
else
{
Console.WriteLine("Fehler beim Lesen");
}
ok = eingabedaten.Lesen(); // Lesen Datensatz
// Lesen eines Datensatzes im C#-Format:
// ok = eingabedaten.LesenCSproprietaer();
}
// Am Ende der Applikation Datei schließen
eingabedaten.Schliessen();
#if DEBUG
Console.ReadLine();
#endif
}
}
}
|
- Weiter
- zu Kapitel 12 (PL/I)
- zu Kapitel 13 (Reservierte Worte)
- Zurück
- zum Anfang dieses Kapitels
- zum Inhaltsverzeichnis
-
- zu Kapitel 1
- zu den Klassenbeispielen von Kapitel 2
- zur Parameterübergabe (Kapitel 2.7.1)
- zu Kapitel 3
- zu den Klassenbeispielen von Kapitel 4
- zu den Java-Klassenbeispielen von Kapitel 5.19.1 (Exceptions)
- zu den Java-Klassenbeispielen von Kapitel 6 (Ein-/Ausgabe von Daten)
- zu den Java-Klassenbeispielen von Kapitel 7 (GUI)
- zu Kapitel 8 (JDBC)
- zu den C#-Klassenbeispielen von Kapitel 9.19.1 (Exceptions)
- Zur
- Java-Dokumentation der Java-Beispiele