Dezember 2012 / WPF

WPF steht für Windows Presentation Foundation und ist ein von Microsoft entwickeltes Grafik-Framework. Es ist ein Teil des .NET-Frameworks ab der Version 3.0 und wird mit Windows Vista,
Windows 7 und Windows 8 ausgeliefert. Auch bei Windows XP ab Service Pack 2 kann es nachinstalliert werden.
Es ist eine Alternative zu den herkömmlichen "Windows Forms" und bietet den Vorteil, dass die Präsentationsschicht und die Logik dahinter von Anfang an getrennt werden, da das Design in einer xaml-Datei gespeichert wird, in welcher gar kein C# Code verwendet werden kann.
Somit wird immer automatisch eine zur xaml-Datei gehörende .xaml.cs Datei erstellt, in welche die Logik hinter der Präsentation programmiert werden kann.

XAML

WPF verwendet die sogenannte "Auszeichnungssprache" XAML, welche auf XML basiert und eigens von Microsoft für die Oberflächengestaltung von Anwendungen entwickelt wurde.
Auf ihr basieren abgesehen von WPF auch die Windows Runtime (für die neuen Windows 8-Apps), sowie Silverlight, welches eine Erweiterung für Webbrowser ist und die Ausführung von Rich Internet Applications ermöglicht.
XAML selbst ist jedoch unabhängig von allen 3 Technologien.
Je nach dem welche Technologie wir verwenden, wird XAML auch unterschiedliche Elemente aus den verschiedenen Namespaces verwenden.

WPF mit Visual Studio

Um eine WPF-Applikation zu erstellen, wählt man beim Projekt-Typ anstelle von "Windows Forms-Anwendung" einfach "WPF-Anwendung" aus.
Sobald das Projekt erstellt wurde, fallen auch schon die ersten Unterschiede zu einer normalen "Windows Forms-Anwendung" auf.
Anstelle der "Program.cs"-Klasse, welche jede Windows Forms-Applikation hat und die Main-Methode bereitstellt, welche immer als erstes ausgeführt wird und die 1. Form (die vorhandene Form1) öffnet, befindet sich nun eine App.xaml Datei sowie eine dazugehörige App.xaml.cs Datei.
Ebenfalls ist keine normale Form vorhanden, sondern eine MainWindow.xaml, welche im WPF-Projekt eine "Form" darstellt, sowie die dazugehörige MainWindow.xaml.cs Datei.

In der App.xaml-Datei befindet sich folgender Code:

App.xaml

Hier ist ein neues "Application"-Element definiert, welches als "StartupUri" die Datei MainWindow.xaml" definiert hat. Das ist der Verweis auf das zu öffnende Fenster, nachdem die Applikation gestartet wurde.

Die MainWindow.xaml-Datei enthält folgenden Code:


MainWindow.xaml

Das ist der Standard-Code für eine WPF-Form, bzw. ein WPF-Fenster.

Die Ansicht eines WPF-Fensters im Visual-Studio ist folgendermassen aufgebaut:
Im oberen Bereich sieht man, wie das Fenster aktuell aussieht. Direkt darunter ist der dazugehörige xaml-Code. Möchte man nun etwas ändern, hinzufügen oder löschen, kann man dies entweder direkt im Code machen oder mithilfe der Toolbox bzw. des Designers. Man hat ebenfalls ein Eigenschaften-Fenster, in welchem die Eigenschaften der einzelnen Steuerobjekte angepasst werden kkönnen.
Das Designen an sich ist sehr ähnlich wie in den herkömmlichen Windows Forms-Applikationen. Den Vorteil sehe ich jedoch darin, dass man direkt auch den Design-Code sieht und sehr einfach anpassen kann. Da es ähnlich aufgebaut ist wie die CSS-Eigenschaften, welche man direkt in den HTML-Code schreiben kann, hatte ich keine Probleme, den Aufbau zu verstehen.
Ein grosser Unterschied ist, dass die Ereignisse nun immer in der dazugehörigen .xaml.cs Datei verarbeitet werden und somit von der Präsentationsschicht getrennt sind.

November 2012 / LINQ to SQL

In meinem letzten Post habe ich LINQ-Abfragen & die Lambda-Ausdrücke beschrieben. Um hier weiterzufahren werde ich nun LINQ to SQL beschreiben, also die Möglichkeit auf einen SQL-Server(in meinem Fall Microsoft SQL Server 2008 R2) zuzugreifen.

Vorbereitung

Um die Funktionen zeigen zu können erstelle ich zunächst eine neue Datenbank namens "TestDB" mithilfe des Management Studios. In dieser Datenbank erstelle ich 2 Tabellen Namens "Projekt" und "Kunde", die eine Beziehung haben. Hier ein ERM davon:

LINQ to SQL-Klasse

Die LINQ to SQL-Klasse arbeitet als OR-Mapper, was bedeutet, dass wir mit ihr komplett objektorientiert auf eine eigentlich Relationale Datenbank zugreifen können.Sie generiert uns Klassen direkt aus unseren Tabellen und stellt eine Datenquelle zur Verfügung. Um nun auf die vorhandene Datenbank zugreifen zu können, verwende ich die vorhandene LINQ to SQL-Klasse. Rechtsklick auf das Projekt, "Hinzufügen", "neues Element", "LINQ to SQL-Klassen" auswählen, sinnvollen Namen geben und hinzufügen:

Nun Befindet sich im Projekt eine neue .dmbl Datei:
Wenn Sie geöffnet wird hat man zuerst diese Ansicht:
Nun müssen Sie die Datenbank auswählen, welche verwendet werde soll. Klicken Sie dazu auf "Server-Explorer" bzw. öffnen Sie diesen und wählen Sie "Mit Datenbank verbinden":
Wählen Sie nun "Microsoft SQL Server" aus, da wir ja auch solch eine Datenbank zugreifen werden:
Geben Sie den SQL-Server Namen an und wählen Sie die gewünschte Datenbank aus:
Wählen Sie im Server-Explorer nun die gewünschten Tabellen, in meinem Fall "Projekt" und "Kunde" auf die linke Seite der weissen fläche, welche angezeigt wird.
Nun ist alles vorbereitet und man kann LINQ benutzen um über die erstellte Verbindung Daten zu holen, zu manipulieren und zu löschen.  Arbeiten mit dem DataContext Die LINQ to SQL-Klasse hat nun eine DataContext-Klasse erstellt mit der wir objektorientiert auf die Datenbank zugreifen können. Der Name der Klasse besteht aus dem Namen der LINQ to SQL-Klasse gefolgt von DataContext. In meinem Fall heisst er DatenbankDataContext und so wird er erstellt: DatenbankDataContext dbContext = new DatenbankDataContext(); Nun können wir mit LINQ oder den Methodenaufrufen, welche ich bevorzuge, auf diesen DataContext zugreifen. Möchte ich z.B. alle Kunden in eine Liste abrufen geht das folgendermassen: dbContext.Kunde.ToList(); Zuerst sollte man jedoch etwas in die Datenbank einfügen. Auch das geht über den DataContext. Möchte ich einen neuen Kunden erstellen gehe ich folgendermassen vor: using(DatenbankDataContext dbContext = new DatenbankDataContext) {     //Wir erstellen einen neuen Kunden     Kunde obj = new Kunde();     //Wir setzen die "Kunde_Name" Eigenschaft     obj.Kunde_Name = "TestKunde";     //Fügt das Kunde-Objekt bei einem Aufruf von SubmitChanges in die DB ein     dbContext.Kunde.InsertOnSubmit(obj);     //Speichert die Änderungen, also den neuen Datensatz     dbContext.SubmitChanges(); } Um einen vorhandenen Datensatz zu editieren muss dieser zuerst ausgelesen werden. Wenn ich nun z.B. die ID des Kunden weiss kann ich das folgendermassen tun: using(DatenbankDataContext dbContext = new DatenbankDataContext) {      //Wir holen den Kunden mit der ID 1      Kunde obj = dbContext.Kunde.Single(k => k.Kunde_ID == 1);      //Wir Ändern die "Kunde_Name" Eigenschaft auf "indico"      obj.Kunde_Name = "indico";      //Speichert die Änderungen      dbContext.SubmitChanges(); } Möchte ich einen vorhandenen Datensatz löschen muss ich auch diesen zuerst auslesen. Wenn ich ebenfalls die ID des Kunden kenne kann ich das folgendermassen tun: using(DatenbankDataContext dbContext = new DatenbankDataContext) {      //Wir holen den Kunden mit der ID 1      Kunde obj = dbContext.Kunde.Single(k => k.Kunde_ID == 1);      //Löscht das Kunde-Objekt bei einem Aufruf von SubmitChanges aus der DB      dbContext.Kunde.DeleteOnSubmit(obj);      //Speichert die Änderungen      dbContext.SubmitChanges(); } Nun kann man eigentlich alles machen was man kann. Auch mit Beziehungen funktioniert das ganze sehr einfach. Erstelle ich ein neues Projekt, welches unbedingt einem Kunden zugewiesen werden muss, bevor es gespeichert werden kann, kann ich der Eigenschaft "Kunde" entweder einen vorhandenen Kunden zuweisen oder sogar einen neuen Erstellen und dann zuweisen. LINQ to SQL erkennt so den neuen Kunden und speichert den bei SubmitChanges() auch gleich in die Datenbank.

Oktober 2012 / LINQ-Abfragen & Lambda-Ausdrücke

Language-Integrated Query (LINQ), was auf Deutsch Sprachintegrierte Abfrage bedeutet, wurden dazu geschaffen, dem Benutzer unabhängig von seiner Datenquelle eine einheitliche Objektorientierte Abfragemöglichkeit zu bieten.
Anstatt für die relationalen Datenbanken SQL oder für XML XQuery zu erlernen, kann ein Entwickler mit LINQ einheitlich auf die meisten Datenquellen zuzugreifen. Das funktioniert auch mit Listen oder ADO.NET-Datasets.

LINQ-Abfrage

Die LINQ-Abfrage besteht aus 3 Teilen.
1. Die Datenquelle muss bekannt sein/gemacht werden.
2. Die Abfrage wird erstellt.
3. Die Abfrage wird ausgeführt.
Hier ein kleines Beispiel mit C#:
Zuerst wird eine neue Klasse "Person" definiert mit welcher wir arbeiten werden:

class Person
{
    public Person(string Vorname, string Nachname, string Wohnort)
    {
        this.Vorname = Vorname;
        this.Nachname = Nachname;
        this.Wohnort = Wohnort;
    }
    public string Vorname
    {
        set;
        get;
    }
    public string Nachname
    {
        set;
        get;
    }
    public string Wohnort
    {
        set;
        get;
    }
}

Nun wird wie bereits erwähnt eine Datenquelle definiert.
Wir erstellen hier eine List mit der Klasse Person als Objekte und fügen ihr gleich einige Personen hinzu:

List datenquelle = new List();
datenquelle.Add(new Person("Till", "Schnegg", "Wabern"));
datenquelle.Add(new Person("Max", "Muster", "Zürich"));
datenquelle.Add(new Person("Lorenz", "Müller", "Zürich"));
datenquelle.Add(new Person("C", "Sharp", "Bern"));

Dann wird die Abfrage definiert. Sie besteht aus mindestens 2 Teilen.
Der 1. Teil ist die from-Klausel, welche die Datenquelle angibt.
Der 2. Teil ist die select-Klausel, welche den Typ der zurückgegebenen Elemente angibt.
Ich werde hier gleich noch 2 weitere Teile zeigen.
Die where-Klausel welche zum filtern der Daten verwendet werden kann und die orderby-Klausel mit welcher man die Daten sortieren kann.
Die Abfrage muss noch in eine Variable gespeichert werden, was dann so aussieht:

var abfrage = from person in datenquelle
                      where person.Wohnort == "Zürich"
                      orderby person.Vorname
                      select person;

Hier werden nun alle "Person"-Objekte in der Liste datenquelle, welche als Wohnort "Zürich" eingetragen haben herausgefiltert und nach ihren Vornamen sortiert.
In der where-Klausel können auch die AND(&&) und OR(||) Operatoren verwendet werden um mehrere Bedingungen zu prüfen.

Im Moment enthält die Variable abfrage nur die Abfrage selbst und noch keine Daten. Erst wenn die Abfrage ausgeführt wird, werden die Daten effektiv ausgelesen.
Dazu wird z.B. eine foreach-Schlaufe verwendet:

foreach (Person person in abfrage)
{
    MessageBox.Show(person.Vorname + " " + person.Nachname + "
    Wohnhaft in: " + person.Wohnort);
}

Mit dieser Art werden jedes Mal, wenn auf die variable abfrage zugegriffen wird, die Daten neu aus der Datenquelle gelesen.
Möchte ich das jedoch nur 1-mal tun und die Daten anschliessend nicht neu Laden, kann ich das mit der Methode ToList() erreichen. Dazu wird die ganze Abfrage in eine Klammer gepackt und am Ende die Methode aufgerufen:

List abfrage = (from person in datenquelle
                        where person.Wohnort == "Zürich"
                        orderby person.Vorname
                        select person)
                        .ToList();

 LINQ Methodensyntax (Lambda-Ausdrücke)

In der .NET Common Language Runtime (CLR) kann diese Abfragesyntax nicht direkt verwendet werden. Deshalb werden sie beim Kompilieren in Methodenaufrufe übersetzt, welche die CLR verwenden kann.
Der Entwickler selbst kann diese Methodenaufrufe jedoch auch selbst von Anfang an verwenden, falls er das möchte. In einzelnen Fällen ist es meines Wissens sogar notwendig.
Sie ist nicht ganz so simpel wie die normale Abfragesyntax und ist daher nicht ganz so einfach lesbar.
Die oben gezeigte Abfrage wird z.B. mit Methodenaufrufen so dargestellt:

var abfrage = datenquelle
                     .Where(person => person.Wohnort == "Zürich")
                     .OrderBy(person => person.Vorname);

Diese Abfrage besteht schon aus weniger Teilen, bewirkt jedoch genau das gleiche.
Diese Ausdrücke, welche die Parameter für die Methoden Where() und OrderBy() bereitstellen, nennen sich Lambda-Ausdrücke. Wie genau man diese Ausdrücke ohne die Lambda-Syntax programmieren müsste, weiss ich nicht. Die Lambda-Syntax selbst, ist jedoch leicht zu verstehen und erklärt sich fast von selbst.
Auf der linken Seite kann eine beliebige Zeichenfolge eingegeben werden. Anschliessend muss der Lambda-Operator => verwendet werden. Mit der links eingegebenen Zeichenfolge, kann nun auf die Klasse, welche in der Datenquelle verwendet wird zugegriffen werden. So kann nun in der Where() Methode eine Bedingung definiert oder in der OrderBy() Methode eine Eigenschaft angegeben werden.

Möchte ich hier genau gleich wie oben die Daten direkt holen und nicht jedes Mal neu abfragen, kann ich das auch mit der .ToList() Methode machen. Da ich hier jedoch bereits mit der normalen Objektorientierten Syntax programmiere brauche ich keine Klammern:

var abfrage = datenquelle
                      .Where(person => person.Wohnort == "Zürich")
                      .OrderBy(person => person.Vorname)
                      .ToList();

Es gibt weitere solche Methoden, welche direkt Daten auslesen.
Mit First() kann ich z.B. direkt das erste Objekt aus der Liste nehmen. Würde ich z.B. mit einer Datenbank arbeiten und mit der ID eines Objekts suchen, so wäre klar dass ich nur 1 Objekt zurückbekommen kann.

LINQ Datentransformationen

Mit LINQ kann man neue Typen bzw. Klassen erstellen. Dies kann direkt mit der select-Klausel erstellt werden. Dadurch ist sie auch nicht so nutzlos wie sie einem zuerst erschien.
Angenommen ich möchte jetzt nicht alle Personen welche in Zürich leben sondern bloss die Nachnamen.
Um das zu erreichen muss ich anstelle von "select person" einfach "select person.Nachname" angeben.
Dadurch bekomme ich eine List zurück, welche Strings enthält.

Noch interessanter wird es, wenn ich verschiedene Datenquellen habe, welche verschiedene Objekte speichern.
Habe ich z.B. zusätzlich zu meiner Personenliste noch eine Liste in der ich Tiere speichere.
Die Eigenschaften dieser Klasse definiere ich jetzt einfach mal so:
- Name
- Tierart
- Wohnort
Möchte ich nun die Namen aller Tiere und Menschen auslesen, welche in Zürich wohnen, kann ich das ganz einfach mit der Methode Concat() machen:

var abfrage = (from person in datenquelle
                       where person.Wohnort == "Zürich"
                       select person.Vorname)
                       .Concat
                       (from tier in datenquelle2
                       where tier.Wohnort == "Zürich"
                       select tier.Name);

Diese Abfrage wird ebenfalls eine List mit Strings zurückgeben.

Möchte ich nun z.B. nicht nur den Namen wissen, sondern ebenfalls welche Tierart das Tier hat und auch die Menschen erkennen will so kann ich nicht nur vorhandene Klassen verwenden sondern auch neue kreieren:

var abfrage = (from person in datenquelle
                       where person.Wohnort == "Zürich"
                       select new { Art = "Mensch", Name = person.Vorname + " " + person.Nachname })
                       .Concat
                       (from tier in datenquelle2
                       where tier.Wohnort == "Zürich"
                       select new { Art = tier.Tierart, Name = tier.Name });

Nun wird in dieser Liste eine Klasse ohne Namen aber mit den Eigenschaften Art und Name zurückgegeben.
Die Art ist beim Menschen dabei immer "Mensch" und beim Tier die gespeicherte Tierart.
Der Name setzt sich beim Menschen aus Vor- und Nachname zusammen und beim Tier wird einfach die Eigenschaft Name übernommen.

September 2012 / TCP-Kommunikation

Letzten Monat habe ich beschrieben, wie 2 Programme auf demselben Computer per Interprozesskommunikation kommunizieren können.
Nun beschreibe ich, wie 2 Programme auf 2 verschiedenen Computern kommunizieren können.
Theoretisch könnten so auch 2 Programme auf demselben Computer kommunizieren, jedoch macht das nicht viel sinn, da andere Möglichkeiten für diesen Anwendungsfall bestehen.

Netzwerk-Kommunikation: TCP-Protokoll

Auch bei dieser Kommunikationsart braucht es eine Server-Applikation, welche die Daten empfängt und eine Client-Applikation, welche die Daten sendet.

Server-Applikation

Um auch hier einen übersichtlicheren und besser wiederverwendbaren Code zu programmieren, habe ich eine Klasse erstellt und sie "Listener" genannt.
Die Klasse hat 3 Klassenvariablen:

public TcpListener listener;
public delegate void dMessage(object sender, MessageEventArgs e);
public event dMessage Message;

Die Klasse TcpListener stellt den eigentlichen TCP-Listener bereit.
Das Delegate und der Event sind dazu da, um ein Event auszulösen, wenn eine Nachricht empfangen wurde.
Die Klasse MessageEventArgs, welche als Parameter verwendet wird ist identisch mit jener im Interprozesskommunikations-Beispiel und enthält lediglich einen public string der die gesendeten Daten übergeben soll:

public class MessageEventArgs
{
     public MessageEventArgs(string message)
     {
         Message = message;
     }
     public string Message
     {
         set;
         get;
     }
}

Im Konstruktor der Listener-Klasse wird ein neuer Tcp-Listener instanziiert, jedoch wird er noch nicht verwendet.
Der TcpListener muss auf einen Port hören können. Daher wird ihm dieser als int übergeben.

public Listener(int port)
{
    listener = new TcpListener(IPAddress.Parse("127.0.0.1"), port);
}

In einer eigenen Methode kann der TcpListener nun gestartet werden, damit er Daten empfangen kann.
Der Grund, weshalb der Server nicht direkt im Konstruktor gestartet wird ist, dass dieser somit in einen eigenen Thread ausgelagert werden kann und der Event im Objekt registriert werden kann, in dem es erstellt wurde.
Diese Start-Methode startet den Server bloss einmal, hört also bloss auf einen Client. Wenn dieser die Verbindung schliesst wird der Server beendet. Mit einer While-Schlaufe kann das ganze natürlich angepasst werden.

public void Start()
{
    //Erstellt einen TCPListener, der auf den Port 4711 hört
    //Startet den Listener
    listener.Start();
    //Wartet bis ein Client eine Verbindung aufbaut
    TcpClient c = listener.AcceptTcpClient();
    NetworkStream clientStream = c.GetStream();
    byte[] message = new byte[4096];
    int bytesRead;
    while (true)
    {
        bytesRead = 0;
        try
        {
            //Wartet bis der Client Daten sendet
            bytesRead = clientStream.Read(message, 0, 4096);
        }
        catch
        {
            //Fehler ist aufgetreten
            break;
        }
        if (bytesRead == 0)
        {
             //Der Client hat die Verbindung geschlossen
            break;
        }
        //Nachricht wurde empfangen
        ASCIIEncoding encoder = new ASCIIEncoding();
        //Löst das Message-Event mit dem gesendeten Inhalt als Message aus
        Message(this, new MessageEventArgs(encoder.GetString(message, 0, bytesRead)));
    }
    //Verwirft den Client & Schliesst den Listener
    c.Close();
    listener.Stop();
}

Den Server kann man nun aus einer anderen Klasse z.B. so verwenden:

//Erstellt einen Listener der auf das Port 11993 hört
Listener tcpListener = new Listener(11993);
//Fängt das Message-Event des Listeners ab
tcpListener.Message += new Listener.dMessage(tcpListener_Message);
//Startet den Listener in einem neuen Thread
listener = new Thread(tcpListener.Start);
listener.Start();

Natürlich wird noch die Methode tcpListener_Message gebraucht, mit welcher wir in diesem Fall den Message-Event abarbeiten.

void tcpListener_Message(object sender, MessageEventArgs e)
{
    //Nachricht verarbeiten
}

Client-Applikation

Bei der Client Applikation muss man eigentlich nur 2 Sachen beachten.
1. Dass die richtige IP-Adresse als Ziel verwendet wird und 2. dass der selbe Port verwendet wird.
Auch hier habe ich wieder eine eigene Klasse Namens "Sender" erstellt.
Sie hat 1 Klassenvariablen:

private IPEndPoint serverEndPoint;

Die Klasse IPEndPoint stellt die Verbindungsdaten zum Server bereit und müssen daher nur 1 mal gesetzt werden.

Im Konstruktor der Sender-Klasse wird ein neuer IPEndPoint instanziiert.
Als Parameter werden die IP-Adresse des Servers und das passende Port übergeben.

public Sender(IPAddress ipAddress, int port)
{
    serverEndPoint = new IPEndPoint(ipAddress, port);
}

In einer eigenen Methode können nun Nachrichten an den Server gesendet werden.
Als Parameter wird nur die Nachricht, welche gesendet werden soll übergeben.

public void Send(string message)
{
    //Erstellt einen neuen TcpClient, der die Verbindung aufbauen
    //und die Daten senden wird
    TcpClient client = new TcpClient();
    try
    {
        // Verbindung zum Server wird aufgebaut
        client.Connect(serverEndPoint);
        NetworkStream clientStream = client.GetStream();
        try
        {
            //Codiert den String um, damit dieser gesendet werden kann
            ASCIIEncoding encoder = new ASCIIEncoding();
            byte[] buffer = encoder.GetBytes(message);
            //Schreibt die Nachricht in den Stream
            clientStream.Write(buffer, 0, buffer.Length);
            //Schickt die Nachricht
            clientStream.Flush();
        }
        catch
        {
            //Fehler ist aufgetreten
            MessageBox.Show("Nachricht konnte nicht gesendet werden");
        }
        //Schliesst die Verbindung zum Server
        client.Close();
    }
    catch
    {
        //Verbindung konnte nicht aufgebaut werden
        MessageBox.Show("Es konnte keine Verbindung Server hergestellt werden!");
    }
}

Den Sender kann man nun so verwenden:

//Erstellt einen Sender der auf die Loopback-IP, also die
//IP des eigenen Computers und das Port 11993 sendet
Sender sender = new Sender(IPAddress.Parse("127.0.0.1", 11993);
//Sendet die Nachricht "Test";
sender.send("Test");

So kann immer wieder die Methode send aufgerufen werde um Daten zu senden.

August 2012 / Interprozesskommunikation

Damit mehrere Programme miteinander kommunizieren können, stellt das .NET Framework verschiedene Möglichkeiten bereit.
Programme, welche auf demselben Computer laufen, können die sogenannte "Interprozesskommunikation" nutzen um Daten auszutauschen.
Laufen die Programme jedoch auf verschiedenen Computern, muss ein Netzwerkprotokoll genutzt werden, um Daten auszutauschen.
Dieses Mal werde ich die Interprozesskommunikation mithilfe von Pipes beschreiben, beim nächsten Mal die über das Netzwerkkommunikation mithilfe des TCP-Protokolls.

Interprozesskommunikation: Pipes

Mithilfe von benannten Pipes, kann man zwischen 2 Programmen eine Kommunikation aufbauen. Dazu braucht es eine Server-Applikation, welche die Daten empfängt und eine Client-Applikation, welche die Daten sendet.

Server-Applikation

Um einen übersichtlicheren und besser wiederverwendbaren Code zu programmieren, habe ich eine Klasse namens PipeServer erstellt.
Die Klasse hat 3 Klassenvariablen:

private NamedPipeServerStream serverstream;
public delegate void dMessage(object sender, MessageEventArgs e);
public event dMessage Message;

Die Klasse NamedPipeServerStream stellt den eigentlichen Pipe-Server bereit.
Das Delegate und der Event sind dazu da, um ein Event auszulösen, wenn eine Nachricht empfangen wurde.
Die Klasse MessageEventArgs, welche als Parameter verwendet wird habe ich ebenfalls selbst erstellt und enthält lediglich einen public string der die gesendeten Daten übergeben soll:

public class MessageEventArgs
{
    public MessageEventArgs(string message)
    {
        Message = message;
    }
    public string Message
    {
        set;
        get;
    }
}

Im Konstruktor der PipeServer-Klasse wird ein neuer NamedPipeServerStream instanziiert, jedoch wird er noch nicht verwendet.
Da dieser PipeServer ja über einen Namen läuft, wird dieser beim Konstruktor angegeben:

public PipeServer(string name)
{
    serverStream = new NamedPipeServerStream(name);
}

In einer eigenen Methode kann der PipeServer nun gestartet werden, damit er Daten empfangen kann.
Der Grund, weshalb der Server nicht direkt im Konstruktor gestartet wird ist, dass dieser somit in einen eigenen Thread ausgelagert werden kann und der Event im Objekt registriert werden kann, in dem es erstellt wurde.
Diese Start-Methode startet den Server bloss einmal, hört also bloss auf einen Client. Wenn dieser die Verbindung schliesst wird der Server beendet. Mit einer While-Schlaufe kann das ganze natürlich angepasst werden.

public void Start()
{
    //Startet den Server worauf er auf eine Verbindung durch den Client wartet.
    serverStream.WaitForConnection();

    //Sobald sich ein Programm verbunden hat, wird ein StreamReader für den PipeServer instanziiert
    StreamReader streamReader = new StreamReader(serverStream);

    //Schleife wird durchloffen, bis die Verbindung vom Client getrennt wurde
    while(true)
    {
        //Liest gesendete Daten bei jedem Flush vom Client
        var data = streamReader.ReadLine();

        //Überprüft ob die Verbindung offen ist und Daten gesendet wurden
        if (data != null)
        {
            //Wenn ja wird der Message-Event ausgelöst und die erhaltenen Daten übergeben
            Message(this, new MessageEventArgs(data));
        }
        else
        {
            //Wenn nein wird der Server geschlossen und die Schlaufe verlassen
            serverStream.Close();
            break;
        }
    }
}

Client-Applikation

Die Client-Applikation ist sehr simpel, jedoch muss man wissen, wie das Flush-System des StreamWriters funktioniert.
Zuerst muss ein NamedPipeClientStream aufgebaut werden. Wichtig ist dabei dass er denselben Namen hat wie der NamedPipeServerStream der Server-Applikation. Ansonsten  können Sie keine Verbindung aufbauen:

NamedPipeClientStream clientStream = new NamedPipeClientStream(name);

Anschliessend muss wird versucht die Verbindung zum Server aufzubauen:

clientStream.Connect();

Nun muss ein StreamWriter erstellt werden.

StreamWriter streamWriter = new StreamWriter(clientStream);

Wichtig ist nun ob man mit AutoFlush arbeiten will, oder nicht, der AutoFlush-Wert ist standardmässig auf false gesetzt.
Ohne AutoFlush wird nichts gesendet, bis man die Methode Flush des StreamWriters aufruft.
Mit AutoFlush wird jede abgeschlossene Zeile gesendet:

streamWriter.AutoFlush = true;

Nun können die Daten mit der Write bzw. der WriteLine Methode des StreamWriters gesendet werden:

streamWriter.Write("Das ist");
streamWriter.WriteLine(" ein Test");
streamWriter.Flush(); //Nur nötig wenn AutoFlush deaktiviert ist

Der Server würde nun "Das ist ein Test" erhalten.

Juli 2012 / Projektmethoden

In der Schule hatten wir ein Projekt-Modul in dem es hauptsächlich darum ging, Erfahrungen zu sammeln, wie man ein Projekt am besten plant & realisiert. Es ging also nicht wirklich um den Inhalt des Projekts, sondern vielmehr um die Organisation.
Um ein Projekt sinnvoll abwickeln zu können, verwendet man normalerweise eine Projektmethode. Davon gibt es viele verschiedene, welche für unterschiedliche Projekttypen mehr bzw. weniger geeignet sind.

HERMES

In unserem Fall mussten wir mit der Projektmethode HERMES arbeiten. HERMES ist eine Projektmethode zum Abwickeln von Projekten in der Informations- und Kommunikationstechnik, also genau für unser Gebiet. Jedoch wurde sie in der Schweiz entwickelt und wird nur hier eingesetzt, daher ist sie im Ausland unbedeutend.
HERMES basiert auf dem sogenannten Phasenmodell. Es ist daher in 6 Phasen unterteilt, damit das Projekt strukturiert abgewickelt werden kann. In jeder dieser Phasen ist klar definiert, welche Punkte erreicht werden müssen, um die nächste Phase beginnen zu können.

Initialisierung

In der Phase Initialisierung wird zuerst der Sachverhalt geklärt.
Es wird die Ausgangslage analysiert, Ziele und Lösungen des Projekts grob definiert, der Mittelbedarf geklärt, die Planung und Organisation (Projektteam, Rollen usw.) geklärt und die Risiken und Konsequenzen analysiert.
Das Ganze wird dann in ein Dokument zusammengefasst und als Projektantrag dem Auftraggeber abgegeben.

Voranalyse

In der Phase Voranalyse wird das Projekt an sich genauer analysiert.
Es wird eine Ist-Aufnahme bzw. Ist-Analyse gemacht, bei der z.B. die Konkurrenz analysiert wird.
Die Systemziele werden klar definiert und es werden Prioritäten gesetzt (Muss-/Kann-Ziele).
Der Fachliche Soll-Zustand wird analysiert und definiert: Entitäten werden wörtlich beschrieben, Hauptaufgaben und Anforderungen bezüglich Informationssicherheit und Datenschutz definiert.
Es werden mehrere Lösungsvarianten erarbeitet und der Entscheid über die Lösungsvarianten begründet.
Ebenfalls wird der Mittelbedarf sowie die Risikofaktoren und die Konsequenzen nochmals überarbeitet.

Konzept

In der Phase Konzept wird das Projekt klar bis ins kleinste Detail definiert, sollte es zumindest.
Falls wie in unserem Fall z.B. eine Webanwendung realisiert werden soll, werden die einzelnen Views und deren Aussehen bereits definiert.
Die Anwendungsfälle werden analysiert und ihre Realisierung klar definiert.
Ebenfalls werden Benutzerschnittstellen, Systemarchitektur Datenmodell definiert und womöglich bereits erste Prototypen verschiedener Komponenten entwickelt.

Realisierung

In dieser Phase ist klar was zu tun ist. Das geplante in die Tat umsetzen und das Projekt realisieren.
Auch hier wird alles Dokumentiert, ein Benutzer- und ein Systemhandbuch erstellt.
Hier ist entscheidend, dass das Konzept genug detailliert erstellt wurde, damit man sich nicht allzu viele Gedanken machen muss oder zusätzliche Probleme auftreten, welche man bereits beim erstellen des Konzepts hätte bemerken müssen.

Einführung

In der Phase Einführung wird das realisierte Projekt in den Betrieb genommen bzw. Migriert.
Ebenfalls wird ein Ausbildungsplan für die Mitarbeiter erstellt, ein Akzeptanztest durchgeführt sowie der effektive Mittelbedarf, die Planung und Organisation und Wirtschaftlichkeit überprüft.

Abschluss

Im Abschlussbericht werden die Zielerreichungen festgehalten, die Erfahrungen dokumentiert und in unserem Fall die persönlichen Vorsätze für die IPA schriftlich festgehalten.

Meine Erfahrung mit HERMES

Es ist zwar eine nützliche Projektmethode, jedoch fehlt mir die Iteration, wie sie in anderen Projektmethoden vorhanden ist.  Hat man einmal etwas definiert wird es so gemacht und es gibt keine Möglichkeit das nochmals zu überprüfen und gegebenenfalls abzuändern.
Ebenfalls war unser Konzept zu wenig genau wodurch wir unser Projekt nicht ganz wie geplant realisieren konnten.

Weitere Projektmethoden

Es gibt natürlich noch viele andere Projektmethoden und wie mir zu Ohren gekommen ist, sollte man diese besonders für die IPA kennen, da sie gerne von den Experten abgefragt werden.

Spiralmodell

Das Spiralmodell ist eine Iterative Projektmethode, was bedeutet, dass die einzelnen Phasen immer wieder durchloffen werden. Die 4 Phasen in diesem Modell sind:
1. Festlegen der Ziele
2. Beurteilen von Alternativen, Risikoanalyse
3. Entwicklung und Test
4. Planung des Nächsten Zyklus

Wasserfallmodell / V-Modell

Das Wasserfallmodell ist ähnlich wie HERMES und besteht aus 5 oder 6 Phasen.
1. Anforderungsanalyse und -spezifikation
2. Systemdesign und -spezifikation
3. Programmierung und Modultests
4. Integrations- und Systemtest
5. Auslieferung, Einsatz und Wartung
Hier hat man im Gegensatz zu HERMES die Möglichkeit einzelne Phasen zurück zu springen.

Juni 2012 / Objektorientiertes PHP & Datenbankzugriff

In einem Früheren Blogeintrag vom Oktober 2010 habe ich bereits einmal über PHP und den Datenbankzugriff geschrieben.
Hier werde ich das ganze jedoch objektorientiert erläutern.
Wie auch schon damals werde ich ab und zu Bilder verwenden, da der Blog HTML interpretieren will.

Datenbank

Als Datenbank wird die MySQL-Datenbank von XAMPP verwendet. Mit phpMyAdmin hat man auch gleich ein grafisches Userinterface und kann seine Datenbanken und Tabellen sehr einfach erstellen.
Wie die Beziehungen genau funktionieren, habe ich aus Zeitgründen nicht angeschaut, sondern in PHP Methoden geschrieben, in denen die Daten aus den dazugehörigen Tabellen automatisch geholt werden.

Objektorientiertes PHP

Mit PHP kann objektorientiert programmiert werden und seit PHP 5 wird es sogar richtig gut unterstützt.
Um eine Klasse verwenden zu können, muss natürlich zuerst eine erstellt werden.
Erstellen wir einmal eine Klasse namens Person:
Dazu wird eine Datei Namens Person.Class.php erstellt und folgender Inhalt eingefügt:

Class Person{
}

Wie in jeder anderen Objektorientierten Sprache, werden Objekte ebenfalls durch Variablen referenziert. Zuerst muss sie jedoch ins aktuelle PHP-File eingebunden werden:

include("Person.Class.php");

Der Parameter von include muss dabei dem Dateinamen bzw. Dateipfad der einzubindenden .php-Datei darstellen. So funktioniert es, wenn sich die beiden Dateien im selben Ordner befinden.

Ein neues Objekt mit der Klasse Person kann nun ganz einfach erstellt werden.

$person = new Person();

Eine Klasse ohne Inhalt bringt uns aber natürlich nichts. Daher können nun Klassenvariablen, Methoden und einen Konstruktor definiert werden, genau gleich wie z.B. in C#:

Variable:
public $vorname; 
public $nachname;
public $alter;

Konstruktor:
public function __construct($vorname, $nachname, $alter)
{
    $this->vorhname = $vorname
    $this->nachname = $nachname
    $this->alter = $alter
}

Methode:

Die Variablen sind wohl selbsterklärend.
Dem Konstruktor müssen nun 3 Werte mitgegeben werden.
Im Konstruktor werden diese dann an die Klassenvariablen $vorname, $nachname und $alter übergeben:
Mit $this rufe ich, wie in C# auch, das Objekt selbst auf, also die aktuelle Instanz der Klasse Person. Dieser "Pfeil" "->" ist mit dem "." in C# zu vergleichen. Damit kann man Methoden bzw. Variablen auf- bzw. abrufen.
Eine neue Instanz der Klasse Person müsste nun also so erstellt werden:

$person = new Person("Till", "Schnegg", 18);

Die Methode ist gibt einfach eine Tabelle mit den Werten des Objekts aus.
das würde dann ca. so aussehen:

<><>
<><>
<><>

Name:	Till Schnegg
Alter:	18

Um diese Methode aber auch sinnvoll nützen zu können, muss man zuerst eine Lösungsarchitektur erarbeiten. Es ist jedoch zu viel Code, um euch hier ein ganzes Beispiel zu zeigen.
Wichtig zu wissen ist jedoch, dass immer die index.php Datei gelesen wird und daher auch dessen Konstruktor als erstes ausgeführt. Dort kann man dann beginnen mit den nötigen Methodenaufrufen, um die Seite generieren zu lassen.

Objektorientierter Datenbankzugriff

Um auf eine objektorientiert auf eine Datenbank zuzugreifen, muss die mysqli-Klasse verwendet werden:

$db = @new mysqli('localhost', 'root', '', 'personenerfassung');

So greife ich auf die Datenbank "personenerfassung" auf dem localhost zu, wenn ich kein Passwort gesetzt habe.
Um zu überprüfen, ob die Verbindung erfolgreich aufgebaut wurde, kann man folgende Abfrage einfügen:

if(mysqli_connect_errno())
{
    die('Fehler beim Aufbauen der Verbindung zur Datenbank: ' . mysqli_connect_error() . ' (' . mysqli_connect_errno() . ')');
}

Konnte die Verbindung hergestellt werden, kann nun eine SQL-Abfrage gemacht werden:

$result = $db->query("SELECT * FROM `person`")

Und anschliessend überprüft, ob das query korrekt ausgeführt wurde, wenn ja kann auf die Daten zugegriffen werden:

if (!$result)
{
    echo ("Fehler");
}
else
{
    while($row = $result->fetch_assoc())
    {
        echo($row["name"]);
    }
}

Mit der Zeile while($row = $result->fetch_assoc()) wird durch alle aus der Datenbank geholten, in der Variable $result gespeicherten Einträge rotiert.
Das ganze Datenbank-Handling kann natürlich wieder in eine eigene Klasse geschrieben werden, wenn wir es schon objektorientiert machen wollen.

Mai 2012 / Joomla

Nutzen eines CMS

Ein CMS (Content-Management-System) ist eine Software um den Inhalt einer Medienform, meistens einer Website zu gestalten. Im falle einer Website ist der Vorteil eines CMS, dass der Ersteller keinerlei kenntnisse von HTML oder PHP haben muss. Er kann den Inhalt einfach zusammenklicken, zumindest fast.

Nachteil für HTML-Kenner

Da ich mich selbst mit HTML, PHP und JS zumindest ein bischen auskenne, ist es nicht ganz einfach ohne Grossen Zeitaufwand den Überblick im Code zu behalten.
Möchte man z.B. eine kleine Funktion einbauen, muss man zuerst einmal herausfinden, wie das ganze Datei-System dahinter aufgebaut ist, wie die eigenen Funktionen genutzt werden können usw.
Weitere Funktionen können auch durch vorhandene Plugins integriert werden.
Den Code innerhalb dieser Plugins ist zwar schnell gefunden, vorhandenen Code zu verstehen ist für mich jedoch schwieriger als meine eigene kleine Funktion zu schreiben.

Verwendung von Joomla / Unserer Website

Joomla ist genau ein solches CMS für Websites, welches wir für unsere neue Website verwenden.
Es ist ziemlich einfach aufgebaut. Sobald man sich eingeloggt hat findet man eine Funktions-Übersicht mit passenden Icons:

Diese kann man direkt nutzen um die gewünschte Aktion durchzuführen.
Es ist jedoch auch eine Normale Navigation, welche ich bevorzuge vorhanden:

An unserer Website müssen grundsätzlich bloss die 2 Menüs oder der Inhalt geändert werden.

Menüs:

Um die Menüs zu bearbeiten, muss über den Navigationspunkt "Menüs" das zu bearbeitende Menu ausgewählt werden:

Das Main Menu ist die Haupt-Navigation unserer Website, das Head Menu befindet sich oben rechts und hat bloss 2 Einträge, wird also selten geändert.

Nach dem Auswählen des Menüs, werden alle Menu-Punkte in einer Art Baum-Struktur dargestellt:

"Produkte" ist ein Hauptmenü-Punkt, befindet sich also auf der obersten Ebene. Als Menütyp ist Menüalias definiert, was bedeutet, dass dieser Menüpunkt keinen eigenen Inhalt anzeigt, sondern auf einen anderen Menüpunkt, der einen Inhalt(Beitrag) anzeigt verlinkt.
"SPS-Steuerungen" ist ein Untermenu-Punkt, der ebenfalls als Menüalias definiert ist.
"Siemens" und "Saia" sind beides Untermenu-Punkte von "SPS-Steuerungen" und sind als Beiträge -> einzelner Beitrag definiert. Das bedeutet, dass sie einen Beitrag als Inhalt anzeigen.
Alle weiteren Punkte sind wie "SPS-Steuerungen" ein Untermenu-Punkt. Sie sind jedoch als Beiträge definiert.

Um einen neuen Menupunkt einzufügen muss auf den Neu-Button geklickt werden:

Anschliessend muss ein Menutyp gewählt und der Menutitel angegeben werden:

Ebenfalls muss der Übergeordnete Menu-Punkt ausgewählt werden:

So wird definiert, wo sich der Menupunkt befindet, ob es ein Hauptmenu- oder Untermenu-Punkt ist.
Um nun einen Beitrag anzuzeigen, muss als Menutyp "Einzelner Beitrag" ausgewählt werden. Dann erscheint auf der rechten Seite eine Option "Beitrag wählen", wo man den anzuzeigenden Beitrag auswählen kann:

Möchte man jedoch nichts anzeigen, sondern bloss auf einen anderen Menupunkt verweisen, muss man als Menutyp "Menüalias" auswählen. Dann erscheint wieder an derselben stelle die Option Menüeintrag, wo der anzuzeigende Menupunkt ausgewählt werden kann:

Beiträge:

Um die vorhandenen Beiträge zu bearbeiten oder einen neuen zu erstellen, muss über den Navigationspunkt "Inhalt" Beiträge bzw. neuer Beitrag ausgewählt werden:

Will man einen vorhandenen Beitrag bearbeiten, muss man diesen bloss aus der angezeigten Liste auswählen:

Will man einen neuen Beitrag erstellen, muss man nur einen Titel und einen Alias vergeben. Bei uns wird der Titel normalerweise Gross und der Alias genau gleich nur klein geschrieben:

Anschliessend kann man den Beitrag bearbeiten bzw. komplett neu erstellen.
Dazu bietet Joomla standardmässig einen Editor namens TinyMCE an. Ich habe jedoch einen etwas benutzerfreundlicheren Editor namens JCE installiert. So sieht die Maske aus:

Das Ganze ist ähnlich aufgebaut wie z.B. im Word. Man kann den Text ausrichten, Schriftart, -grösse & -farbe einstellen, Tabellen erstellen, Bilder einfügen usw.

Für HTML- und CSS-Kenner gibt es natürlich die Code-Ansicht, in welcher der Code für den aktuellen Beitrag angezeigt wird. Die Umschaltung findet man direkt oberhalb der JCE-Maske bei [Toggle Editor]:

Um die Änderungen zu speichern, muss man oben rechts im Bild auf Speichern bzw. auf Speichern & Schliessen klicken:

April 2012 / C# Code hinter Reports

C# Report-Möglichkeiten

Aktuell Entwickle ich ein Programm Namens iVBA, welches über eine Access-Datenbank Benutzer, Logins und weiteres speichert.
Aus diesen Benutzer- und Login-Daten müssen Reports erstellt werden können. In C# gibt es verschiedene Möglichkeiten, Reports zu erstellen und anzuzeigen.
- Es gibt die normalen "Reports" welche vom Microsoft Report Viewer dargestellt werden können
- Es gibt die sogenannten "CrystalReports" welche vom CrystalReportViewer dargestellt werden können.
Um die Vor- und Nachteile der beiden Varianten habe ich mich nicht gekümmert.
Ich habe mich für die Microsoft-Variante entschieden und mit dem MicrosoftReportViewer gearbeitet.

Da ich meine Datenbank-Verbindung und all meine Abfragen, wie in früheren Posts von mir beschrieben, per Code definiert habe, wollte ich es auch diesmal genau gleich machen.
Ich fand zuerst bloss Anleitungen, wie ich mir mit Hilfe von Visual Studio ein Dataset erstellen und es dem Report zuweisen kann. Dazu hätte ich jedoch eine neue Verbindung zur Datenbank aufbauen müssen, was mir gar nicht gefiel.

Report-Objekte

Anstatt also direkt die Datenbank als Quelle für meine Reports zu nehmen, erstellte ich meine eigenen Klassen, welche die selben Eigenschaften wie die Datenbank-Tabellen enthielten und fügte diese als Datenquellen hinzu.

Klassen erstellen:

Wir gehen nun davon aus, dass wir eine Tabelle namens "User" haben, welche folgende Eigenschaften hat:

• id
• vorname
• nachname
• email
• inaktiv
• created

Zuerst erstellte ich mir eine neue Klasse mit dem Namen ReportObjects. Innerhalb dieser Klasse erstellte ich dann für jede nötige Tabelle eine Daten-Klasse und eine Klasse, die diese als Liste enthält.
In unserem Fall also eine User-Daten-Klasse und eine User-Listen-Klasse, den Inhalt werde ich später erläutern:

public class ReportObjects
{
    public class User{}
    public class UserList{}
}

Die Klasse User soll nun also die Tabelle darstellen, bzw. die Datensätze darin. Dazu werden in der Klasse folgende Eigenschaften definiert:

private int id;
private string vorname;
private string nachname;
private string email;
private bool inaktiv;
private DateTime created;

Jede dieser Eigenschaften muss natürlich von aussen erreichbar sein, zumindest um diese lesen zu können:

public int Id
{
    get { return id; }
}

Dasselbe wird natürlich für jede Eigenschaft wiederholt, ich denke das kennt ihr.
Um die Eigenschaften zu setzten definieren wir einfach einen Konstruktor:

Public User (int id, string vorname, string nachname, string email, bool inaktiv, DateTime created)
{
    this.id = id;
    this.vorname = vorname;
    this.nachname = nachname;
    this.email = email;
    this.inaktiv = inaktiv;
    this.created = created;
}

Nun ist unsere User-Daten-Klasse also fertig.
Also erstellen wir die User-Listen-Klasse. Die Realisierung dieser Klasse ist eigentlich den Bedürfnissen anzupassen. Hier jedoch meine Variante.
Zuerst erhält die klasse folgende Klassen-Variablen:

private List userList;
private DataTable userSource;

Die userList enthält später alle User, die userSource enthält die Datenquelle für die User, also Datensätze aus der User-Tabelle unserer Datenbank.
Zuerst habe ich 2 Konstruktoren definiert. Der 1. ist dafür da, eine Liste zu erstellen, ohne die userSource bereits zu definieren, der 2. um sie bereits zu übergeben.

public UserList()
{
    userList = new List();
}

public UserList (DataTable userSource)
{
    this.userSource = userSource;
    userList = new List();
    AddUsersToList();                        <-- Wird noch erklärt/definiert
}

Die Methode AddUsersToList() fügt alle Datensätze in der userSource der UserList hinzu und sieht so aus:

private void AddUsersToList()
{
    userList.Clear(); <-- Löscht alle User-Objekte in der UserList
    foreach (DataRow zeile in userSource.Rows)
    {
        userList.Add( new User (
            (int)zeile[0],
            zeile[1].ToString(),
            zeile[2].ToString(),
            zeile[3].ToString(),
            (bool)zeile[4],
            (DateTime)zeile[5]));
    }
}

Nun wären also alle User in der Liste. Hätte ich jedoch den 1. Konstruktor verwendet, wäre noch gar nichts als userSource definiert und die AddUseresToList-Methode noch gar nicht ausgeführt.
Deshalb erstellen wir noch die Methode SetUserSource() welche die userSource setzt:

public void SetUserSource(DataTable userSource)
{
    this.userSource = userSource;
    AddUsersToList();   <-- Fügt sofort alle User der UserList hinzu
}

Sobald wir also entweder den 1. Konstruktor und anschliessend SetUserSource() oder den 2. Konstruktor aufgerufen haben, ist die Liste gefüllt. Um die Liste auch holen zu können müssen wir noch die GetUser-Methode definieren:

public List GetUser()
{
    return userList;
}

Damit kann also auf die Liste in der Klasse zugegriffen werden.

Datenquellen hinzufügen

Kompilieren Sie zuerst ihr Projekt indem sie über "Erstellen" auf "Projektmappe erstellen" klicken.
Navigieren Sie Dann zu: Daten --> Neue Datenquelle hinzufügen --> Objekt --> Weiter
Nun erhalten Sie eine Baum-Struktur. Öffnen Sie ihren eigenen Namespace, diesem Untergeordnet einen Weiteren Knoten mit ihre Namespace . Nun sollten Sie den Knoten ReportObjects sehen. Öffnen Sie diesen und wählen sie User aus.

Bericht erstellen & Anzeigen

Sie brauchen natürlich auch noch einen Report und einen "MicrosoftReportViewer" um diesen anzuzeigen.
Das Ganze kann natürlich immer etwas anders realisiert werden, jedoch zeige ich hier eine Möglichkeit auf.
Erstellen Sie dazu am besten einen Unterordner und fügen sie ihm einen Bericht hinzu(Endung .rdlc nicht rpt).
Diesen können Sie nun so designen, wie Sie möchten.
Um nun die Daten aus unserer User-Datenquelle anzeigen zu können, müssen Sie bei den Datenquellen (falls Sie diese nicht sehen: Daten/Datenquellen anzeigen) die gewünschte Eigenschaft auswählen und per Drag & Drop auf das Formular ziehen.
Fügen Sie die Felder einfach so ein, wird jedoch nur die Eigenschaft des 1. Objekts in der Datenquelle angezeigt.
Möchten Sie eine Auflistung aller Objekte in der Datenquelle, können Sie über die Toolbox eine Liste hinzufügen und die Eigenschaften per Drag & Drop in die Liste ziehen. Dann wird für jedes Objekt ein Listen-Eintrag generiert.

Sobald Sie die 1. Eigenschaft auf das Formular gezogen haben, wird im Hintergrund ein DataSet für den Bericht definiert. Über diesen werden die Daten beim anzeigen geholt. Das ist sehr wichtig und werde ich später noch genauer erläutern. Wenn ich also vom DataSet des Berichts schreibe, ist genau das gemeint.

Damit Sie den Report anzeigen können, müssen Sie eine neue Form hinzufügen. Der ReportViewer wird später per Code hinzugefügt.

Öffnen Sie nun die Form in der Code-Ansicht.
Fügen sie als KlassenVariable eine UserList hinzu:

private ReportObjects.UserList userlist = new ReportObjects.UserList();

Im Konstruktor fügen sie nun einen MicrosoftReportViewer hinzu, wählen den Report aus der angezeigt werden soll und füllen das DataSet des ausgewählten Reports.

public form ()
{
    InitializeComponent();

    //Fügt den ReportViewer hinzu.
    ReportViewer reportViewer = new ReportViewer();
    reportViewer.ProcessingMode = ProcessingMode.Local;
    reportViewer.Dock = DockStyle.Fill;
    this.Controls.Add(reportViewer);

    //Setzt den zu ladenden Report
    reportViewer.LocalReport.ReportEmbeddedResource =
    "Namespace.Reports.reportname.rdlc";

    //Füllen Sie spätestens hier die UserList mit Daten aus der
    //Datenbank. Bei mir z.B. so:
    userList.SetUserSource(dbHandler.GetNewDataTable(
    "SELECT * FROM [User]"))

    //Hier wird die Source für das DataSet gesetzt.
    //Der Name des ReportDataSource(1. Parameter) ist entscheidend!
    //Er besteht immer aus dem Namespace und
    //verbunden mit einem _ dem Namen der Datenquelle.
    //In unserem Fall "Namespace_User"
    //Der 2. Parameter ist die DataSource.
    //In unsere, Fall die Liste im userList-Objekt
    reportViewer.LocalReport.DataSources.Add(
    new ReportDataSource("Namespace_User", userList.GetUser()));

    //Zeigt den Report an
    reportViewer.RefreshReport();
}

In meinem Fall habe ich das Ganze noch mit Parametern ausgestattet, in dem ich den Report übergebe, welcher geladen werden sollte, sowie meine Datenbank-Verbindung. Natürlich braucht es dann noch andere Auswertungen, welchen DataSet nun mit welchen Daten gefüllt werden muss, aber alles kann ich hier auch nicht beschreiben.
Die Rapporte kann man über die Where-Klausel der SQL-Abfrage Filtern.
Nun müssen Sie nur noch die Form aufrufen und der Report, wie auch immer Sie definieren wollen, welcher es nun sein sollte, wird angezeigt.

Parameter

Es kann sein, dass Sie in ihrem Report einige Parameter verwenden. Diese können Sie in der Eigenschaft ReportParameters des Reports definieren.
Diese werden in diesem Fall natürlich auch per Code, spätestens vor dem reportViewer.RefreshReport() gesetzt.
Wir gehen davon aus, dass der Report einen Integer und einen Bool als Parameter braucht.
Um diese zu Übergeben müssen Sie zuerst einen Array von ReportParameter deklarieren:

ReportParameter[] parameter = new ReportParameter[2];

Nun müssen Sie die einzelnen ReportParameter ins Array einfügen:

parameter[0] = new ReportParameter("ParameterName", "53", false);
parameter[1] = new ReportParameter("ParameterName", "True", false);

Äusserst speziell finde ich, dass Parameter bloss als strings übergeben werden können. Deshalb wird der Integer und der Bool hier auch als string übergeben.
Um die Parameter dann doch als Integer bzw. Bool verwenden zu können, müssen Sie im Bericht bei Verwendung des Wertes einfach mit der VB-Syntax einen Ausdruck definieren:
String in Integer: CInt(Parameters!Parametername.Value)
String in Bool: CBool(Parameters!Parametername.Value)
Alle Umwandlungen und weitere Funktionen findet man im Ausdrucks-Generator.

Schlussendlich müssen die Parameter noch dem Report zugewiesen werden:

reportViewer.LocalReport.SetParameters(parameter);

Subreports

Subreports sind etwas sehr nützliches und wurden von mir auch verwendet. Wie ich oben bereits geschrieben habe speichern wir hier Logins. Ein Benutzer hat mehrere Logins auf verschiedene Applikationen.
Das heisst ich haben einen User der hat z.B. mehrere Logins auf eines unserer Produkte.
Möchte ich nun für jeden Benutzer den ich habe alle Logins auf dieses Produkt auflisten, erstelle ich einfach genau gleich wie beim Hauptreport in der Klasse ReportObjects eine Daten-Klasse und eine Listen-Klasse für dieses Login.
Ebenfalls füge ich die Datenquelle hinzu und designe einen neuen Report. Diesen werde ich jedoch nun als Subreport verwenden. Als Parameter werde ich im Unterbericht natürlich die UserID definieren, damit ich auch nur die Logins des aktuellen Users ausgebe.
Dazu werde ich aus der Toolbox einen "Unterbericht"-Steuerelement in den Hauptreport ziehen. Natürlich platziere ich dieses wieder in der Liste, da ich für jeden User einen Sub-Report mit dessen Logins ausgeben will.
Mit einem Rechtsklick auf dieses Steuerelement kann ich meinen erstellten SubReport auswählen und die Parameter auswählen. Als Parametername muss ich den korrekten Namen des Parameters angeben, hier also "UserID". Als Parameterwert die ID des aktuellen Users also "=Fields!Id.Value".

Nun wird der Hauptreport zwar versuchen die Subreports zu erstellen, das wird jedoch nicht funktionieren, da wir den DataSet der Subreports keine Datasource zugewiesen haben.

Um das zu tun registrieren wir im Konstruktor einen neuen Event namens SubReportProcessingEvent:

reportViewer.LocalReport.SubreportProcessing +=
new SubreportProcessingEventHandler
(SubreportProcessingEventHandler);

Natürlich müssen wir die Event-Methode definieren:

void SubreportProcessingEventHandler
(object sender, SubreportProcessingEventArgs e)
{

}

In dieser Prozedur muss genau wie oben beim Hauptreport die DataSource fürs DataSet des Reports definiert werden. Wichtig ist das vorher die vorhandenen Daten gelöscht werden.
Per e.Parameters[index].Value[index] kann auf die Parameter-Werte zugegriffen werden:

e.DataSources.Clear()
loginList.SetLoginSource(dbHandler.GetNewDataTable(
"SELECT * FROM Logins WHERE userID=" + e.Parameters[0].Values[0]));
e.DataSources:Add(new ReportDataSource(
"Namespace_Login", loginList.GetLogins()));

Falls mehrere Unterberichte vorhanden sind können die Namen über die Eigenschaft e.ReportPath ausgelesen werden. So weiss man genau für welchen Bericht nun das DataSet gesetzt werden muss.

März 2012 / ASP.NET MVC 3

MVC - Model View Controller

MVC steht für Model View Controller und ist eine Architektur in der Software-Entwicklung. Sie besteht aus 3 Einheiten nämlich Model(Datenmodell), View(Präsentation - UI) und Controller(Programmsteuerung).
Ziel der Architektur ist es, spätere Änderungen oder Erweiterungen zu vereinfachen und die Wiederverwendbarkeit einzelner Klassen & Komponenten.

Model:

Zumindest in ASP.NET MVC 3, welches ich verwendet habe, gibt es eigentlich 2 Arten von Models. Die 1. Art heisst "Domainmodel", ist komplett von View und Controller unabhängig und wird verwendet, um die Datenbankstruktur hinter der Anwendung zu kreieren.
Dazu wird das Entity Framework verwendet, welches "CodeFirst" ermöglicht verwendet. Dazu jedoch später mehr.
Die 2. Art heisst "Viewmodel" und wiederspiegelt die View. Das heisst es ist der View angepasst, so dass alle nötigen Informationen von der View an den Controller weitergegeben werden kann, diese Daten werden jedoch nicht direkt sondern gefiltert und über ein Domainmodel in die Datenbank gespeichert. Diese Models sind sozusagen von der View abhängig und müssen somit bei Änderungen ebenfalls angepasst werden.

Controller

Der Controller ist die Steuerung der Applikation und verwaltet eine oder mehrere Views. Von diesen nimmt er die Benutzerinteraktionen entgegen, wertet diese aus und reagiert entsprechend. Er ist ebenfalls dafür zuständig, die erhaltenen Daten falls nötig zu manipulieren und/oder zu speichern/ändern/löschen.

View

Die View ist lediglich für die Darstellung zuständig. Hier wird also die Grafische Oberfläche definiert und mit den vom Controller, als Model erhaltenen Daten gefüllt. Die View selbst enthält aber keine Logik, sondern Sendet die Daten bloss an den Controller weiter. Eine View hat zwingend immer einen Controller, damit diese Überhaupt angezeigt werden kann, kann jedoch ohne Model auskommen.

ASP.NET MVC 3

ASP.NET MVC 3 ist ein Framework zum erstellen von Websites, basierend auf ASP.NET und dem .NET Framework. Die Website wird natürlich mit der MVC-Architektur erstellt, was durch dieses Framework hervorragend unterstützt wird. Es basiert auf dem .NET Framework 4.0 was eine Verwendung von Visual Studio 2010 nötig macht, da die früheren Visual Studio Versionen diese .NET Version nicht unterstützen.

Entity Framework

MVC 3 integriert das Entity Framework, welches CodeFirst unterstützt. Dass ermöglicht uns aus den Models der Webanwendung die Datenbank kreieren zu lassen.
Die Models werden also wie ganz normale Klassen erstellt und mit Eigenschaften versehen. Möchte ich z.B. eine Webanwendung mit verschiedenen Alben erstellen kann ich das Model folgendermassen realisieren:

public class Album
{
    public int AlbumId { get; set; }
    public string Titel { get; set; }
    public int Preis { get; set; }
}

Das Entity Framework erstellt daraus eine Tabelle, welche die Eigenschaften der Klasse als Spalten verwendet.
Es verwendet das sogenannte ORM (object relational mapping), was aus objektorientierten Datenmodellen relationale Datenbanken generiert. Das erleichtert das Programmieren ungemein, da für das Programm alles komplett objektorientiert bleibt.Die SQL-Befehle werden ebenfalls durch das Entity Framework generiert, was dem Entwickler ebenfalls viel Arbeit abnimmt.

Strongly-typed View

Eine Strongly-typed View hat immer ein Model als Parameter, was ja bekanntlich nicht bei jeder View der Fall ist. Dafür muss folgender Code in die 1. Zeile der View:
@model Namespace.Models.Album
Diese Views ermöglichen, dass direkt auf die Eigenschaften des übergebenen Models zugegriffen werden kann. Das erleichtert die Programmierung stark und ermöglicht vollen IntelliSense Support. Somit kann, bei einer Strongly-typed View auf Album mit folgendem Code auf den Preis des Models zugegriffen werden:
@Model.Preis
Es können ebenfalls mehrere Models übergeben werden, wodurch auch auf alle Models zugegriffen werden kann. Dazu muss die 1. Zeile der View mit IEnumerable modifiziert werden:
@model IEnumerable
Anschliessend kann z.B. auf die Anzahl übergebener Models mit @Model.Count() zugegriffen, oder alle mit einer foreach-Schlaufe aufgelistet werden.
@foreach (var album in Model)
{
    @Model.Titel
}

Validierung der Daten

Wird z.B. eine View erzeugt, um neue Alben zu erfassen, müssen natürlich gewisse Validierungs-Regeln wie die maximale Zeichenlänge oder der Datentyp der einzelnen Eigenschaften definiert werden. Das schöne hier ist, dass alle Validierungs-Regeln direkt im Model definiert werden können. Somit muss eine spätere Änderung auch bloss dort gemacht werden.
Es werden viele Validierungs-Regeln angeboten, wie Required, DataType, Display, StringLength usw.
Die Regeln werden immer in [] vor der Eigenschaft definiert. So könnte es z.B. beim Albumtitel aussehen:

[Required]
[StringLength(100, ErrorMessage = "Error", MinimumLength = 2]
public string Titel { get; set;}

Mehr über MVC - Nützliche Tutorials

MVC ist ein riesiges Gebiet und bietet unglaublich viele Möglichkeiten.
Um mehr über MVC 3 zu erfahren besuchen sie folgende Websites:
http://www.asp.net/mvc/mvc3
http://www.asp.net/mvc/overview/getting-started
Ich selbst habe bisher 2 Tutorials gemacht, welche beide sehr nützlich sind.
Hier wird eine Film-Sammlung Programmiert:
http://www.asp.net/mvc/tutorials/getting-started-with-aspnet-mvc3/getting-started-with-mvc3-part1-cs
Hier wird ein MusicStore Programmiert:
http://www.asp.net/mvc/tutorials/mvc-music-store/mvc-music-store-part-1
Das 2. Tutorial finde ich wirklich super, da alles von Grund auf neu gemacht wird und nicht wie im 1. Bereits mit vorhandenem gearbeitet wird.

Februar 2012 / C# AccessDB auf Text- / Check-boxen

Zugriff auf Access-DB mit C#
 

Zu diesem Thema habe ich bereits vor einigen Monaten im August 2011 einen Blogeintrag verfasst. In diesem Eintrag findet man die Anleitung, um eine Tabelle aus einer Access-Datenbank zu holen, und wieder zu speichern.

Heute werde ich beschreiben, wie man eine Tabelle mit Hilfe eines BindingNavigators an Textboxen bzw. bei einem Boolean an Checkboxen bindet.

Der BindingNavigator findet sich in der Toolbox von Visual Studio und kann einfach auf die nötige Form gezogen werden. Er hilft beim Navigieren durch Tabellen und sieht so aus:

Grundsätzlich wird die Verbindung mit der Datenbank genau gleich hergestellt. Bloss wird die BindingSource direkt an den BindingNavigator über das BindingSource-Property gebunden:

bindingNavigator.BindingSource = bSource.Source;

BindingSource an Text- / Checkboxen

Sobald die BindingSource also mit dem BindingNavigator verknüpft ist, müssen die einzelnen Tabellen-Spalten an die Textboxen gehängt werden. Dazu wird folgendes verwendet:

textBox.DataBindings.Add(new Binding("Text", bindingNavigator.BindingSource,"Spaltenname"));

Der 1. Parameter definiert die Eigenschaft der TextBox, an welche die Spalte gebunden werden soll, welche logischerweise "Text" ist. Der 2. die BindingSource und der 3. den Spaltennamen der BindingSource.

An eine Checkbox wird das ganze genau gleich gebunden:
checkBox.DataBindings.Add(new Binding("Checked", bindingNavigator.BindingSource, "Spaltenname"));

Speichern der Änderungen

Das speichern funktioniert wieder genau gleich. Es wird einfach nur
dAdapter.Update(dTable);
ausgeführt und schon ist die Tabelle gespeichert.
Was ich noch nie geschrieben habe ist, dass vor dem Speichern noch der Befehl:
bSource.EndEdit();
aufgerufen werden sollte, damit auch wirklich alle Änderungen in den Textboxen bzw. bei Datagridviews in den Zellen übernommen werden.
Hier zu beachten sind ebenfalls wieder die Error-Handlings, welche in diesem Blogeintrag vom Januar 2012 beschrieben sind.

Kombination aus Datagridview und Textboxen

Es ist ebenfalls möglich eine Kombination aus Datagridview und Textboxen zu verwenden, wobei das Datagridview bloss als Navigation durch die Tabelle und die Textboxen als Bearbeitungs-Felder dienen.
Der Vorteil, gegenüber dem BindingNavigator ist natürlich, dass man mit dem Datagridview eine viel bessere Übersicht hat und den gesuchten Datensatz viel schneller findet.
Dazu wird die BindingSource wie bereits beschrieben an das Datagridview gebunden.
Anschliessend werden die einzelnen Zellen direkt an die Textboxen gebunden.
Das wird am besten im RowEnter-Event des Datagridviews gemacht:
textBox.DataBindings.Add(new Binding("Text", Datagridview[Spaltenindex, Zeilenindex], "Value");
Der Spaltenindex ist klar, der Zeilenindex wird am besten über Datagridview.SelectedRows[0].Index genommen.

Wichtig ist das bei jedem Zeilenwechsel bzw. vor jeder erneuten Bindung, die alte Bindung gelöscht wird. Dazu wird folgender Befehl verwendet:
textbox.DataBindings.Clear();

Januar 2012 / C# AccessDB auf DataGridView Teil 2

Zugriff auf Access-DB mit C#

Zu diesem Thema habe ich bereits vor einigen Monaten im August 2011 einen Blogeintrag verfasst. In diesem Eintrag findet man die Anleitung, um eine Tabelle aus einer Access-Datenbank zu holen, und wieder zu speichern.

Falsche Daten abfangen
Sobald nun eine Verbindung zur Datenbank besteht, und mind. ein DataGridView mit einer Tabelle verbunden ist, sollte man die eingegebenen Daten überprüfen.
Gibt man nämlich in ein Feld, in welches nur Zahlen geschrieben werden sollten Buchstaben ein, so wird das DataError-Event ausgelöst.

Eine ziemlich einfache Lösung wäre z.B. bloss folgende Zeile einzufügen:
MessageBox.Show("Fehlerhafte Dateneingabe!");
So wird dem Benutzer, bei einer Falscheingabe mitgeteilt, dass er einen Fehler gemacht hat und er kann das Feld nicht verlassen, bis die eingegebenen Daten das korrekte Format haben.

Es gibt natürlich noch andere Möglichkeiten, auf dieses Event zu reagieren, aber ich denke es ist schon mal nicht schlecht.

ID eines neuen Datensatzes
Da die ID normalerweise von der Datenbank selbst generiert wird und sie im DataGridView, so hoffe ich zumindest, nicht angezeigt wird, fällt einem dieses Problem zuerst gar nicht wirklich auf.
Hier noch der Code um eine Spalte auszublenden:

DataGridView.Columns["Spaltenname"].Visible = false;

Das Problem ist, dass in der Datenbank zwar eine ID vorhanden ist, das DataGridView diese jedoch nicht eingetragen hat bzw. diese gar nicht kennt. Wenn also ein neuer Datensatz erstellt wird, dieser mit Update() in die Datenbank gespeichert wurde und der Benutzer anschliessend diesen Datensatz erneut bearbeiten & speichern möchte, wird eine Exception ausgegeben, da der Datensatz keine ID hat.
Um das zu verhindern, muss man die ID von der Datenbank holen.

Dazu muss man unsere Verbindung ein kleines bisschen umbauen:
Anstatt wie im anderen Blog-Eintrag angegeben den DataAdapter direkt mit dem Abfrage und dem Connecting-string(strConnect) zu instanziieren, wird zuerst eine Connection mit dem Connecting-string erstellt und der DataAdapter dann mit der Connection instanziiert:
Aus:

OleDbDataAdapter dAdapter = new OleDbDataAdapter(strAbfrage, strConnect); dAdapter = new OleDbDataAdapter(strAbfrage, strConnect);

wird also:

OleDbConnection dbConnection = new OleDbConnection(strConnect);
dbConnection.Open();
OleDbDataAdapter dAdapter = new OleDbDataAdapter(strAbfrage, dbConnection);

Das macht für die Verbindung nun eigentlich keinen wirklich grossen Unterschied, aber um das Problem zu beheben, muss eine Connection verwendet werden.

Jetzt muss in derselben Methode, in der Sie die Verbindung aufbauen, folgende Zeile eingefügt werden:

dAdapter.RowUpdated += new OleDbRowUpdatedEventHandler(dAdapter_RowUpdated);

Das fügt einen OleDbRowUpdatedEventHandler hinzu, was so viel heisst wie: wir können nun das RowUpdated-Event abfangen.
Wir erstellen also folgende Prozedur:

private void dAdapter_RowUpdated (object sender, OleDbRowUpdatedEventArgs e)
{
    if (e.StatementType == StatementType.Insert)
    {
        OleDbCommand cmdNewID = new OleDbCommand("SELECT @@IDENTITY", dbConnection);
        e.Row[idColumn] = (int) cmdNewID.ExecuteScalar();
    }
}

Hier wird also zuerst abgefragt, ob es sich um ein Insert-Statement handelt.
Wenn das Zutrifft, wird die ID in die Zelle im Datagridview geschrieben, wobei e das Datagridview und idColumn den Namen oder den Index der Spalte darstellt.
Problem gelöst.

Exeption bei Checkboxen Es kam vor, dass wenn ich wahllos auf den Checkboxen herumgedrückt habe, ich irgendwann eine Exception bekam. Ich fand heraus, dass es genau bei folgendem Vorgang stattfand:
Sobald ich einen neuen Datensatz erstellt und anschliessend, nachdem ich den Datensatz bereits gespeichert hatte, eine Checkbox gesetzt habe.

Der Grund dafür ist, dass die Datenbank automatisch alle Werte der nicht gesetzten Checkboxen als false speichert, was auch richtig ist. Das DataGridView hingegen, speichert den Wert dieser Checkboxen als null ab. Beim Speichern eines Datensatzes überprüft der DataAdapter immer, ob die aktuellen Daten in der Datenbank und die beim letzten Mal gelesenen bzw. gespeicherten Daten übereinstimmen.
Da die Datenbank nun überall false, das geholte DataTable jedoch überall null gespeichert hat, wird eine Exception ausgegeben.

Die Lösung dieses Problems ist es, im DefaulValuesNeeded-Event des DataGridViews alle null-Werte in bool-Zellen, also Checkboxen, auf false zu ändern.
Hier ein Teil meiner Methode:

for (int i = 0; i < dgv.Columns.Count; i++)
{
    if (dgv.SelectedCells[0].OwningRow.Cells[i].ValueType == typeof(Boolean) && dgv.SelectedCells[0].OwningRow.Cells[i].Value == null)
    {
        dgv.SelectedCells[0].OwningRow.Cells[i].Value = false;
    }
}

dgv repräsentiert hier das DataGridView.