www.der-wirtschaftsingenieur.de » C# http://www.der-wirtschaftsingenieur.de Portal für Wirtschaftsingenieure Tue, 31 Jan 2012 13:34:49 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 .NET-Code, unfreiwilliger Open Source? http://www.der-wirtschaftsingenieur.de/index.php/net-code-unfreiwilliger-open-source/ http://www.der-wirtschaftsingenieur.de/index.php/net-code-unfreiwilliger-open-source/#comments Sat, 01 Nov 2008 12:26:36 +0000 admin http://firedaxx.com/projectioneering/?p=94 Es ist schon ein wenig gewöhnungsbedürftig, der Gedanke, dass der gesamte Code eines mühevoll entwickeltes Programms quasi von jedem Nutzer eingesehen werden kann. “Open Source” ist an dieser Stelle sicherlich zu viel gesagt, denn nur weil der Quellcode (mit Hilfsmitteln) einsehbar ist, heißt dies nicht, dass dieser auch für andere Zwecke als die Programmausführung genutzt werden darf.

Aber ein einsehbarer Quellcode erleichtert die Spionage, Piraterie und sonstigen Missbrauch enorm.
Aber warum kann der Quellcode eines .Net Programms so einfach eingesehen werden? Das Problem existiert bei .NET Sprachen (und auch Java) zum einen, weil die Quellcode in eine Zwischensprache (IL, Intermediate Language) übersetzt wird und zum anderen an Reflections.

Die Zwischensprache ist bereits für den Menschen lesbarer als Assemblercode und lässt sich verhältnismäßig einfach wieder zurück übersetzen, denn die Zwischensprache spricht anders als Assemblercode nicht einzelne Register an (kann sie auch nicht, denn sie ist eine hardware-universelle Sprache), sondern liest sich auf einem viel höheren Abstraktionslevel.

Mit welchen Programmen kann man an den .NET Quellcode nur über eine ausführbare Datei gelangen?
Dafür gibt es das kostenlose Programm Reflector for .NET sowie das kostenpflichtige Programm Remotesoft .NET Explorer.

Auch ohne diese Programme ist es Fakt, dass der Quellcode von in .NET Sprachen geschriebenen Programmen mit genügend Aufwand zu dekompilieren ist. Wie kann sich ein Unternehmer davor schützen? Es ist ein ganz natürliches Interesse eines Unternehmers, dass ein teuer entwickeltes Programm mit neuesten Algorithmen nicht durch Quellcodespionage einfach nachgebaut werden kann.
Ein wichtiger Aspekt ist hierbei allerdings die Usability, welche nicht (oder nur im unwesentlichen Umfang) unter dem Schutz vor Spionage leiden sollte. Der Programmbenutzer sollte von den Schutzmaßnahmen nichts merken und sich wegen diesen nicht einschränken müssen.

Das einfachste Verfahren zur Erschwerung des wirksamen Quellcodeverständnisses ist die Obfuskation. Hierfür gibt es bestimmte Programme. Die Entwickler können aber auch selbst eine gewisse (und vielleicht sehr effektive) Verwirrung hervorrufen, indem sie Methoden gezielt falsch benennen und falsche Fährten legen. Dies sollte aber erst nach kompletter Fertigstellung geschehen und erfordert eine gute Eigendokumentation.

Die weitergehende Variante ist die Kompilierung von .NET Quellcode in Maschinencode. Dies ist beispielsweise mit dem Salamander .NET Native Compiler der Firma Remotesoft möglich und hat den positiven Nebeneffekt, dass kein .NET Framework zur Ausführungszeit benötigt (aber dafür auf die Plattformunabhängigkeit verzichtet) wird.
So ist der Quellcode dann etwa vergleichbar gut geschützt, wie z. B. in C geschriebener und kompilierter Code.

Weiterführende Webseiten:
http://www.remotesoft.com – Remotesoft
http://www.red-gate.com/products/reflector/ – .NET Reflector (kostenlos)

]]> http://www.der-wirtschaftsingenieur.de/index.php/net-code-unfreiwilliger-open-source/feed/ 0 Reflections in C# http://www.der-wirtschaftsingenieur.de/index.php/reflections-in-c-sharp/ http://www.der-wirtschaftsingenieur.de/index.php/reflections-in-c-sharp/#comments Sat, 11 Oct 2008 19:43:02 +0000 admin http://www.der-wirtschaftsingenieur.de/?p=167 Es kann zur Laufzeit eines Programms notwendig sein, dass das Programm sich selbst analysieren und ggf. verändern kann. In C# kann dies mir der Funktionalität von Reflections erreicht werden.

Reflection „reflektiert" zur Laufzeit aufrufbare Assemblys, Module und Typen und bietet so dynamischen Zugriff auf Objekte, Methoden und Metadaten, welche erst zur Laufzeit bekannt werden.
Eine Programmiersprache, welche diese Möglichkeit zur "Reflektion" der eigenen Programminhalte hat, kann ihre eigene Struktur selbst zur Laufzeit analysieren und auf sie Einfluss nehmen.

Reflection als Methode zum dynamischen Aufruf von Klassen, Methoden, Variablen, Ressourcen usw. ist abgesehen von C# (und anderen .NET-Programmiersprachen) auch in Java bekannt und in noch einigen weiteren Programmiersprachen in ähnlicher Form verbreitet. Aber auch die Reflection-Funktionalität von Java und C# sind nicht absolut identisch. Während Java auf Klassenebene „reflektiert" und generell auch Klassen als Informationsempfänger verwendet, kommt C# nicht über Klassen, sondern über Assemblies an die gewünschten Informationen heran.

Grundsätzlich sollte der Einsatz von Reflections vermieden werden, denn der dynamische Aufruf ist wesentlich langsamer, als der direkte Aufruf. Insgesamt ist der Einsatz dieser Funktionalität mit übermäßigen Performance-Einbußen verbunden. Mit der Anwendung von Reflections erkauft sich der Programmierer Flexibilität zur Laufzeit, nimmt damit aber Leistungseinbußen in Kauf.
Nur wenn ein dynamischer Aufruf unbedingt notwendig ist, gibt es für Reflections grundsätzlich keine Alternative. Beispiele für Anwendungsgebiete sind Schnittstellen für Plugins, der Debugger und auch die automatische Textvervollständigung in Entwicklungsumgebungen (z. B. Microsofts IntelliSense).

Um Reflections in C# nutzen zu können, sind Klassen aus dem Namespace System.Reflection notwendig, welcher daher in das Projekt eingebunden werden muss.

PLAIN TEXT
C#:
  1. using System.Reflection;

Auch die Klasse System.Type ist für Reflections von ausschlaggebender Bedeutung. Sie steht im Namespace System zur Verfügung.

System.Type repräsentiert u.a. Klassen, Interfaces und Wertetypen.

Um das Objekt eines Typen nach System.Type zu erhalten, dienen der typeof() Operator bzw. zur Laufzeit eines Objekts die Instanzmethode [object].GetType() als Typlieferanten. (Siehe hierzu typeof() vs getType())

Das Type-Objekt stellt wichtige Informationen und Zugriffsmöglichkeiten, u.a. auf Methoden, Konstruktoren und Variablen bereit.

Von Interesse könnte für den Programmier beispielweise sein, wie die eigene Assembly heißt. Der Name der Assembly wird mit der Methode myAssemblyInfo() ausgegeben.

PLAIN TEXT
C#:
  1. private void myAssemblyInfo()
  2. {
  3.    Assembly myAssembly = System.Reflection.Assembly.GetExecutingAssembly();
  4.  
  5.    Console.Writeline(myAssembly.GetName().FullName);
  6. }

Diese Methode kann in der neuen Klasse (z.B. im Konstruktor) aufgerufen werden.

PLAIN TEXT
C#:
  1. myAssemblyInfo();

Ausgabe:

ReflectionExample, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null

Ausgegeben wurden alle Informationen über den Namen dieser Assembly (Fullname). Die Assembly selbst heißt ReflectionExample (dies ist der Name des Projekts).

Reflections in C# an Hand eines Beispiels:

Die nachfolgende Klasse Calculator im Namensraum Reflection_Test soll mit Reflections analysiert werden.

Die Klasse Calculator hat eine Konstante und Eigenschaft (Property) sowie einige Methoden.

PLAIN TEXT
C#:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.IO;
  5. using System.Windows.Forms;
  6. using System.Reflection;
  7.  
  8. namespace Reflection_Test
  9. {
  10.    class Calculator
  11.    {
  12.       private const float pi = 3.14f;
  13.  
  14.       public float PI
  15.       {
  16.          get
  17.          {
  18.             return pi;
  19.          }
  20.       }
  21.  
  22.       public Calculator()
  23.       {
  24.       }
  25.  
  26.       public int DivideAndWrite(double d)
  27.       {
  28.          double result = d / 2;
  29.  
  30.          return (int)result;
  31.       }
  32.  
  33.       public void WriteText(string text)
  34.       {
  35.          Console.WriteLine(text);
  36.       }
  37.  
  38.       private void WriteText2(string text) // invisible, not able to reflect
  39.       {
  40.          Console.WriteLine(text);
  41.       }
  42.  
  43.       public void doThis()
  44.       {
  45.          // do anything possible...
  46.  
  47.          Console.WriteLine("We do this!");
  48.       }
  49.  
  50.       public void doThat()
  51.       {
  52.          // do anything (else) possible
  53.  
  54.          Console.WriteLine("We do that!");
  55.       }
  56.    }
  57. }

Dazu wird eine neue Klasse aufgestellt, in welche je nach Bedarf nachfolgenden Methoden implementiert und aufgerufen werden können.

Wissenswert ist auch, welche Datei (und in welchem Pfad sie liegt) zu der Klasse Reflection_Class gehört.
Die Methode myAssemblyFiles() gibt alle Dateien namentlich aus, welche zu dieser Klasse gehören.

PLAIN TEXT
C#:
  1. private void myAssemblyFiles()
  2. {
  3.    Assembly asm = Assembly.GetAssembly(typeof(Reflection_Class));
  4.  
  5.    FileStream[] files = asm.GetFiles();
  6.  
  7.    foreach (FileStream file in files)
  8.    {
  9.       Console.WriteLine("Filename: " + file.Name);
  10.    }
  11. }

Nach Aufruf der Methode myAssembyFiles() in der neuen Klasse (z.B. im Konstruktor)...

PLAIN TEXT
C#:
  1. myAssemblyFiles();

erfolgt folgende Ausgabe:

Filename: C:\Dokument...daten\Temporary Projects\Reflection\bin\Debug\Reflection.exe

Die Ausgabe zeigt den Namen der ausführbaren Datei mit absoluter Pfadangabe.

Eine weitere Methode namens getMetaDataByTypeName() bekommt einen Typennamen (Name einer Klasse) als Parameter und gibt die Namen aller Methoden aus.

PLAIN TEXT
C#:
  1. private void getMetaDataByTypename(string typeName)
  2. {
  3.    Type ctype = Type.GetType(typeName);
  4.  
  5.    MethodInfo[] mis = ctype.GetMethods();
  6.  
  7.    foreach (MethodInfo mi in mis)
  8.    {
  9.       Console.WriteLine("Methodename: '" + mi.Name.ToString() + "'");
  10.    }
  11. }

Diese Methode kann wie folgt aufgerufen werden:

PLAIN TEXT
C#:
  1. this.getMetaDataByTypeName("Reflection_Test.Calculator");

Ausgabe:

Methodename: 'get_PI'
Methodename: 'DivideAndWrite'
Methodename: 'WriteText'
Methodename: 'doThis'
Methodename: 'doThat'
Methodename: 'GetType'
Methodename: 'ToString'
Methodename: 'Equals'
Methodename: 'GetHashCode'

Zu beachten ist hier, dass die private Methode writeText2() nicht gefunden wurde. Die get()-Methode der Eigenschaft PI wurde mitgezählt.

Eine andere Methode reflectProperty() greift auf den Wert der Eigenschaft PI zu und zeigt diesen Wert an.
Dabei wird vor dem Zugriff mit der Eigenschaft CanRead der Instanz vom Typ PropertyInfo auch geprüft, ob die Eigenschaft PI Lesezugriff bietet.

Die Methode reflectProperty() verlang hierzu die Klasse als Parameter, welche die Eigenschaft PI hat.

PLAIN TEXT
C#:
  1. private void reflectProperty(object rClass)
  2. {
  3.    PropertyInfo propi = rClass.GetType().GetProperty("PI", typeof(float));
  4.  
  5.    if (null != propi && propi.CanRead)
  6.    {
  7.       Console.WriteLine("PI: " + propi.GetValue(rClass, new object[] { }));
  8.    }
  9. }

Aufgerufen wird diese Methode beispielsweise mit einer flüchtigen Instanz der Klasse Calculator.

PLAIN TEXT
C#:
  1. reflectProperty(new Reflection_Test.Calculator());

Ausgabe:

PI: 3,14

Reflektierte Methoden aufrufen

Häufiger Wunsch ist es, nicht nur Metadaten einer Assembly abzufragen, sondern auch bestimmte Methoden aufzurufen.

Dies geschieht mit der Instanzmethode des Objekts vom Typ MethodInfo.
Die Methode reflectAndInvokeMethode() sucht nach Methoden nach ihren Namen und ruft sie nacheinander auf.

PLAIN TEXT
C#:
  1. private void reflectAndInvokeMethod(object rClass, string[] methodnames)
  2. {
  3.    foreach (string methodname in methodnames)
  4.    {
  5.       MethodInfo mi = rClass.GetType().GetMethod(methodname);
  6.  
  7.       if (null != mi)
  8.       {
  9.          mi.Invoke(rClass, new Object[] { });
  10.       }
  11.    }
  12. }

Aufgerufen wird die Methode beispielsweise wie folgt, dabei wird ihr eine flüchtige Instanz der Klasse Calculator sowie zwei Namen von Methoden übergeben.

PLAIN TEXT
C#:
  1. reflectAndInvokeMethod(new Reflection_Test.Calculator(), new String[] { "doThis", "doThat" });

Ausgabe:

We do this!
We do that!

Aufruf einer reflektierten Methode mit Rückgabewert

Eine "reflektierte" Methode liefert ihren Rückgabewert direkt von der Invoke-Methode zurück und kann einer Variable zugewiesen werden.

PLAIN TEXT
C#:
  1. Type ctype = typeof(Reflection_Test.Calculator);
  2.  
  3. MethodInfo[] mi3 = ctype.GetMethods();
  4.  
  5. foreach (MethodInfo mi in mi3)
  6. {
  7.    Reflection_Test.Calculator Calculator = new Reflection_Test.Calculator();
  8.  
  9.    if (mi.Name.Equals("DivideAndWrite"))
  10.    {
  11.  
  12.       // Rückgabewert von reflektierter Methode empfangen
  13.       double returnvalue = Convert.ToDouble(mi.Invoke(Calculator, new Object[] { 5.0 }));
  14.  
  15.       Console.WriteLine("Value: " + returnvalue.ToString());
  16.    }
  17. }

Ausgabe:

Value: 2



]]> http://www.der-wirtschaftsingenieur.de/index.php/reflections-in-c-sharp/feed/ 2 Überladen von Methoden http://www.der-wirtschaftsingenieur.de/index.php/uberladen-von-methoden-in-c-sharp/ http://www.der-wirtschaftsingenieur.de/index.php/uberladen-von-methoden-in-c-sharp/#comments Tue, 26 Aug 2008 19:46:26 +0000 admin http://www.der-wirtschaftsingenieur.de/?p=191 Im Laufe eines Software-Projekts sind Algorithmen zu entwerfen und in Methoden zu schachteln, welche zwar prinzipiell das gleiche tun, aber mit Werten von unterschiedlichen Datentypen oder einer verschiedenen Anzahl an Werten. Für solche Fälle bietet C# die Möglichkeit zur Überladung von Methoden.

Die meisten höheren Programmiersprachen erlauben überladene Methoden, neben C# beispielsweise auch C++ und Java.
Überladene Methoden haben zwei oder mehr Signaturen. Die Signatur ist die Kopfzeile einer Methode, welche die Zugriffsmöglichkeit, den Rückgabewert, den Methodennamen und die Parameter (Namen, Anzahl und Typ) beschreibt.
Die Überladung bezieht sich in C# (und den meisten anderen Programmiersprachen auch) jedoch ausschließlich auf die Parameteranzahl und die Datentypen der Parameter, denn nur diese sind bei einem Methodenaufruf maßgebend für eine klare Abgrenzung der verschiedenen Ausführungen einer überladenen Methode.

Die Methode sumTwoValues() (tatsächlich wird hier für gewöhnlich von nur einer Methode gesprochen, obwohl es sich strukturell um zwei Methoden handelt) ist überladen.
Werden der Methode zwei Werte des Typs Integer (int) übergeben, wird entsprechend ein Wert vom Typ Integer zurückgeliefert.
Sind die Parameter andernfalls aber Werte vom Typ double, liefert die Methode einen Wert vom Typ double zurück. Der Rückgabedatentyp und die Datentypen der Parameter entsprechen dem in der Signatur der Methode vorgegebenen Schema.

PLAIN TEXT
C#:
  1. private int sumTwoValues(int a, int b)
  2. {
  3.    return a + b;
  4. }
  5.  
  6. private double sumTwoValues(double a, double b)
  7. {
  8.    return a + b;
  9. }

Da sich eine überladene Methode in ihren Ausführungen immer durch die Anzahl an Parametern oder den Datentypen der Parameter klar unterscheiden lassen muss, ist eine weitere Ausführung der Überladung der Methode sumTwoVariables() in beispielsweise folgender Form nicht möglich:

PLAIN TEXT
C#:
  1. // nicht möglich
  2. private int sumTwoValues(double a, double b)
  3. {
  4.    return (int)(a + b);
  5. }

Die überladene Methode pythagoras() unterscheidet zwei Signaturen, welche eine unterschiedliche Parameteranzahl haben. Die erste Ausführung der Methode pythagoras() hat gegenüber der zweiten einen dritten Parameter, welcher mit dem Schlüsselwort out als nicht initialisierter Refernezparameter vorgegeben wird.
Die zweite Ausführung von pythagoras() hat nur zwei Parameter und einen Rückgabewert. Diese Ausführung greift auf die erste Ausführung zurück und gibt das (durch die Referenz erworbene) Ergebnis zurück.

PLAIN TEXT
C#:
  1. private void pythagoras(double a, double b, out double c)
  2. {
  3.    c = Math.Sqrt(a * a + b * b);
  4. }
  5.  
  6. private double pythagoras(double a, double b)
  7. {
  8.    double c;
  9.    pythagoras(a, b, out c);
  10.    return c;
  11. }

Das Überladen von Methoden kann leider nicht immer angewandt werden, wie das folgende Beispiel zeigt:

Die Methode multiplyValues() multipliziert beliebig viele Parameter des Typs double und liefert das Ergebnis ebenfalls als double zurück.
Das Schlüsselwort params sorgt für eine beliebige Anzahl (ein Parameterarray) an Wertetypen im vorgegeben Datentypen (hier: double). Das Parameterarray darf auch "leer" sein, wie der Aufruf von multiplyValues() (Rückgabewert: 1.0) beweist.
Eine Methode kann nur einen Parameterarray haben und somit auch nur einmal das Schlüsselwort params aufnehmen.
Das Schlüsselwort params ist nicht mit den Schlüsselwörtern ref und out kombinierbar, ein Parameterarray ist somit immer ein Wertetyp.

PLAIN TEXT
C#:
  1. private double multiplyValues(params double[] numbers)
  2. {
  3.    double product = 1;
  4.  
  5.    foreach (double number in numbers)
  6.    {
  7.       product *= number;
  8.    }
  9.  
  10.    return product;
  11. }

Überladung (weitere Ausführung hinzufügen):
Soll nun noch eine Ausführung der Methode multiplyValues() aufgestellt werden, welche nur genau zwei Werte vom Typ double als Parameter annehmen soll, dann steht diese, wenn die Methode mit genau zwei Parametern aufgerufen wird, mit der Ausführung der Methode mit einer beliebigen Anzahl an Parametern in Konflikt.
Es bestünde in diesem Fall keine Klarheit, welche Methode aufzurufen ist.

Aus diesem Grund müssen die Methoden verschieden benannt und somit die Überladung umgangen werden. Beispielsweise könnte die zweite Ausführung als eigene Methode wie folgt aussehen:

PLAIN TEXT
C#:
  1. private double multiplyTwoValues(double a, double c)
  2. {
  3.    return multiplyValues(a, c);
  4. }



]]> http://www.der-wirtschaftsingenieur.de/index.php/uberladen-von-methoden-in-c-sharp/feed/ 0 typeof() vs .GetType() http://www.der-wirtschaftsingenieur.de/index.php/typeof-vs-gettype-in-csharp/ http://www.der-wirtschaftsingenieur.de/index.php/typeof-vs-gettype-in-csharp/#comments Wed, 20 Aug 2008 17:59:57 +0000 admin http://www.der-wirtschaftsingenieur.de/?p=162 Um den Typen nach System.Type bestimmen zu können, werden entweder der Operator typeof() oder die Instanzmethode getType() verwendet. Diese beiden Möglichkeiten liefern ein Objekt vom Typ System.Type zurück.

Oft wird die Frage gestellt, welcher Unterschied zwischen diesen beiden Möglichkeiten der Typ-Bestimmung besteht.

Der typeof()-Operator kann nur das Objekt von System.Type eines Typen (eine Klasse) bestimmen.

(Achtung: In C# sind auch die oft als primitiven Typen bezeichneten Wertetypen, z. B. Integer (int) oder Double (double) Klassen!)

Dabei kann der typeof()-Operator auch generische Typen bestimmen. Überladen werden, kann dieser Operator jedoch nicht.

PLAIN TEXT
C#:
  1. System.Type type = typeof(double);

getType() ist eine Methode einer Instanz (eines Objekts). getType() kann daher nicht frei verwendet werden, wie der typeof()-Operator, sondern ist an eine Instanz gebunden. getType() liefert den Typen, der eigenen Instanz zurück.

PLAIN TEXT
C#:
  1. double d = 5.4;
  2. System.Type type = d.GetType();

getType() kann im Gegensatz zu typeof() auch überladen werden. GetType() kann allerdings nicht (typeof() natürlich auch nicht) überschrieben werden.

Auf den Punkt gebracht: Zur Bestimmung von Typen von Klassen wird der Operator typeof() benutzt. Die Bestimmung von Typen von Objekten ist hingegen die Methode getType() zu benutzen.

Nachfolgend eine kleine, vergleichende Veranschauung. Es soll der Typ Int32 festgestellt werden.

PLAIN TEXT
C#:
  1. int number = 4;
  2.  
  3. Type[] types = new Type[3];
  4.  
  5. types[0] = typeof(int);
  6.  
  7. // types[1] = typeof(number);    // Not possible!
  8.  
  9. types[2] = number.GetType();
  10.  
  11. for (int i = 0; i <types.Length; i++)
  12. {
  13.     if (null != types[i])
  14.     {
  15.         Console.WriteLine("Type[" + i.ToString() + "]: " + types[i].Name);
  16.     }
  17. }

Ausgabe:

Type[0]: Int32
Type[2]: Int32

Es wurde mit typeof() genauso wie mit getType() der System.Type Int32 festgestellt.

Ein anderes Beispiel mit einer eigenen Klasse, TestClass:

PLAIN TEXT
C#:
  1. public class TestClass
  2. {
  3.     public TestClass()
  4.     {
  5.  
  6.     }
  7. }

Es wird versucht, das Objekt von System.Type für diese Klasse TestClass zu ermitteln:

PLAIN TEXT
C#:
  1. TestClass tc = new TestClass();
  2.  
  3. Type[] types = new Type[3];
  4.  
  5. // types[0] = typeof(tc);        // Not possible!
  6. types[1] = typeof(TestClass);
  7. types[2] = tc.GetType();
  8.  
  9. for (int i = 0; i <types.Length; i++)
  10. {
  11.     if (null != types[i])
  12.    {
  13.        Console.WriteLine("Type[" + i.ToString() + "]: " + types[i].Name);
  14.    }
  15. }

Ausgabe:

Type[1]: TestClass
Type[2]: TestClass

]]> http://www.der-wirtschaftsingenieur.de/index.php/typeof-vs-gettype-in-csharp/feed/ 1 Ausnahme-Behandlung in C# (Exception-Handling) http://www.der-wirtschaftsingenieur.de/index.php/exceptions-in-c-sharp/ http://www.der-wirtschaftsingenieur.de/index.php/exceptions-in-c-sharp/#comments Fri, 25 Apr 2008 18:49:11 +0000 admin http://www.der-wirtschaftsingenieur.de/?p=108 Ein Programm, welches mit einer höheren Programmiersprache entwickelt wurde, interagiert mit seiner Umwelt, neben anderen Programmen vor allem mit dem Betriebssystem, über dieses auch mit der Hardware.

Während das Programm bis in das kleinste Detail durchdacht und nach unzähligen Tests auch (scheinbar) völlig fehlerfrei funktioniert, kann es bei der Interaktion zwischen dem Programm mit seiner Umwelt zu Problemen kommen.

Beispielsweise könnte es beim Öffnen einer Datei zu einem Fehler kommen, die Datei lässt sich nicht öffnen (obwohl das Programm vorher zumindest die Existenz der Datei festgestellt hatte). Möglicherweise lässt sich eine Datei auch nicht speichern, da der Speicherplatz nicht ausreicht, das Speichermedium entfernt wurde oder defekt ist. Nur einige von sehr vielen Beispielen von sogenannten Exceptions.
Einige Exceptions lassen sich bis zu einem bestimmten Grad vorbeugen; Beispielsweise lässt sich unmittelbar vor der Beanspruchung von Speicherplatz prüfen, ob der Speicherplatz ausreicht. Ob der Speicherplatz dann aber bei der Speicherung tatsächlich vorhanden ist und nicht schon von einem anderen Vorgang belegt wurde, ist erst bei der Speicherung feststellbar.

Mit einem bestimmten System lassen sich solche Fehler zwar nicht verhindern, jedoch behandeln.
Software-Entwickler sprechen hierbei von Fehlerbehandlung oder (besser:) Ausnahmebehandlungen, also die Behandlung von Ausnahmen (Exceptions).

Mit einer Ausnahmebehandlung, wie sie z.B. in C++, Java und C# möglich ist, können diese Fehler umgangen werden, so dass Programm nur die fehlerträchtige Funktion beendet, aber dennoch nicht komplett abstürzt. Das .NET Framework von Microsoft bietet beispielsweise ein einheitliches Fehlermanagement mit der Möglichkeit zur Ausnahmebehandlung.

Was kann mit der Ausnahmebehandlung erreicht werden?

Im Grund bezweckt die Fehlerbehandlung, dass ein Programm immer stabil läuft. Frühere Programme, welche über keine ausgereifte Fehlerbehandlung verfügen, stürzten häufig komplett ab, wenn eine Funktionalität (z.B. das Schreiben auf einen Datenträger) einen Fehler erzeugte. Dies ist besonders ärgerlich, wenn im Programm (bzw. im Arbeitsspeicher) noch nicht gesicherte Daten liegen, welche beim Programmabsturz komplett verloren gehen.

Wo können diese Fehler entstehen?

• Im Laufzeitsystem: z.B. wenn ein Stack „gesprengt“ wurde (StackOverflow) oder auch sogenannte Nullreferenzen (Arrayfeld mit bestimmten Index nicht vorhanden etc.)

• Bei der Benutzung von Bibliotheksklassen: z.B. wenn das Lesen aus einer Datei über eine Methode aus einer Bibliotheksklasse fehlschlägt

• Im eigenen Code: Es ist möglich Exceptions nach eigenem Wunsch auszulösen und auch eigene Exceptions zu definieren und diese auszulösen

Hinweis: Mit Exception-Behandlung sollen keine Programmfehler "ausgebügelt" werden, Programmfehler bzw. Fehler im Programmalgorithmus sollen behoben, nicht mit einer Exception-Behandlung umgangen werden.

Beispiel: Exception in C#

Eine Klasse Exception definiert die Exception, eine Exception ist eine Instanz dieser Klasse.

Neben der allgemeinen Exception gibt es spezielle Exceptions, welchen nur einen besonderen Fehler abfangen.

Eine spezielle Exception ist immer mit Exception benannt, Beispiele:

  • FileNotFoundException
  • IndexOutOfRangeException
  • OutOfMemoryException

Aufbau der Ausnahmebehandlung:

Die Ausnahmebehandlung wird mit nur drei Schlüsselwörtern gegliedert: try, catch und finally

Try („Versuch“ bzw. „versuche“)

Im Try-Block wird der Quellcode eingeschleust, welcher in Verdacht steht, Exceptions auszulösen.

PLAIN TEXT
C#:
  1. try
  2. {
  3.    //...  der Code, welche Ausnahmen erzeugen könnte
  4. }

Catch („Abfangen“)

Im Catch-Block wird eine Exception behandelt.

PLAIN TEXT
C#:
  1. catch (Exception e) // allgemeine Exception (irgend eine!)
  2. {
  3.    // Behandlung der Ausnahme, z.B. Ausgabe der Fehlermeldung
  4. }

Der Catch-Block kann jede Exception abfangen oder sich auf eine spezielle Exception beschränken

PLAIN TEXT
C#:
  1. catch (FileNotFoundException fnfe) // Behandlung der FileNotFoundException (nur diese!)
  2. {
  3.    // Behandlung der speziellen Ausnahme, z.B. Ausgabe an den User, was schief gelaufen sein könnte
  4. }

Wenn jedoch nur bestimmte Exceptions behandelt werden, jedoch eine Exception auftritt, welche durch keinen Catch-Block abgefangen wird, wird die Exception in das nächst höhere Level weitergegeben (bis hin zum Betriebssystem) und zumindest die Methode, wenn nicht das gesamte Programm, abgebrochen.

Finally („abschließend“)

Ein Programmierer hat für die Sicherheit seines Programms Sorge zu tragen und so einige Feinheiten bei der Programmierung zu beachten.

So sind häufig Anweisungen auszuführen, die unbedingt ausgeführt werden müssen, „komme was wolle“.

Beispielweise sollte ein Stream (z.B. zu einer Datei) immer geschlossen werden, nach der Benutzung.

PLAIN TEXT
C#:
  1. StreamReader sr;
  2.  
  3. // Benutzung
  4.  
  5. sr.close();

Der Stream soll immer geschlossen werden, unbedingt aber auch, wenn etwas bei der Benutzung des Streams schief läuft.

Hierfür gibt es den Finally-Block, welcher dazu dient, eine sichere Zone für kritische Aufgabe zu bilden. Anweisungen, welche in jedem Fall auszuführen sind, werden in den Finally-Block platziert.

PLAIN TEXT
C#:
  1. finally
  2. {
  3.    if (sr != null)
  4.    {
  5.       sr.Close();
  6.    }
  7. }

Der Zweck von Finally ist sicher leicht nach zu vollziehen, dennoch kommt schnell die Frage auf, warum der Stream nicht einfach hinter/unter der Catch-Anweisung platziert wird; dann würde der Code ebenfalls ausgeführt werden, egal ob eine FileNotFoundException ausgelöst wurde oder nicht.

Das ist soweit richtig, allerdings ist der Finally-Block eine speziell sichere Zone, welcher unbedingt vor Verlassen der Methode ausgeführt wird.
Wenn beispielsweise eine andere als die FileNotFoundException auftritt, würde die Methode sofort stoppen und der Stream nicht geschlossen werden. Der Finally-Block würde aber in jedem Fall ausgeführt werden.

Weitergabe einer Exception:

Es kann auch notwendig sein, dass eine Methode abgefangen und behandelt wird, dann aber doch trotzdem an die nächst höhere Ebene im Programm oder gar an das Betriebssystem weitergereicht wird, damit die Exception auch auf höherer Ebene behandelt werden kann. Dies ist mit dem Schlüsselwort throw möglich.

PLAIN TEXT
C#:
  1. catch (Exception e)
  2. {
  3.    // Fehlerbehandlung
  4.  
  5.    MessageBox.Show(e.Message);
  6.  
  7.    throw e;    // Weiterreichung der Exception
  8. }

Mit dem Schlüsselwort throw wird die Exception neu geworfen und dadurch die Weiterleitung nach der erstmaligen Behandlung erreicht.

Auf diese Art lässt sich auch irgend eine definierte Exception auslösen, zu jeder Zeit.

PLAIN TEXT
C#:
  1. public void GiveException()
  2. {
  3.    throw new NoNullAllowedException();
  4. }

Komplette Beispiele:

1. Beispiel - Datei lesen und die FileNotFoundException

Die Methode FileIsReady() prüft die Zugriffsbereitschaft genau, indem sie ausgelesen wird.

PLAIN TEXT
C#:
  1. public bool FileIsReady(string path)
  2. {
  3.    bool isReady = true; // zugriffsbereit (optimistisch)
  4.  
  5.    try
  6.    {
  7.       sr = new StreamReader(path);
  8.       string line;
  9.  
  10.       while ((line = sr.ReadLine()) != null)
  11.       {
  12.          Console.WriteLine(line);
  13.       }
  14.    }
  15.    catch (FileNotFoundException)
  16.    {
  17.       isReady = false;    // doch nicht zugriffsbereit
  18.       Console.WriteLine("File does not exist !?");
  19.    }
  20.    finally
  21.    {
  22.       if (sr != null)
  23.       {
  24.          sr.Close();
  25.       }
  26.    }
  27.  
  28.    return isReady;
  29. }

Hinweis: In dem Beispiel wird nur die FileNotFoundException behandelt. Ein Dateizugriff bzw. der Versuch eine Datei zu öffnen, kann jedoch auch zu weiteren Exceptions führen.

Der Test, ob eine Datei zugriffsbereit ist, ist in der Praxis eher unnötig, da sich die Datei, wenn sie wirklich erst benötigt wird, schon wieder in einem anderen Status befinden könnte. Daher wird i.d.R. auf die Datei zugegriffen wenn es nötig wird und genau dann auf eventuell auftretende Ausnahmen eingegangen.

2. Beispiel - Zugriff auf ein Array und die IndexOutOfRangeException

Die TestClass stellt die Methode SetNull() zur Verfügung, welche ein eigenes Array anspricht. Die Funktion setzt alle Felder im Array von (Parameter) start bis end auf den Wert 0.

PLAIN TEXT
C#:
  1. ///
  2. /// Diese Klasse dient der Produktion von Exceptions
  3. ///
  4. public class TestClass
  5. {
  6.    public TestClass()
  7.    {
  8.    }
  9.  
  10.    /// Setzt alle Werte eines eigenen Arrays vom Start-Index bis Ziel-Index
  11.    /// auf den Wert 0
  12.    /// Bei zu hohem Index wird so die Exception "IndexOutOfRangeException"
  13.    /// ausgelöst
  14.    public void SetNull(int start, int end)
  15.    {
  16.       int[] numbers = new int[100];
  17.  
  18.       for (int i = start; i <= end; i++)
  19.       {
  20.          numbers[i] = 0;
  21.          Console.WriteLine(i);
  22.       }
  23.    }
  24. }

Die Klasse Form1 instanziiert die Klasse TestClass und führt deren Methode SetNull() aus. Dabei wird der Wert 500 als Parameter end übergeben, welcher viel zu groß ist und so eine IndexOutOfRangeException hervorruft.

PLAIN TEXT
C#:
  1. public partial class Form1 : Form
  2. {
  3.    public Form1()
  4.    {
  5.    // Testklasse instanziieren
  6.    TestClass tc = new TestClass();
  7.  
  8.    // versuche.....
  9.    try
  10.    {  // ... die Methode auszuführen
  11.       tc.SetNull(80, 500);
  12.    }
  13.    // Falls Fehlerfall 1 (Index zu hoch)...
  14.    catch (IndexOutOfRangeException iore)
  15.    {
  16.       // ...gebe eine Fehlermeldung aus
  17.       Console.WriteLine("Index Out of Range :( ");
  18.    }
  19.    // Falls Fehlerfall 2 (irgend ein Fehler)...
  20.    catch (Exception e)
  21.    {
  22.       // ...gebe die Fehlermeldung aus
  23.       Console.WriteLine(e.Message);
  24.    }
  25.  
  26.    // .... weiter geht`s mit anderen Aufgaben...
  27. }

Hinweise: In der Praxis sollte die Methode SetNull() natürlich mit eine If-Bedingung feststellen, ob die Größe des Array ausreicht. So ließe sich die IndexOutOfRangeException vermeiden!

]]> http://www.der-wirtschaftsingenieur.de/index.php/exceptions-in-c-sharp/feed/ 0 Wertetyp vs Refernztyp http://www.der-wirtschaftsingenieur.de/index.php/wertetyp-vs-refernztyp/ http://www.der-wirtschaftsingenieur.de/index.php/wertetyp-vs-refernztyp/#comments Tue, 25 Mar 2008 18:44:29 +0000 admin http://www.der-wirtschaftsingenieur.de/index.php/2008/03/25/wertetyp-vs-refernztyp/ In der prozeduralen und objektorientierten Programmierung wird zwischen Wertetypen und Referenztypen unterschieden.
Beispielsweise sind in den Programmiersprachen C# und Java primitive Datentypen, Enumeratoren und Strukturen Wertetypen. Klassenobjekte sind hingegen Referenztypen.
In C/C++ dienen Pointer (Zeiger) als Refernztyp, welche die Adresse speichert, die auf einen veränderbaren Wert verweist. Über den Pointer kann die Adresse dann von Funktion zu Funktion überreicht werden.
So kann aus jeder Funktion heraus, die den Zeiger zur Verfügung hat, der Wert verändert werden, auf den die Adresse zeigt. Der geänderte Wert ist über diese Adresse wieder abrufbar, von allen Funktionen aus, die die Refernz bekommen haben. Ein Zeiger in C ist also eine Referenz.

Ähnlich verhält es sich bei Klassenobjekten in C# und Java. Für diese wird ein Speicherplatz im Heap des Arbeitsspeichers angefordert, welcher sich über die Speicheradresse ansprechen und verändern (bzw. überschreiben) lässt. Auch die Klassenobjekte in C++ werden im Heap gespeichert.
Der Heap kann beliebig angesprochen werden, jedoch muss der Speicher bei Bedarf geordert und spätestens bei Programmende wieder freigegeben werden.
In C++ muss sich darum der Programmierer selbst kümmern; C#, Java und die meisten objektorientierten Skriptsprachen haben hierfür eine automatische Speicherbereinigung (Garbage Collector).

Wertetypen werden nicht über eine Speicheradresse an eine Funktion übergeben, sondern als Wert. Diese Werte werden kopiert und auf den Stack im Arbeitsspeicher gelegt.
Je mehr die Funktionsaufrufe verschachtelt sind, um so größer wird auch der Stack.
Diese Vorgehensweise ist durchaus sinnvoll, denn auf den Stack kann zwar nicht beliebig, sondern nur über das aktuellste (oberste) Stack-Element zugegriffen werden, da jedoch auch vor allem die
Funktionsvariablen (Parameter) benötigt werden, erfolgt der Zugriff daher i.d.R. sehr schnell.
Bei jeder Parameterübergabe mit Wertetypen werden die Werte daher kopiert und der Stack wächst. Die Werte sind (zumindest noch bei Funktionsaufruf) redundant auf dem Stack.
Werden die Parameter in der Funktion verändert, hat dies keine Auswirkungen auf die Variablen, welche außerhalb der Funktion als Parameter übergeben wurden.

In einigen Fällen ist es vom Programmierer erwünscht, dass auch Wertetypen innerhalb der Funktion geändert werden können. Wertetypen können als Referenz übergeben werden. Dann sind diese in C/C++ als Pointer zu übergeben, in C# und Java mit dem Schlüsselwort ref.

Ein Beispiel-Programm mit Funktionsaufrufen und Parameterübergaben als Werte- und Referenztyp:

PLAIN TEXT
C#:
  1. class Program
  2. {
  3.      static void Main(string[] args)
  4.     {
  5.         Program program = new Program();
  6.     }
  7.  
  8.     public Program()
  9.     {
  10.         int a = 45;
  11.         int b = 34;
  12.  
  13.         this.Sum(a, b);
  14.         Console.WriteLine("a = " + a.ToString() + "; b = " + b.ToString());
  15.  
  16.         this.Sum2(ref a, ref b);
  17.         Console.WriteLine("a = " + a.ToString() + "; b = " + b.ToString());
  18.     }
  19.  
  20.     // Normalfall: By Value - die Variable a kann nicht überschrieben werden
  21.     private void Sum(int param1, int param2)
  22.     {
  23.         param1 = param1 + param2;
  24.     }
  25.  
  26.     // Sonderfall: By Reference - die Variable a wird überschrieben
  27.     private void Sum2(ref int param1, ref int param2)
  28.     {
  29.         param1 = param1 + param2;
  30.     }
  31. }

Ausgabe:

a = 45; b = 34
a = 79; b = 34

Die Ausgabe des Programms zeigt, dass nur die Methode mit der als Referenz übergebenen Parameter die Variablen im Konstruktor verändert.

Alternativ zum Schlüsselwort ref kann auch das Schlüsselwort out verwendet werden.
Während ein mit ref bezeichneter Parameter vor Paramterübergabe definitiv initialisiert werden muss damit er verwendet werden kann, initialisiert sich ein mit out bezeichneter Parameter bei Methodenaufruf selber und muss daher nicht im Vorfeld initialisiert worden sein.
Hiervon abgesehen besteht kein wesentlicher Unterschied zwischen den Schlüsselwörtern ref und out, daher kann auch keine Überladung mit Unterscheidung dieser beiden Schlüsselwörter geschehen.

Boxing / Unboxing

Eine Konvertierung eines Wertetyps zu einem Referenztyp wird als Boxing bezeichnet. Unboxing ist die entgegengesetzte Konvertierung, also einer Referenz zu einem Wert. Dabei ist in C# und Java i.d.R. explizites Casting notwendig (Vorbestimmung des Datentyps zwischen einfachen Klammern).

PLAIN TEXT
C#:
  1. int a = 1548;    // Wertetyp
  2. object o = a;    // boxing
  3. int b = (int)o;  // unboxing (mit Casting)

]]> http://www.der-wirtschaftsingenieur.de/index.php/wertetyp-vs-refernztyp/feed/ 1 Queue Datenstruktur in C# http://www.der-wirtschaftsingenieur.de/index.php/queue-datenstruktur-in-c/ http://www.der-wirtschaftsingenieur.de/index.php/queue-datenstruktur-in-c/#comments Wed, 19 Mar 2008 22:06:15 +0000 admin http://www.der-wirtschaftsingenieur.de/index.php/2008/03/19/queue-datenstruktur-in-c/ Eine Queue (Warteschlange) ist eine First-in-First-out-(FIFO) Datenstruktur.
Die Datenstruktur Queue ist ein Stapel, auf welchem nach und nach Daten abgelegt werden.
Allerdings wird auf Elemente der Queue nur von unten zugegriffen. Das unterste Element ist das mit höchster Priorität, nur auf dieses als erstes hinzugefügte Element kann zugegriffen werden.

Stack

Ein Pointer (Zeiger) zeigt intern immer auf das Element, welches (relativ zu den anderen Elementen) als erstes in die Queue aufgenommen wurde.
Ein einfaches "Lösche aus der Queue" gibt es nicht, ein Element kann aus der Queue mit Peek() herausgelesen und mit Dequeue() herausgelesen und zugleich entfernt werden.
An das Warteschlangenende angereiht werden Elemente mit Enqueue();

Funktionsweise einer Queue an Hand eines praktischen Beispiels:

Stellen Sie sich vor, Sie müssten eine Software für ein Theater schreiben. Die Software soll Ticket-Bestellungen für
Vorführungen bearbeiten. Nun sind die Vorstellungen aber sehr schnell ausgebucht, so dass viele Tickets nicht mehr ausgestellt werden können. Bei der Ticket-Bestellung gilt jedoch "wer zu erst kommt, mal zu erst".
Die Daten aller eingehenden Bestellungen legen Sie in eine Queue (Warteschlange). Die Daten in der Queue werden vom ersten bis zum letzten Eintrag abgearbeitet, bis die Queue vollständig abgearbeitet wurde oder keine Plätze mehr verfügbar sind.

Beispielhafte Verwendung einer Queue in C#

Eine Queue wird mit der Klasse Queue angelegt. Die Queue benötigt jedoch die Information, von welchem Typ die zu speichernden Daten sein werden, diese werden mit spitzen Klammern angegeben.
Im Beispiel wird eine Queue angelegt, welche Strings speichern soll. Dabei wird seine Kapazität auf 500 Elemente beschränkt.

Diese Queue soll Bewerber auf Tickets für eine Theateraufführung speichern.

PLAIN TEXT
C#:
  1. Queue<string> queue = new Queue<string>(500);

In einer ArrayList werden dafür 7 Beispiel-Bewerber eingetragen. Die Klasse ArrayList setzt using System.Collections vorraus.

PLAIN TEXT
C#:
  1. ArrayList applicants = new ArrayList();
  2.  
  3. applicants.AddRange(new string[] {
  4.                                                 "Thomas",
  5.                                                 "Daniela",
  6.                                                 "David" ,
  7.                                                 "Sarah",
  8.                                                 "Marion",
  9.                                                 "Friedarike",
  10.                                                 "Benjamin" });

Die Bewerber werden in die Queue (Warteschlange) eingereiht:

PLAIN TEXT
C#:
  1. foreach (string applicant in applicants)
  2. {
  3.        queue.Enqueue(applicant);
  4. }

Die Plätze sind jedoch begrenzt, nur 5 Tickets können vergeben werden.

PLAIN TEXT
C#:
  1. this.guests = new string[5];

Eine Methode vergibt die Plätze nach dem Prinzip "Wer zu erst kommt, malt zu erst". Die Elemente der Queue werden in das Array guests übertragen.

PLAIN TEXT
C#:
  1. private void EnterShow(Queue<string> queue)
  2. {
  3.       for (int i = 0; i < this.guests.Length; i++)
  4.       {
  5.            this.guests[i] = queue.Dequeue();
  6.       }
  7. }

In dem Beispiel können nicht alle Plätze vergeben werden, so dass die Personen "Friedarike" und "Benjamin" die Vorführung nicht sehen können und vorerst in der Warteschlange verbleiben müssen.

]]> http://www.der-wirtschaftsingenieur.de/index.php/queue-datenstruktur-in-c/feed/ 0 Stack Datenstruktur in C# http://www.der-wirtschaftsingenieur.de/index.php/stack-datenstruktur-in-c/ http://www.der-wirtschaftsingenieur.de/index.php/stack-datenstruktur-in-c/#comments Wed, 19 Mar 2008 21:27:42 +0000 admin http://www.der-wirtschaftsingenieur.de/index.php/2008/03/19/stack-datenstruktur-in-c/ Ein Stack (Stapel) ist eine Last-in-First-out-(LIFO) Datenstruktur.
Die Datenstruktur Stack sollte dann verwendet werden, wenn Daten gesammelt werden, jedoch immer nur ein Datenelement aktuell bearbeitet werden darf.

Das aktuelle Element ist dann das einzige, auf welches zugegriffen werden kann. Alle anderen Elemente bleiben im
Hintergrund und werden erst (und dann auch jeweils einzeln) bearbeitet, wenn das aktuelle Element abgearbeitet und vom Stapel entfernt wurde.

Ein Pointer (Zeiger) zeigt intern immer auf das Element, welches (relativ zu den anderen Elementen) als letztes auf den Stapel gelegt wurde.
Ein einfaches "Lösche aus dem Stack" gibt es nicht, ein Element kann aus dem Stack mit Peek() herausgelesen und mit Pop() herausgelesen und zugleich entfernt werden.
Ein Element kann mit Push() auf den Stack gelegt werden.

Stack

Die Funktionsweise des Stack an Hand eines praktischen Beispiels:
Stellen Sie sich einen Stapel Teller vor, welchen sie abwaschen möchten. Sie würden sicherlich beim obersten Teller anfangen, diesen vom Stapel nehmen und abwaschen. Erst dann können Sie den nächsten Teller vom Stapel nehmen.

Beispielhafte Verwendung eines Stack in C#

Ein Stack wird mit der Klasse Stack angelegt. Der Stack benötigt jedoch die Information, von welchem Typ die zu speichernden Daten sein werden, diese werden mit spitzen Klammern angegeben.
Im Beispiel wird ein Stack angelegt, welcher Integer-Werte speichern soll. Dabei wird seine Kapazität auf 15 Elemente beschränkt.

Im Beispiel werden dann die Werte 3, 4, 5 und 6 auf den Stack abgelegt.

PLAIN TEXT
C#:
  1. Stack<int> stack = new Stack<int>(15);
  2.  
  3. stack.Push(3);
  4. stack.Push(4);
  5. stack.Push(5);
  6. stack.Push(6);

Die Anweisung zum Abruf des obersten Segments...

PLAIN TEXT
C#:
  1. stack.Peek();

...hat folgende Ausgabe zur Folge:

6

Mit der Methode Contains() kann geprüft werden, ob der Stack ein Element enthält (dieses muss nicht das oberste sein). Die Stack-Klasse bietet eine Methode ToArray() an, mit der sich alle Elemente des Stack ausgeben lassen.

Eigentlich soll der Stack die Elemente jedoch nicht alle ausgeben können, sondern nur das oberste (bzw. zuletzt eingefügte) Element!

Dennoch ein Beispiel für eine Methode, welche alle Elemente des Stack ausgibt, in dem jedes Element ausgegeben und entfernt und dann auf einen anderen Stack gelegt wird, um dann wieder (nach der Ausgabe aller Elemente) wieder in den ursprünglichen Stack abgelegt zu werden.

PLAIN TEXT
C#:
  1. private void showStackItems(Stack<int> stack)
  2. {
  3.         Stack<int> tempStack = new Stack<int>();
  4.  
  5.         while (stack.Count> 0)
  6.         {
  7.             Console.WriteLine("Oberster Stackinhalt: " + stack.Peek().ToString());
  8.  
  9.             tempStack.Push(stack.Pop());
  10.         }
  11.  
  12.        while (tempStack.Count> 0)
  13.        {
  14.             stack.Push(tempStack.Pop());
  15.       }
  16. }

]]> http://www.der-wirtschaftsingenieur.de/index.php/stack-datenstruktur-in-c/feed/ 0 Hashtable in C# http://www.der-wirtschaftsingenieur.de/index.php/hashtable-in-c/ http://www.der-wirtschaftsingenieur.de/index.php/hashtable-in-c/#comments Mon, 17 Mar 2008 23:48:27 +0000 admin http://www.der-wirtschaftsingenieur.de/index.php/2008/03/18/hashtable-in-c/ Hashtables (Hash-Tabellen) sind Datenstrukturen, die den Arrays sehr ähnlich sind.
Hashtables können in C# ähnlich wie eine ArrayList verwendet werden, der Zugriff erfolgt über einen Index.
Der Index ist ein spezieller Key, welcher eine Zahl (z.B. vom Typ Float oder Integer) genauso wie ein String sein darf.

PLAIN TEXT
C#:
  1. // Beispiele, Syntax: hashtablename[key] = value;
  2.  
  3. ht_pass[32.3] = "juhu";
  4. ht_pass[5] = "tobias";
  5. ht_pass["zoo"] = 45.3;

Wozu werden Hashtables benötigt?

Hashtables sind sinnvoll, wenn sich Listen bzw. Arrays verknüpfen bzw. verschachteln lassen. So kann der Wert eines Listenfeldes der Schlüssel zu einem Wert eines anderen Feldes sein. Zwar ließe sich das auch mit einem normalen Array
(und somit Integer-Werten als Index) realisieren, dann wären jedoch einige zusätzliche Listen/Tabellen nötig, um von einer
Zahl auf einen speziellen Schlüssel und von diesem Schlüssel wieder auf eine anderen Zahlenschlüssel zu verweisen.

C# bietet natürlich einen gewissen Komfort bei Benutzung von Hashtables (wie bei vielen anderen Dingen auch). In der Programmiersprache C haben Programmierer eigene Hash-Funktionen entwickelt, um z.B. einen Text als Zahl umzuschlüsseln (z.B. "Hallo" -> "2342424", "Schule" -> "792942" usw.), um diesen dann als Index (Schlüssel) für ein Array zu benuten. Vorteil: Um einen Wert zu suchen, musste nicht unbedingt das ganze Array durchlaufen und im
schlimmsten Falle alle Felder iteriert werden. Man musste sich nur die Schlüssel für bestimmte Werte merken, diese in eine Zahl konvertieren, auf den Wert im Feld mit dem Schlüssel zugreifen und es auslesen. Daraus ergibt sich ein sehr großer Geschwindigkeitsvorteil.
Der Nachteil liegt in der Größe des Arrays, dieses muss nämlich so groß sein bzw. so einen hohen Index haben, wie eine Zahl, die aus einem Text resultiert, werden kann. Außerdem könnte es vorkommen, dass Werte nicht abgespeichert werden können, da zwei oder mehrere unterschiedliche Texte trotz ausgereiften Algorithmus den selben Index ergeben. Ausweichmöglichkeiten sind zwar vorhanden (den Index verschieben, bis ein freies Feld gefunden wurde), macht die Sache jedoch trotzdem nicht viel unproblematischer.

Die Hashtables in C# sind weitaus dynamischer, denn intern ist ein Hahstable auch nur so groß, wie es notwendig ist. Der Zugriff ist jedoch absolut schnell, konstant schnell! Unabhängig von der Größe des Hashtable ist die Zugriffszeit konstant.

Verwendung von Hashtables

Um die Klasse Hashtable verfügbar zu machen, muss der Namespace Collections benutzt werden.

PLAIN TEXT
C#:
  1. using System.Collections;

Ein Anwendungsbeispiel:

Es soll ein Hashtable angelegt werden, welcher Benutzernamen als Key mit dazugehörigem Benutzerpasswort als Value speichert.

PLAIN TEXT
C#:
  1. // Deklaration
  2. Hashtable ht_pass;
  3.  
  4.  
  5. // Instanziierung des Hashtable ht_pass
  6.  
  7. ht_pass = new Hashtable();
  8.  
  9.  
  10. // Anlegen von Schlüssel-Werte-Paare, ähnlich einem normalen Array
  11.  
  12. ht_pass["benny"]    = "porsche";
  13. ht_pass["david"]    = "programmierer";
  14. ht_pass["thomas"]   = "kaufmann";
  15. ht_pass["daniela"]  = "hamburg";
  16. ht_pass["sarah"]    = "universität";

Nun können die Passwörter ausgegeben werden, beispielweise:

PLAIN TEXT
C#:
  1. Console.WriteLine(this.ht_pass["benny"].ToString());

Ausgabe:

porsche

Aber Vorsicht! Wird ein Schlüssel in den Hashtable eingesetzt, welcher nicht im Hashtable vorkommt, geschieht eine Exception! (Programmabsturz)

Daher wird eine Methode implementiert, welche vorher prüft, ob der Hashtable nicht Null ist und der gewünschte Key im Hashtable vorkommt und erst dann auf das Value zugreift bzw. es nicht versucht, auf einen Wert zuzugreifen.

PLAIN TEXT
C#:
  1. private string GetHashTableValueByIndey(Hashtable ht, string key)
  2. {
  3.       string return_string;
  4.  
  5.       if (ht != null && ht.ContainsKey(key))
  6.       {
  7.           return_string = ht[key].ToString();
  8.       }
  9.       else
  10.       {
  11.           return_string = "[Wert-Schlüssel-Paar mit Schlüssel '" + key + "' existiert nicht]";
  12.       }
  13.  
  14.       return return_string;
  15. }

Um den gesamten Inhalt des Hashtable zu illustrieren, wird eine weitere Methode ShowAllItems() implementiert:

PLAIN TEXT
C#:
  1. private void ShowAllItems(Hashtable hashtable)
  2. {
  3.       foreach (object key in hashtable.Keys)
  4.       {
  5.            Console.WriteLine("Key: " + key.ToString() + "; Value: " + hashtable[key].ToString());
  6.       }
  7. }

Wenn diese Methode mit dem Hashtable ht_pass als Parameter aufgerufen wird....

PLAIN TEXT
C#:
  1. this.ShowAllItems(ht_pass);

... erfolgt die Ausgabe der Schlüssel-Werte-Paare.

Ausgabe:

Key: daniela; Value: hamburg
Key: benny; Value: porsche
Key: sarah; Value: universität
Key: thomas; Value: kaufmann
Key: david; Value: programmierer

Verschachtelung von Hashtables

Ein weiterer Hashtable wird deklariert, welcher eine Beschreibung (Value) zu einem Objekt (Key) bereithält. Die Beschreibung soll einen Hinweis/Tipp auf ein Passwort sein.

PLAIN TEXT
C#:
  1. Hashtable ht_tipp;

Dazu wird eine neue Methode implementiert, die den Hashtable instanziiert und mit Werten füllt.

PLAIN TEXT
C#:
  1. private void InitializeHashtable2()
  2. {
  3.       this.ht_tipp = new Hashtable();
  4.  
  5.       this.ht_tipp.Add("hamburg", "stadt");
  6.       this.ht_tipp.Add("bmw", "automarke");
  7.       this.ht_tipp.Add("porsche", "automarke");
  8.       this.ht_tipp.Add("universität", "öffentliche Einrichtung");
  9. }

Wie im Beispiel zu erkennen, können Schlüssel-Werte-Paare auch mit der Methode Add() hinzugefügt werden. Der erste Parameter der Methode Add() ist der Schlüssel, der zweite Parameter der Wert.

Diese Methode InitializeHashtable2() soll nun ausgeführt werden:

PLAIN TEXT
C#:
  1. InitializeHashtable2();

Nun können wir einem Dritten einen Tipp geben, welches Passwort benny benutzt.

PLAIN TEXT
C#:
  1. string benutzer = "benny";
  2. Console.WriteLine("Ein Tipp für das Passwort von '" + benutzer + "': " + this.ht_tipp[this.ht_pass[benutzer].ToString()].ToString());

oder besser:

PLAIN TEXT
C#:
  1. string benutzer = "benny";
  2. Console.WriteLine("Ein Tipp für das Passwort von '" + benutzer + "': " + this.GetHashTableValueByIndey(this.ht_tipp, this.GetHashTableValueByIndey(this.ht_pass, benutzer)));

Ausgabe:

Ein Tipp für das Passwort von 'benny': automarke

Die beiden Hashtables ht_pass und ht_tipp wurden verschachtelt. Der Wert von ht_pass mit dem Schlüssel benny ist der Schlüssel für einen Wert des Hashtable ht_tipp.

Die Verschachtelung über die Methode GetHashTableValueByIndey() ist sinnvoller, da diese eigenimplementierte Methode auf nicht vorhandene Schlüssel eingeht und eine Exception verhindert.

Ein Beispiel für einen nicht vorhandenen Schlüssel:

PLAIN TEXT
C#:
  1. benutzer = "jens";
  2. Console.WriteLine("Ein Tipp für das Passwort von '" + benutzer + ": " + this.GetHashTableValueByIndey(this.ht_tipp, this.GetHashTableValueByIndey(this.ht_pass, benutzer)));

Ausgabe:

Ein Tipp für das Passwort von 'jens: [Wert-Schlüssel-Paar mit Schlüssel '[Wert-Schlüssel-Paar mit Schlüssel 'jens' existiert nicht]' existiert nicht]

Nachfolgend den gesamten Quelltext im Zusammenhang:

PLAIN TEXT
C#:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Collections;
  4. using System.ComponentModel;
  5. using System.Data;
  6. using System.Text;
  7.  
  8. namespace ConsoleApplication_stack
  9. {
  10.     public class Program
  11.     {
  12.         // Deklaration
  13.         Hashtable ht_pass;
  14.         Hashtable ht_tipp;
  15.  
  16.         private Program()
  17.         {
  18.  
  19.             // Instanziierung des Hashtable ht_pass
  20.  
  21.             ht_pass = new Hashtable();
  22.  
  23.  
  24.             // Anlegen von Schlüssel-Werte-Paaren, ähnlich einem normalen Array
  25.  
  26.             ht_pass["benny"]    = "porsche";
  27.             ht_pass["david"]    = "programmierer";
  28.             ht_pass["thomas"]   = "kaufmann";
  29.             ht_pass["daniela"]  = "hamburg";
  30.             ht_pass["sarah"]    = "universität";
  31.  
  32.             Console.WriteLine(this.ht_pass["benny"].ToString());
  33.             Console.WriteLine(this.GetHashTableValueByIndey(this.ht_pass,"key1"));
  34.             Console.WriteLine(this.GetHashTableValueByIndey(this.ht_pass, "thomas"));
  35.  
  36.             this.ShowAllItems(ht_pass);
  37.  
  38.             InitializeHashtable2();
  39.  
  40.             string benutzer = "benny";
  41.             Console.WriteLine("Ein Tipp für das Passwort von '" + benutzer + "': " + this.ht_tipp[this.ht_pass[benutzer].ToString()].ToString());
  42.             Console.WriteLine("Ein Tipp für das Passwort von '" + benutzer + "': " + this.GetHashTableValueByIndey(this.ht_tipp, this.GetHashTableValueByIndey(this.ht_pass, benutzer)));
  43.  
  44.  
  45.             benutzer = "jens";
  46.             Console.WriteLine("Ein Tipp für das Passwort von '" + benutzer + ": " + this.GetHashTableValueByIndey(this.ht_tipp, this.GetHashTableValueByIndey(this.ht_pass, benutzer)));
  47.         }
  48.  
  49.  
  50.         /// <summary>
  51.         /// Liefert den Wert eines Hastables zurück
  52.         /// </summary>
  53.         /// <param name="ht">Referenz des Hashtable</param>
  54.         /// <param name="key">Schlüssel</param>
  55.         /// <returns>Wert</returns>
  56.         private string GetHashTableValueByIndey(Hashtable ht, string key)
  57.         {
  58.             string return_string;
  59.  
  60.             if (ht != null && ht.ContainsKey(key))
  61.             {
  62.                 return_string = ht[key].ToString();
  63.             }
  64.             else
  65.             {
  66.                 return_string = "[Wert-Schlüssel-Paar mit Schlüssel '" + key + "' existiert nicht]";
  67.             }
  68.  
  69.             return return_string;
  70.         }
  71.  
  72.  
  73.         private void InitializeHashtable2()
  74.         {
  75.             this.ht_tipp = new Hashtable();
  76.  
  77.             this.ht_tipp.Add("hamburg", "stadt");
  78.             this.ht_tipp.Add("bmw", "automarke");
  79.             this.ht_tipp.Add("porsche", "automarke");
  80.             this.ht_tipp.Add("universität", "öffentliche Einrichtung");
  81.         }
  82.  
  83.         private void ShowAllItems(Hashtable hashtable)
  84.         {
  85.             foreach (object key in hashtable.Keys)
  86.             {
  87.                 Console.WriteLine("Key: " + key.ToString() + "; Value: " + hashtable[key].ToString());
  88.             }
  89.         }
  90.  
  91.         public static void Main()
  92.         {
  93.             Program programm = new Program();
  94.         }
  95.     }
  96. }

]]> http://www.der-wirtschaftsingenieur.de/index.php/hashtable-in-c/feed/ 0 Events in C# http://www.der-wirtschaftsingenieur.de/index.php/events-in-c/ http://www.der-wirtschaftsingenieur.de/index.php/events-in-c/#comments Wed, 12 Mar 2008 23:33:42 +0000 admin http://www.der-wirtschaftsingenieur.de/index.php/2008/03/13/events-in-c/ Oft ist es notwendig, dass ein Quellcode ausgeführt wird, wenn ein Button geklickt, ein Programm gestartet oder ein Status erreicht wurde. In vielen Fällen liegt es hierbei an "fremden" Objekten, dass etwas passiert ist, dann soll jedoch entsprechend darauf reagiert werden. Eine Nachricht muss von diesem "fremden" Objekt empfangen werden, wenn das entsprechende Ereignis eintritt. Dieses Ereignis/Event ist der springende Punkt, es kann vom eigenen Programmcode (im Algorithmus oder durch Interaktion mit Benutzer oder Netzwerk) oder auch vom Betriebssystem ausgehen.

Das Betriebssystem und das Framework stellen sehr viele vorgefertigte Events zur Verfügung, welche nur abonniert werden müssen. Bei der Arbeit mit Windows.Forms wird das Ereignis des Button.Click beispielsweise häufig verwendet. Dieses wird z.B. von einem Button button1 wie folgt von der eigenen Klasse (welche auf das Ereignis reagieren soll) abonniert:

PLAIN TEXT
C#:
  1. this.button1.Click += new System.EventHandler(this.button1_Click);

Dabei wird eine Methode einem Delegate (Funktionszeiger) zugewiesen. Diese Methode heißt im Beispiel button1_Click, sie soll ausgeführt werden, wenn der button1 geklickt wird.

PLAIN TEXT
C#:
  1. private void button1_Click(object sender, EventArgs e)
  2. {
  3. \\ tu etwas
  4. }

Die Methode ist die Event-Reaktion. Wird das Event ausgeführt, also der Button geklickt, führt ein Funktionszeiger, der auf diese Methode zeigt, diese aus. Die Methode hat zwei Parameter (Pflichtparameter bei vom Framework vordefinierten Events), auf welche später weiter eingegangen wird.

Eventhandling

Tritt ein Objekt ein Event los, werden alle abonnierenden Objekte benachrichtigt. Bei Button.Click ist der Button das publizierende Objekt. Die Abonnenten können nach der Benachrichtigung, dass ein Event eingetreten ist, entsprechend reagieren. Wie die empfangenden Objekte auf das Ereignis reagieren, interessiert den Event-Publizierer nicht. Dabei wird eine 1-zu-n Beziehung angewandt, denn ein Publizierer kann sehr viele Abonnenten benachrichten.

Ein eigenes Event definieren

Nachfolgend soll ein kleines Programm beschrieben werden, welches von einem Startwert zu einem Endwert zählt. Dabei wird über einen Parameter eine ArrayList an Zahlen übergeben, welche als kritisch eingestuft werden. Stößt die Zählschleife auf diese Zahlen, soll sie sofort (per Event) Alarm schlagen! Wie abonnierende Objekte darauf dann reagieren, ist der Zählschleife ganz egal, nur Alarmschlagen liegt in ihrem Aufgabenbereich.

PLAIN TEXT
C#:
  1. public void Count(int start, int end, ArrayList items)
  2. {
  3.    for (int i = start; i <= end; i++)
  4.    {
  5.       if (items.Contains(i))      // Ein Item erwischt?
  6.       {
  7.          // mach was, aber nicht hier!!
  8.       }
  9.    }
  10. }

Um ein Event-Handling (darf beruhigt als Ereignis-Behandlung bezeichnet werden) einzurichten, ist ein EventHandler notwendig. Dieser ist nichts weiter als ein Delegate (Funktionszeiger), welcher auf eine oder mehrere Methoden zeigt. Das Delegate überbrückt die Distanz zwischen Event-Sender und den entkoppelten Event-Empfängern. Im folgenden Beispiel wird ein EventHandler namens CountEventHandler definiert, er hat zwei Parameter vom Typ object bzw. InfoEventArgs.

PLAIN TEXT
C#:
  1. // Delegate für die Abonnenten
  2. public delegate void CountEventHandler(object Instanz, InfoEventArgs EventInfo);

Die beiden Parameter sind nicht unbedingt für eine Event-Behandlung notwendig, haben jedoch ihren Zweck. Vordefinierte Events des Frameworks sind nach gleichem/ähnlichem Schema eingerichtet. Der erste Parameter vom Typ object verweist auf den Absender (Ereignisauslöser). So kann der Empfänger wissen, welches Objekt das Ereignis auslöste bzw. bei welchem es ausgelöst wurde (dies kann z.B. wichtig sein, wenn mehrere EventHandler auf die gleiche Methode verweisen, also eine n-zu-n Beziehung umgesetzt wurde).

Der zweite Parameter vom Typ InfoEventArgs ist ein spezieller Informationslieferant. Er soll verschiedene Auskünfte über das Event geben.
I.d.R. (spezielle Events ausgenommen) wird statt des Parameters vom Typ InfoEventArgs ein Parameter vom Typ EventArgs übergeben. Dieser Parameter wird bei der Event-Reaktion eine wichtige Rolle spielen.

Das Delegate muss natürlich noch deklariert werden:

PLAIN TEXT
C#:
  1. // Deklaration des Delegates
  2. public CountEventHandler ItemMatch;

Nun existiert ein Delegate vom Typ CountEventHandler mit dem Instanz-Namen ItemMatch. Dieses soll Abonnenten benachrichtigen, wenn eine kritische Zahl erreicht wurde.

InfoEventArgs ist eine, eigens für dieses Event neuverfasste, Definition von der Klasse EventArgs aus dem .NET-Framework. Dabei wird hier eine eigene Klasse geschrieben, die von der Klasse EventArgs erbt, denn die vorgegebene Klasse EventArgs stellt für dieses Beispiel eine Information zu wenig zur Verfügung.

PLAIN TEXT
C#:
  1. public class InfoEventArgs : EventArgs
  2. {
  3.    public readonly int number;
  4.  
  5.    public InfoEventArgs(int number)
  6.    {
  7.       this.number = number;
  8.    }
  9. }

Zweck dieser Eigendefinition ist die Bereitstellung der Zahl, welche für das Event (nämlich dem Alarm) ausschlaggebend war. Diese Zahl soll der Ereignisauslöser bereitstellen und der Ereignis-Abonnent erhalten können, jedoch wirklich nur erhalten, nicht verändern (daher readonly).

Sind keine maßgeschneiderten Event-Informationen notwendig, kann die vorgefertigte EventArgs Klasse verwendet werden (sie darf bei eigenen Events auch ganz weggelassen werden, wenn keine Event-Informationen benötigt werden und die Abonnenten-Benachrichtigung alleine ausreicht). Dann muss eine Instanz der Klasse EventArgs deklariert und instanziiert werden:

PLAIN TEXT
C#:
  1. System.EventArgs eventInfo = new System.EventArgs();

Da hier jedoch die eigene Definition benutzt wird, wird stattdessen die vorherig beschriebene InfoEventArgs Klasse deklariert.

PLAIN TEXT
C#:
  1. // Instanzierung der Klasse für die Event-Informationen
  2. InfoEventArgs eventInfo;

Die eigentliche Zählschleife wird um einige Anweisungen erweitert. Wenn eine kritische Zahl erreicht wurde, also die Bedingung items.Contains(i) erfüllt ist, soll Alarm geschlagen werden. Dazu wird eine Instanz der InfoEventArgs erstellt und dieser über den Konstruktor-Parameter die kritische Zahl übergeben. Dann werden alle Abonnenten benachrichtigt. Gibt es keine Abonnenten, ist das Delegate mit dem Wert Null ausgewiesen, so dass (dank der if-Bedingung) die Benachrichtigung nicht versucht wird. Die Benachrichtigung geschieht durch das Delegate als Stellvertreter für die Methoden der Abonnenten. Diese Methoden, auf welche das Delegate zeigt, müssen zwei Parameter empfangen, wie es bereits bei der Delegate-Definition festgeschrieben wurde.

Zu einem den Parameter vom Typ object, welcher das eigene Objekt (referenziert durch das Schlüsselwort this), zum anderen den Parameter, welcher Auskunft über das Event selbst geben soll, das Objekt eventInfo.

PLAIN TEXT
C#:
  1. // Zählschleife
  2. public void Count(int start, int end, ArrayList items)
  3. {
  4.    for (int i = start; i <= end; i++)
  5.    {
  6.       if (items.Contains(i))      // Ein Item erwischt?
  7.       {
  8.          // Event-Information bereitstellen
  9.          eventInfo = new InfoEventArgs(i);
  10.  
  11.          if (ItemMatch != null)
  12.          {
  13.             // Action! Benachrichtigung der Abonnenten!
  14.             ItemMatch(this, eventInfo);
  15.          }
  16.       }
  17.    }
  18. }

Das Event ist nun vollständig eingerichtet und wird vom Objekt publiziert, d.h. es kann von anderen Objekten (die Zugriff auf das Objekt haben) abonniert werden.

Einen Abonnenten einrichten:

Nun wird eine neue, eigene Klasse Alarm definiert, welche Alarm schlagen soll. Diese Klasse hat einen Konstruktor, der das Objekt als Parameter empfängt, welches das Event anbietet. In diesem Beispiel ist es das Objekt der Klasse Counter, das zur Laufzeit instanziiert werden soll.

PLAIN TEXT
C#:
  1. public class EventAlarm
  2. {
  3.    public EventAlarm(Counter counter)    // Konstruktor
  4.    {
  5.    }
  6.  
  7.    public void Alarm(int item)
  8.    {
  9.       Console.WriteLine("Die kritische Zahl " + item.ToString() + " wurde gefunden!");
  10.    }
  11. }

Wenn die Instanz der Klasse Counter das Event lostritt, soll die Methode Alarm der Klasse EventAlarm aufgerufen werden. Dazu wird eine weitere Methode implementiert:

PLAIN TEXT
C#:
  1. public void ItemMatched(object sender, InfoEventArgs e)
  2. {
  3.    this.Alarm(e.number);
  4. }

Diese Methode ItemMatched ruft die Methode Alarm auf. Nun spielen die Parameter vom Typ object bzw. InfoEventArgs wieder eine Rolle. Diese Parameter müssen in die Signatur der Methode, denn der EventHandler (Delegate) soll auf diese Methode zeigen. Der EventHandler setzt diese Parameter (wie in der Definition des EventHandlers festgelegt) voraus.

Der Parameter e vom Typ InfoEventArgs bietet Zugriff auf die Zahl, die zum Event führte (siehe dazu die Klassen-Definition InfoEventArgs). Der Parameter darf natürlich beliebig benannt werden, Events des .NET Frameworks nennen ihn standardmäßig jedoch auch e.

Damit diese Methode ItemMatched auch im Falle eines Events aufgerufen wird, muss das Objekt der Klasse EventAlarm das Event mit dieser Methode abonnieren, dies geschieht im Konstruktor wie folgt:

PLAIN TEXT
C#:
  1. public EventAlarm(Counter counter)
  2. {
  3.    // Der Funktionszeiger soll auch auf die Funktion "ItemMatched" zeigen
  4.    counter.ItemMatch += new Counter.CountEventHandler(ItemMatched);
  5. }

Das Objekt counter der Klasser Counter stellt den EventHandler ItemMatch zur Verfügung. Eine neue Referenz auf eine Methode wird mittels new-Operator eingerichtet, der Methodenname wird als Parameter (als Referenz) übergeben. Da bekannt ist, dass es nur einen einzigen Abonnent gibt, dürfte auf die Zuweisung mit "+=" verzichtet werden. Sobald es jedoch weitere Abonnenten gibt, würden diese überschrieben werden (und als Abonnenten verloren gehen), daher sollte immer die "+=" Operatorkombination verwendet werden.

Das Event ist nun mit einem Abonnent vollständig eingerichtet.

Nachfolgend der gesamte Quellcode im Zusammenhang:

PLAIN TEXT
C#:
  1. /// <summary>
  2.     /// Start-Klasse
  3.     /// </summary>
  4.     public class Program
  5.     {
  6.         public static void Main()
  7.         {
  8.             Program program = new Program();
  9.         }
  10.  
  11.         private Program()
  12.         {
  13.             Counter counter = new Counter();
  14.             EventAlarm eventAlarm = new EventAlarm(counter);
  15.  
  16.             ArrayList items = new ArrayList();
  17.             items.AddRange(new object [] { 2, 50, 88});
  18.  
  19.             counter.Count(0, 100, items);
  20.         }
  21.     }
  22.  
  23.     /// <summary>
  24.     /// Zusätzliche Event-Information in Klasse lagern
  25.     /// Erbt von EventArgs, welche Standard-Informationen zur Verfügung stellt
  26.     /// </summary>
  27.     public class InfoEventArgs : EventArgs
  28.     {
  29.         public readonly int number;
  30.  
  31.         public InfoEventArgs(int number)
  32.         {
  33.             this.number = number;
  34.         }
  35.     }
  36.  
  37.     /// <summary>
  38.     /// Event-Publizierer
  39.     /// </summary>
  40.     public class Counter
  41.     {
  42.         // Delegate für die Abonnenten
  43.         public delegate void CountEventHandler(object Instanz, InfoEventArgs EventInfo);
  44.  
  45.         // Deklaration des Delegates
  46.         public CountEventHandler ItemMatch;
  47.  
  48.         // Instanzierung der Klasse für die Event-Informationen
  49.         InfoEventArgs eventInfo;
  50.  
  51.         public Counter()    // Konstruktor
  52.         {
  53.  
  54.         }
  55.  
  56.         // Zählschleife
  57.         public void Count(int start, int end, ArrayList items)
  58.         {
  59.             for (int i = start; i <= end; i++)
  60.             {
  61.                 if (items.Contains(i))      // Ein Item erwischt?
  62.                 {
  63.                     // Event-Information bereitstellen
  64.                     eventInfo = new InfoEventArgs(i);
  65.  
  66.                     if (ItemMatch != null)
  67.                     {
  68.                         // Action! Benachrichtigung der Abonnenten!
  69.                         ItemMatch(this, eventInfo);
  70.                     }
  71.                 }
  72.             }
  73.         }
  74.     }
  75.  
  76.     /// <summary>
  77.     /// Diese Klasse aboniert das Event und schlägt Alarm, wenn es eintritt
  78.     /// </summary>
  79.     public class EventAlarm
  80.     {
  81.         public EventAlarm(Counter counter)
  82.         {
  83.             // Der Funktionszeiger soll auch auf die Funktion "ItemMatched" zeigen
  84.             counter.ItemMatch += new Counter.CountEventHandler(ItemMatched);
  85.         }
  86.  
  87.         public void Alarm(int item)
  88.         {
  89.             Console.WriteLine("Die kritische Zahl " + item.ToString() + " wurde gefunden!");
  90.         }
  91.  
  92.         public void ItemMatched(object sender, InfoEventArgs e)
  93.         {
  94.             this.Alarm(e.number);
  95.         }
  96.     }

Ausgabe:



]]> http://www.der-wirtschaftsingenieur.de/index.php/events-in-c/feed/ 0