Exemplarische Vorgehensweise: Erstellen einer verteilten Anwendung mit Hilfe von Visual J#

Artikel
04/01/2008

Im Folgenden wird exemplarisch Schritt für Schritt die Erstellung einer mehrschichtigen, verteilten Anwendung beschrieben. Die Anwendung soll aus drei logischen Ebenen bestehen: Daten, Geschäftsobjekt und Benutzeroberfläche. Die Datenebene stellt eine SQL Server-Datenbank dar. Auf der Geschäftsobjektebene wird der Zugriff auf die Daten und die Verteilung der Daten zu den Clients realisiert. Die Ebene der Benutzeroberfläche besteht aus einer webbasierten Anwendung und aus einer herkömmlichen Windows-Anwendung. In der folgenden Abbildung wird die Architektur der Anwendung dargestellt.

Architektur der verteilten Anwendung

Die zu erstellende Anwendung ist eine einfache Datenanwendung mit Such- und Bearbeitungsfunktion. Es werden sowohl Windows- als auch webbasierte Clients erstellt, um die Tabelle authors aus der SQL Server-Beispieldatenbank Pubs anzuzeigen. Der Webclient besteht aus einer Webseite, die mit dem Web Forms-Designer erstellt wird und mit einem HTML 3.2-Standardbrowser kompatibel ist. Auf dem Server wird durch den Web Forms-Code ein XML-Webdienst aufgerufen, mit dem aus der Datenbank Informationen über Autoren abgerufen werden. Der Windows-Client besteht aus einer Windows-Anwendung, über die eine Kommunikation mit dem gleichen XML-Webdienst aufgebaut wird, um einen Datensatz mit Informationen zu Autoren abzurufen. Die Kommunikation mit dem XML-Webdienst wird mit HTTP und XML realisiert.

Systemanforderungen

Für die Durchführung dieser exemplarischen Vorgehensweise benötigen Sie Folgendes:

Zugriff auf einen Server mit der SQL Server-Beispieldatenbank Pubs, konfiguriert für Integrierte Windows-Authentifizierung. Die Datenbank Pubs ist eine der Beispieldatenbanken, die mit SQL Server installiert werden können.
Ein grundlegendes Verständnis der Behandlung von Daten in Visual Studio .NET. Weitere Informationen finden Sie unter Einführung in den Datenzugriff mit ADO.NET.

Erstellen einer verteilten Anwendung

Eine der möglichen Vorgehensweisen bei der Entwicklung verteilter Anwendungen besteht darin, die Ebenen nach und nach zu erstellen. Dabei wird mit der Datenebene begonnen, danach folgt die Erstellung des Geschäftsobjekts der mittleren Ebene. Abschließend wird die Benutzeroberfläche erstellt. Die Daten für diese exemplarische Vorgehensweise wurden bereits generiert und stehen in der SQL Server-Datenbank Pubs zur Verfügung. Daher wird hier als Erstes das Geschäftsobjekt – der XML-Webdienst – erstellt. Anschließend werden die beiden Benutzeroberflächen – eine Web Forms-Seite und ein Windows Form – realisiert.

Bei dieser exemplarischen Vorgehensweise werden folgende Schritte ausgeführt:

Erstellen von Geschäftsobjekten mittlerer Ebene
1. Erstellen eines ASP.NET-Webdienstprojekts
2. Erstellen und Konfigurieren einer Datenbankverbindung und eines DataSet-Schemas
3. DataSet vom Geschäftsobjekt aus zur Verfügung stellen
Erstellen der Benutzeroberfläche
1. Erstellen einer Windows-Benutzeroberfläche
2. Erstellen einer Webbenutzeroberfläche
Weitergabe der Projektmappe

Erstellen von Geschäftsobjekten mittlerer Ebene

Das Geschäftsobjekt wird auf einem Webserver ausgeführt. Das sichert die für verteilte Anwendungen erforderliche hohe Leistungsfähigkeit und Skalierbarkeit. Zusätzlich wird das Geschäftsobjekt als XML-Webdienst implementiert. Dadurch können für die Kommunikation zwischen Clients unterschiedlicher Plattformen und dem Geschäftsobjekt Internetstandardprotokolle verwendet werden. Weitere Informationen finden Sie unter Webprogrammierung mit XML-Webdiensten.

In dieser exemplarischen Vorgehensweise werden durch die XML-Webdienstkomponente die Datenverbindungen und die Definition des DataSets zur Verfügung gestellt. Anschließend werden XML-Webdienstmethoden hinzugefügt, die den Zugriff und die Veränderung des DataSets durch andere Anwendungen ermöglichen.

Die ASP.NET-Webdienstvorlage ist ein webbasiertes Projekt, das speziell für die Erstellung von Komponenten der mittleren Ebene entwickelt wurde, deren Schnittstellen als XML-Webdienste verwendet werden. Weitere Informationen finden Sie unter ASP.NET-Webdienstprojekte in Visual Studio.

Durch den XML-Webdienst werden zwei Methoden bereitgestellt. Mit der ersten Methode, GetAuthors, wird von der Datenbank ein DataSet zurückgegeben. Mit der zweiten Methode, UpdateAuthors, wird die Datenbank entsprechend den Änderungen der Benutzer aktualisiert. Um diese Methoden zu implementieren, werden verschiedene private Member erstellt. Sie enthalten:

Eine Instanz eines Datasets
Einen Datenadapter
Eine Datenverbindung
Mehrere Befehlsobjekte zum Abrufen von Daten von und Senden von Updates an die Datenbank

Im folgenden Schema wird der XML-Webdienst dargestellt.

Die mittlere Ebene einer verteilten Anwendung

So erstellen Sie ein ASP.NET-Webdienstprojekt

Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt, um das Dialogfeld Neues Projekt zu öffnen.
Wählen Sie im Bereich Projekttypen die Option Visual J#-Projekte aus, und wählen Sie anschließend im Bereich Vorlagen die Option ASP.NET-Webdienst aus.
Geben Sie im Feld Speicherort die Bezeichnung des Webservers mit dem Namen des Projekts, http://Servername/AuthorsWebService, ein. Klicken Sie anschließend auf OK.

Tipp Falls sich der Webserver auf Ihrem Computer befindet, können Sie als Servername LOCALHOST verwenden.

Tipp Bei Problemen mit der Erstellung des ASP.NET-Webdienstprojekts finden Sie weitere Informationen unter Dialogfeld "Webzugriffsfehler".
Das Projekt AuthorsWebService wird zur Projektmappe hinzugefügt. In der Entwicklungsumgebung wird der Komponenten-Designer für Service1.asmx angezeigt.
Wählen Sie durch Doppelklicken im Projektmappen-Explorer Service1.asmx aus.
Legen Sie im Eigenschaftenfenster AuthorsService für die Name-Eigenschaft von Service1 fest.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei Service1.asmx, wählen Sie Umbenennen aus, und geben Sie der Datei den Namen AuthorsService.asmx, damit dieser dem Dienstnamen entspricht.

In dieser Komponente wird eine Verbindung zum Datenspeicher aufgebaut und eine Instanz von Daten durch ein DataSet bereitgestellt.

Erstellen und Konfigurieren einer Datenbankverbindung und eines DataSet-Schemas

Es werden zwei Objekte zum XML-Webdienst hinzugefügt: ein SqlDataAdapter-Objekt und ein SqlConnection-Objekt. Durch das Verbindungsobjekt wird eine neue Verbindung zur Datenbank erstellt. Der Datenadapter wird für Abfragen an die Datenbank und für die Übergabe der Ergebnisse an ein DataSet-Objekt verwendet. Außerdem werden durch den Datenadapter die von den Benutzern am DataSet vorgenommenen Veränderungen in die Datenbank eingetragen. Mit einem Datenadapter wird eine Instanz für die in der Datenbank vorliegenden Informationen bereitgestellt. Das DataSet-Objekt wird weiter unten in der exemplarischen Vorgehensweise für die Anzeige von Daten im Windows Form und der Web Forms-Seite verwendet. Eine Übersicht finden Sie unter Einführung in verteilte Anwendungen und Datenintegration.

So erstellen Sie die Datenbankverbindung und den Datenadapter

Klicken Sie auf Server-Explorer.

Hinweis Der Server-Explorer wird standardmäßig als vertikale Registerkarte auf der linken Seite der Entwicklungsumgebung angezeigt. Falls der Server-Explorer nicht angezeigt wird, klicken Sie im Menü Ansicht auf Server-Explorer.
Klicken Sie im Server-Explorer mit der rechten Maustaste auf den Knoten Datenverbindungen, und wählen Sie dann im Kontextmenü Verbindung hinzufügen aus.
Geben Sie im Dialogfeld Datenverknüpfungseigenschaften auf der Registerkarte Verbindung den Namen des SQL Servers ein, auf dem die Datenbank Pubs installiert ist. Geben Sie (local) ein, wenn der SQL Server auf dem lokalen Computer installiert ist.
Wählen Sie als Anmeldeinformationen Windows NT Integrated Security verwenden aus.

Hinweis Wenden Sie sich an den Netzwerkadministrator, wenn auf Ihrem System die integrierte Sicherheit nicht eingerichtet wurde.
Wählen Sie aus der Liste die Datenbank Pubs aus.
Klicken Sie auf Verbindung testen, um die bereitgestellten Informationen zu prüfen. Klicken Sie danach auf OK, um die Verbindung herzustellen.

Im Knoten Datenverbindungen des Server-Explorers wird ein neuer Knoten angezeigt.

Hinweis Wenn der Verbindungsaufbau fehlschlägt, müssen Sie sich an den Datenbankadministrator wenden.
Erweitern Sie im Server-Explorer den Knoten für die neue Verbindung, und erweitern Sie dann den Knoten Tabellen.
Lokalisieren Sie den Knoten authors, und erweitern Sie ihn, um die Felder in der Tabelle authors anzuzeigen.
Wählen Sie die Felder au_id, au_lname, au_fnameu und city aus, indem Sie die STRG-TASTE drücken und auf die einzelnen Felder klicken.
Ziehen Sie die Felder aus dem Server-Explorer auf die Entwurfsoberfläche. Im Designer wird ein SqlConnection-Objekt zusammen mit einem SqlDataAdapter-Objekt angezeigt. Damit ist die Verbindung zur Datenbank hergestellt. Für den Informationsaustausch steht das SqlDataAdapter-Objekt bereit. Diese Komponenten sind so konfiguriert, dass über sie mit der Tabelle authors verknüpfte Daten von und zur Datenbank bewegt werden können.

Hinweis In dieser exemplarischen Vorgehensweise wird das SqlDataAdapter-Objekt verwendet, das für SQL Server 7.0 oder höher optimiert ist. Sie können aber auch das OleDbDataAdapter-Objekt verwenden, der generischer ist und einen ADO.NET-Zugriff auf alle OLE DB-kompatiblen Datenquellen bietet. Wenn Sie eine Verbindung zu einer Datenbank aufbauen, die keine SQL Server-Datenbank ist, wird durch das Projektsystem automatisch ein OleDbDataAdapter-Objekt und ein OleDbConnection-Objekt erstellt.

Hinweis In dieser exemplarischen Vorgehensweise wird das DataSet mit einigen Spalten und allen Zeilen der Tabelle authors gefüllt. In Produktionsanwendungen optimieren Sie den Datenzugriff in der Regel dadurch, dass Sie eine Abfrage erstellen, die nur die erforderlichen Spalten und Zeilen zurückgibt. Ein Beispiel finden Sie unter Exemplarische Vorgehensweise: Anzeigen von Daten in Windows Forms mit Hilfe von parametrisierten Abfragen unter Verwendung von Visual J#.

Um integrierte Sicherheit verwenden zu können, müssen Sie die Sicherheitseinstellungen Ihres Projekts konfigurieren. Dazu deaktivieren Sie den anonymen Zugriff und aktivieren den Identitätswechsel. Weitere Informationen finden Sie unter Sicherheitsmodell.

So konfigurieren Sie die integrierte Windows-Authentifizierung

Um für das Projekt Integrierte Windows-Authentifizierung zu konfigurieren, müssen Sie die Projektdateien ändern und das Projekt konfigurieren. Dazu verwenden Sie das Tool Internet-Informationsdienste.

Starten Sie das Tool Internet-Informationsdienste. Die Ausführung erfolgt in der Systemsteuerung unter Verwaltung. (Weitere Informationen zum Starten dieses Tools finden Sie in der Windows-Hilfe.)
Erweitern Sie den Knoten für den Server.
Erweitern Sie den Knoten Standardwebsite.
Klicken Sie mit der rechten Maustaste auf den Knoten für AuthorsWebService, und wählen Sie im Kontextmenü die Option Eigenschaften aus.
Klicken Sie auf die Registerkarte Verzeichnissicherheit.
Klicken Sie im Abschnitt Steuerung des anonymen Zugriffs und der Authentifizierung auf die Schaltfläche Bearbeiten.
Deaktivieren Sie das Kontrollkästchen Anonyme Anmeldung.
Aktivieren Sie das Kontrollkästchen Integrierte Windows-Authentifizierung. Sie haben nun das Verzeichnis für den XML-Webdienst konfiguriert.
Doppelklicken Sie im Projektmappen-Explorer auf die Datei Web.config, um zu dem Projekt in Visual Studio zu wechseln.
Fügen Sie den nachfolgend aufgeführten Tag auf der Zeile nach dem Tag <system.web> ein, um für den XML-Webdienst integrierte Sicherheit zu konfigurieren.
```
<identity impersonate="true"/>
```

So erstellen Sie die Definition einer DataSet-Klasse

Doppelklicken Sie im Projektmappen-Explorer auf die Datei AuthorsService, um sie im Designer zu öffnen.
Wählen Sie im Menü Daten die Option DataSet generieren. Wählen Sie im Dialogfeld DataSet generieren die Option Neu, und geben Sie dem DataSet die Bezeichnung "authors1". Aktivieren Sie nicht das Kontrollkästchen DataSet zu Designer hinzufügen.

Hinweis Eine DataSet-Schemadatei, authors1.xsd, wird erstellt und zum Projekt hinzugefügt. Diese Schemadatei enthält eine Klassendefinition für authors1. Die Klasse erbt von der DataSet-Klasse und enthält eine typisierte DataSet-Definition für die Tabelle authors.
Wählen Sie im Menü Datei die Option Alle speichern.

DataSet "authors1" vom Geschäftsobjekt aus zur Verfügung stellen

Im nächsten Schritt dieser exemplarischen Vorgehensweise wird das soeben erstellte DataSet-Objekt veröffentlicht. Dadurch steht das DataSet für Windows- und Webanwendungen zur Verfügung.

So fügen Sie eine Methode zum XML-Webdienst hinzu

Doppelklicken Sie im Projektmappen-Explorer auf AuthorsService, falls dieser Dienst im Designer noch nicht geöffnet ist.
Klicken Sie im Menü Ansicht auf Code.
Fügen Sie die Methode mit der Bezeichnung GetAuthors hinzu, mit der einem Client ein DataSet zur Verfügung gestellt wird.

Durch diese, unten dargestellte, Methode wird ein neues DataSet authors1 erstellt und mit Hilfe des SqlDataAdapter-Objekts mit Daten aus der Tabelle authors gefüllt. Als Rückgabewert wird durch die Methode das DataSet bereitgestellt.
```
// Visual J#
/** @attribute WebMethod() */
public authors1 GetAuthors() 
{
   authors1 authors = new authors1();
   sqlDataAdapter1.Fill(authors);
   sqlConnection1.Close();
   return authors;
}
```
Fügen Sie eine Methode mit der Bezeichnung UpdateAuthors hinzu, mit der Änderungen des Clients an die Datenbank weitergegeben werden.

Die unten dargestellte Methode verfügt über einen Parameter (authorChanges) vom Typ authors1-DataSet, der die geänderten Daten enthält und mit der Methode SqlDataAdapter.Update die Datenbank aktualisiert. Die Update-Methode übernimmt die Änderungen des DataSets. Das DataSet wird an den Client zurückgegeben. Vom Client wird das zurückgegebene DataSet zur Aktualisierung seiner eigenen Instanz des authors1-DataSets verwendet. Weitere Informationen zur Update-Methode und zur Übernahme von Änderungen in einem DataSet finden Sie unter Einführung in Datenadapter.
```
// Visual J#
/** @attribute WebMethod() */
public authors1 UpdateAuthors(authors1 authorChanges)
{
   if (authorChanges != null)
   {
      sqlDataAdapter1.Update(authorChanges);
      sqlConnection1.Close();
      return authorChanges;
   }
   else
   {
      return null;
   }
}
```
Hinweis In Produktionsanwendungen wird diesen Methoden eine Fehlerprüfung und Ausnahmebehandlung hinzugefügt.
Wählen Sie im Menü Datei die Option Alle speichern.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen.
Geben Sie den XML-Webdienst weiter, so dass der Clientanwendung zugehörige Webverweise zur Verfügung stehen. Weitere Informationen finden Sie im Abschnitt "Weitergeben eines XML-Webdienstes" unter Exemplarische Vorgehensweise: Erstellen eines XML-Webdienstes mit Hilfe von Visual J#.

Im vorherigen Abschnitt haben Sie ein Geschäftsobjekt der mittleren Ebene erstellt, das ein an eine SQL Server-Datenbank gebundenes DataSet verwendet. Sie haben zum XML-Webdienst AuthorsWebService der mittleren Ebene Code hinzugefügt, um Daten von einer Datenquelle zu erhalten und die Datenquelle bei Änderungen zu aktualisieren. Der Client greift über die XML-Webdienstmethoden GetAuthors und UpdateAuthors auf diese Funktionen zu.

Erstellen der Benutzeroberfläche

Nachdem ein Geschäftsobjekt mittlerer Ebene für den Datenzugriff erstellt und als XML-Webdienst bereitgestellt wurde, wird im nächsten Schritt die Clientschnittstelle erstellt. In dieser exemplarischen Vorgehensweise werden zwei Verfahren umgesetzt: ein herkömmliches Windows Form und eine Web Forms-Seite. Beide werden in diesem Beispiel als separate Projekte in der gleichen Projektmappe erstellt.

Option einer Windows-Benutzeroberfläche

Durch eine Windows-Benutzeroberfläche werden die Möglichkeiten der Clientcomputer ausgenutzt, Teile der Anwendung selbst auszuführen. Im Allgemeinen bietet eine Windows-Oberfläche umfangreichere Funktionalität und höhere Benutzerfreundlichkeit als eine webbasierte Benutzeroberfläche. Da durch den Server nicht die gesamte Anwendungslogik ausgeführt werden muss, gibt es auf dem Server weniger Last als bei einem Web-Front-End. Außerdem kann eine Windows-Oberfläche die Ressourcen des Betriebssystems verwenden, einschließlich des Dateisystems und der Registrierung.

Im folgenden Schema ist der zu implementierende Client hervorgehoben.

Windows-Client in einer verteilten Anwendung

Die Windows-Anwendung besteht aus einem Windows Form und enthält einen Webverweis zu AuthorsWebService. Wenn auf eine Schaltfläche zum Laden geklickt wird, werden die Daten der Datenbank in einem DataGrid-Steuerelement angezeigt. Für den Ladevorgang wird die GetAuthors-Methode des XML-Webdienstes aufgerufen. Änderungen lassen sich direkt im DataGrid-Steuerelement vornehmen und werden sofort an das darunter liegende DataSet weitergegeben. Das Formular enthält außerdem eine Schaltfläche zum Speichern. Der Code dieser Schaltfläche ruft die UpdateAuthors-Methode des XML-Webdienstes auf, durch die die Änderungen in die Datenbank eingetragen werden.

So erstellen Sie die Windows-Anwendung

Zeigen Sie im Menü Datei auf Projekt hinzufügen, und klicken Sie auf Neues Projekt, um das Dialogfeld Neues Projekt hinzufügen zu öffnen.
Wählen Sie im Bereich Projekttypen die Option Visual J#-Projekte aus, und wählen Sie anschließend im Bereich Vorlagen die Option Windows-Anwendung aus.
Geben Sie dem Projekt die Bezeichnung AuthorsWinClient, und wählen Sie einen Speicherort für das Projekt aus.

Das Projekt AuthorsWinClient wird zur Projektmappe hinzugefügt. Form1 wird automatisch zum Projekt hinzugefügt und im Windows Forms-Designer angezeigt.
Fügen Sie zum vorher erstellten ASP.NET-Webdienstprojekt einen Webverweis hinzu:
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt AuthorsWinClient, und klicken Sie anschließend im Kontextmenü auf Webverweis hinzufügen.
2. Geben Sie am oberen Rand des Dialogfelds Webverweis hinzufügen im Feld Adresse den Speicherort der ASMX-Datei des XML-Webdienstprojekts (http://Servername/AuthorsWebService/AuthorsWebService.asmx) ein, und drücken Sie die EINGABETASTE. Falls Sie Probleme beim Hinzufügen des Webverweises haben, finden Sie weitere Informationen unter Dialogfeld "Webverweis hinzufügen" und Hinzufügen und Entfernen von Webverweisen.
3. Klicken Sie auf Verweis hinzufügen.
4. Sie können jetzt in der Anwendung eine Instanz des DataSets authors1 erstellen.

So fügen Sie dem Formular Steuerelemente hinzu

Ziehen Sie ein DataGrid-Steuerelement von der Registerkarte Windows Forms der Toolbox in das Formular.
Ziehen Sie ein Button-Steuerelement von der Registerkarte Windows Forms der Toolbox in das Formular. Setzen Sie die Name-Eigenschaft der Schaltfläche auf LoadData und die Text-Eigenschaft auf Load.
Ziehen Sie ein weiteres Button-Steuerelement von der Registerkarte Windows Forms der Toolbox in das Formular. Setzen Sie die Name-Eigenschaft der Schaltfläche auf SaveData und die Text-Eigenschaft auf Save.
Ziehen Sie ein DataSet-Objekt von der Registerkarte Daten der Toolbox in das Formular. Das Dialogfeld DataSet hinzufügen wird angezeigt. Wählen Sie Typisiertes DataSet und aus der Liste Name "AuthorsWinClient.Servername.authors1" aus. Mit diesem Vorgang wird im Komponentenfach ein DataSet-Objekt erstellt, das auf der Klassendefinition des DataSets authors1 basiert.
Markieren Sie das DataSet-Steuerelement, und geben Sie als Name-Eigenschaft AuthorData ein.
Markieren Sie das DataGrid-Steuerelement, und wählen Sie aus der Liste DataSource-Eigenschaft AuthorData aus. Wählen Sie authors aus der Liste DataMember-Eigenschaft. Die Spaltenüberschriften des DataGrid erhalten die Spaltennamen der Tabelle authors.

So fügen Sie Code für die Schaltflächen "LoadData" und "SaveData" hinzu

Klicken Sie im Menü Ansicht auf Designer. Doppelklicken Sie auf die Schaltfläche LoadData, um eine Ereignisbehandlungsmethode für das Click-Ereignis zu erstellen. XML-Webdienstmethoden kommen zum Einsatz, indem zuerst eine Instanz der Dienstklasse erstellt wird und danach die Dienstmethoden aufgerufen werden. In diesem Fall wird die GetAuthors-Methode aufgerufen. Das zurückgegebene DataSet wird mit dem DataSet AuthorData zusammengeführt. Mit Hilfe der Credentials-Eigenschaft des XML-Webdienstes wird Ihre Identität an den XML-Webdienst weitergegeben, der diese wiederum an den Datenbankserver weitergibt. Fügen Sie den nachfolgenden Code zur Methode hinzu.

Wenn der XML-Webdienst nicht auf dem lokalen Computer ausgeführt wird, müssen Sie im Codebeispiel localhost durch den Namen des entsprechenden Servers ersetzen, auf dem der XML-Webdienst ausgeführt wird.
```
// Visual J#
private void LoadData_Click (Object sender, System.EventArgs e)
{
   localhost.AuthorsService ws =new localhost.AuthorsService();
   ws.set_Credentials(System.Net.CredentialCache.get_DefaultCredentials());
   AuthorData.Merge(ws.GetAuthors());
}
```
Klicken Sie im Menü Ansicht auf Designer. Doppelklicken Sie auf die Schaltfläche SaveData, um eine Ereignisbehandlungsmethode für das Click-Ereignis zu erstellen.

Wurden im DataSet Änderungen vorgenommen, wird für die geänderten Daten ein neues DataSet vom Typ authors1 erstellt. Dieses DataSet wird anschließend der UpdateAuthors-Methode des XML-Webdienstes übergeben. Nach der Übernahme der Änderungen wird das DataSet zurückgegeben. Danach wird auch das DataSet AuthorData entsprechend aktualisiert. Weitere Informationen zur Übernahme von Änderungen in ein DataSet finden Sie unter Einführung in Datenadapter.

Hinweis In Produktionsanwendungen ist in diesem Schritt eine Berücksichtigung von Parallelitätsaspekten angebracht. Weitere Informationen finden Sie unter Einführung in die Datenparallelität in ADO.NET.

Fügen Sie der Methode folgenden Code hinzu:
```
// Visual J#
private void SaveData_Click (Object sender, System.EventArgs e)
{
   if (AuthorData.HasChanges())
   {
      localhost.AuthorsService ws = new localhost.AuthorsService();
      ws.set_Credentials(System.Net.CredentialCache.get_DefaultCredentials());
      localhost.authors1 diffAuthors = new localhost.authors1();
      diffAuthors.Merge(AuthorData.GetChanges());
      diffAuthors = ws.UpdateAuthors(diffAuthors);
      AuthorData.Merge(diffAuthors);
   }
}
```

So führen Sie die Anwendung aus

Wählen Sie im Menü Datei die Option Alle speichern.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt AuthorsWinClient, und wählen Sie Als Startprojekt festlegen.
Drücken Sie STRG+F5, um die Anwendung auszuführen.

Es wird ein Fenster angezeigt, das eine leeren Tabelle mit den Spaltenüberschriften der Tabelle authors aus der Datenbank Pubs enthält.
Klicken Sie auf Laden, um die Tabelle zu füllen. Führen Sie einige Änderungen durch, und klicken Sie auf Speichern, um die Änderungen zu speichern.

Im vorherigen Abschnitt haben Sie ein Windows Forms-Projekt, das als Windows-Oberfläche verwendet wird, zur Projektmappe hinzugefügt. Sie haben das Windows Form mit dem XML-Webdienst, den Sie im ersten Abschnitt erstellt hatten, verbunden und mit Hilfe des DataGrid-Steuerelements und des Button-Steuerelements die Benutzeroberfläche zum Laden und Aktualisieren von Daten erstellt. Im nächsten Abschnitt erstellen Sie für die Projektmappe eine webbasierte Benutzeroberfläche.

Option einer Webbenutzeroberfläche

Durch eine Weboberfläche kann eine Anwendung auf Clientcomputern und mit Browsern unterschiedlichster Art ausgeführt werden. Die Verarbeitung aller Aktivitäten der Benutzeroberfläche erfolgt dabei durch den Webserver statt durch den Client. Mit einer Web Forms-Seite wird eine Weboberfläche erstellt, mit der auf das gleiche Geschäftsobjekt mittlerer Ebene zugegriffen wird, das auch durch die Windows-Oberfläche im vorherigen Abschnitt verwendet wurde. Im folgenden Schema ist der zu implementierende Client hervorgehoben.

Webclient in einer verteilten Anwendung

So erstellen Sie die Web Forms-Anwendung

Zeigen Sie im Menü Datei auf Projekt hinzufügen, und klicken Sie dann auf Neues Projekt.
Wählen Sie im Dialogfeld Neues Projekt hinzufügen aus dem Bereich Projekttypen den Eintrag Visual J#-Projekte. Klicken Sie anschließend im Bereich Vorlagen auf den Eintrag ASP.NET-Webanwendung.
Geben Sie im Feld Speicherort die Bezeichnung des Webservers mit dem Namen des Projekts, http://Servername/AuthorsWebClient, ein. Klicken Sie anschließend auf OK.

Ein neues Projekt wird zum Projektmappen-Explorer hinzufügt. Dem Projekt wird eine Web Forms-Seite WebForm1.aspx hinzugefügt und in den Designer geladen.
Fügen Sie zum vorher erstellten ASP.NET-Webdienstprojekt einen Webverweis hinzu:
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt AuthorsWebClient, und klicken Sie anschließend im Kontextmenü auf Webverweis hinzufügen.
2. Geben Sie am oberen Rand des Dialogfelds Webverweis hinzufügen im Feld Adresse den Speicherort der ASMX-Datei des XML-Webdienstprojekts (http://Servername/AuthorsWebService/AuthorsWebService.asmx) ein, und drücken Sie die EINGABETASTE.
3. Klicken Sie auf Verweis hinzufügen.
4. Sie können jetzt in der Anwendung eine Instanz des DataSets authors1 erstellen.

So fügen Sie Steuerelemente zur Webseite hinzu

Ziehen Sie ein DataSet-Objekt von der Registerkarte Daten der Toolbox in das Formular. Das Dialogfeld DataSet auswählen wird angezeigt. Wählen Sie Typisiertes DataSet und aus der Liste Name den Eintrag "AuthorsWebClient.Servername.authors1" aus. Zum Komponentenfach wird ein DataSet-Objekt hinzugefügt.
Markieren Sie das DataSet-Objekt, und geben Sie als Name-Eigenschaft AuthorData ein.
Ziehen Sie ein DataGrid-Steuerelement von der Registerkarte Web Forms der Toolbox in das Formular.
Setzen Sie im Fenster Eigenschaften des DataGrid-Steuerelements die DataSource-Eigenschaft auf AuthorData und die DataMember-Eigenschaft auf authors. Diese Einstellungen werden in der Dropdownliste des Steuerelements angezeigt. Die Spaltenüberschriften des DataGrid erhalten die Spaltennamen der Tabelle authors.
Fügen Sie zur Unterstützung der direkten Bearbeitung im DataGrid-Steuerelement eine Spalte zum Bearbeiten, Aktualisieren, Abbrechen mit einer Schaltfläche Bearbeiten hinzu. Wenn der Benutzer auf die Schaltfläche Bearbeiten klickt, wird der Inhalt der Zeile in Textfeldern angezeigt und die Schaltfläche Bearbeiten durch die Schaltflächen Aktualisieren und Abbrechen ersetzt. So fügen Sie diese Spalte hinzu:
1. Klicken Sie am unteren Rand des Fensters Eigenschaften auf den Link Eigenschaftengenerator, und wählen Sie danach im Dialogfeld die Registerkarte Spalten.
2. Erweitern Sie im Bereich Verfügbare Spalten das Element Schaltflächenspalte.
3. Wählen Sie Bearbeiten, Aktualisieren, Abbrechen, und klicken Sie auf die Schaltfläche ().
4. Klicken Sie auf OK.

So fügen Sie Code für die Schaltflächen "Bearbeiten", "Aktualisieren" und "Abbrechen" hinzu

Klicken Sie mit der rechten Maustaste auf das Formular, und wählen Sie Code anzeigen. Fügen Sie den unten angegebenen Code zum Page_Load-Ereignis hinzu, durch den das DataGrid-Steuerelement mit Daten gefüllt wird. Durch diesen Code wird eine Instanz des XML-Webdienstes erstellt, das AuthorData-DataSet gefüllt und das DataSet an das DataGrid-Steuerelement gebunden. Jede Seite, die eine Schleife zurück zum Benutzer unternimmt, enthält ein DataGrid mit der aktuellen Kopie der Daten aus der Datenbank. Mit Hilfe der Credentials-Eigenschaft des XML-Webdienstes wird Ihre Identität an den XML-Webdienst weitergegeben, der diese wiederum an den Datenbankserver weitergibt.

Hinweis In dieser exemplarischen Vorgehensweise wird bei jedem Dowloaden der Web Forms-Seite auf einen Clientbrowser eine neue Kopie der Tabelle authors von der Datenbank abgerufen. Dies kann dazu führen, dass die Anwendung keine optimale Leistung erbringt. Eine Erörterung anderer Methoden der Leistungsoptimierung finden Sie unter Empfehlungen zur Zugriffsstrategie auf Webdaten.
```
// Visual J#
private void Page_Load(Object sender, System.EventArgs e)
{
   localhost.AuthorsService ws = new localhost.AuthorsService();
   ws.set_Credentials(System.Net.CredentialCache.get_DefaultCredentials());
   AuthorData.Merge(ws.GetAuthors());
   if (! get_IsPostBack()) 
   {
      DataGrid1.DataBind();
   }
}
```
Wenn ein Benutzer auf die Schaltfläche Bearbeiten klickt, wird das EditCommand-Ereignis des DataGrid-Steuerelements ausgelöst. Verwenden Sie dieses Ereignis, um die EditItemIndex-Eigenschaft des DataGrid-Steuerelements zu ändern. Die durch die EditItemIndex-Eigenschaft angegebene Zeile wird im Textfeld mit allen Daten angezeigt.
1. Erstellen Sie einen Ereignishandler für das EditCommand-Ereignis.
  
  Bei Verwendung von Visual J# klicken Sie auf das DataGrid1-Steuerelement. Klicken Sie im Fenster Eigenschaften auf die Schaltfläche Ereignisse, um eine Liste möglicher DataGrid-Ereignisse zu erhalten. Doppelklicken Sie auf das EditCommand-Ereignis.
2. Fügen Sie den nachfolgenden Code hinzu.
```
// Visual J#
private void DataGrid1_EditCommand (Object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
{
   DataGrid1.set_EditItemIndex( e.get_Item().get_ItemIndex());
   DataGrid1.DataBind();
}
```
Erstellen Sie einen Ereignishandler für das CancelCommand-Ereignis. (Siehe Schritt 2 für das Hinzufügen von Ereignishandlern.)

Wenn der Benutzer auf die Schaltfläche Abbrechen klickt, wird das CancelCommand-Ereignis des DataGrid-Steuerelements ausgelöst. Verwenden Sie dieses Ereignis, um die EditItemIndex-Eigenschaft auf -1 zu setzen und damit die aktuelle Zeile wieder als Text anzuzeigen. Fügen Sie den nachfolgenden Code hinzu.
```
// Visual J#
private void DataGrid1_CancelCommand (Object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
{
   DataGrid1.set_EditItemIndex(-1);
   DataGrid1.DataBind();
}
```

Wenn ein Benutzer auf die Schaltfläche Aktualisieren klickt, wird das UpdateCommand-Ereignis des DataGrid-Steuerelements ausgelöst. Mit dieser Methode werden die Änderungen im DataGrid-Steuerelement an das DataSet AuthorData und über den XML-Webdienst an die Datenbank zurückgegeben. Erstellen Sie einen Ereignishandler für das UpdateCommand-Ereignis. (Siehe Schritt 2 für das Hinzufügen von Ereignishandlern.) Fügen Sie den nachfolgenden Code hinzu.

// Visual J#
private void DataGrid1_UpdateCommand (Object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
{
   // Change the data in the dataset.
   for (int i=1; i<AuthorData.get_authors().get_Columns().get_Count(); i++) 
   {
      TextBox t = (TextBox)((TableCell)(e.get_Item().get_Cells().get_Item(i))).get_Controls().get_Item(0);
      DataRow row = AuthorData.get_authors().get_Item(e.get_Item().get_DataSetIndex());
      row.set_Item(AuthorData.get_authors().get_Columns().get_Item(i-1).get_Caption(),t.get_Text());
   }

   // Update the database.
   if (AuthorData.HasChanges()) 
   {
      localhost.AuthorsService ws = new localhost.AuthorsService();
      ws.set_Credentials(System.Net.CredentialCache.get_DefaultCredentials());
      localhost.authors1 diffAuthors = new localhost.authors1();
      diffAuthors.Merge(AuthorData.GetChanges());
      ws.UpdateAuthors(diffAuthors);
      AuthorData.Merge(diffAuthors);
   }
   DataGrid1.set_EditItemIndex( -1);
   DataGrid1.DataBind();
}

So konfigurieren Sie die integrierte Windows-Authentifizierung

Starten Sie das Tool Internet-Informationsdienste. Die Ausführung erfolgt in der Systemsteuerung unter Verwaltung. (Weitere Informationen zum Starten dieses Tools finden Sie in der Windows-Hilfe.) Erweitern Sie den Knoten für den Server.
Erweitern Sie den Knoten Standardwebsite.
Klicken Sie mit der rechten Maustaste auf den Knoten für AuthorsWebClient, und wählen Sie im Kontextmenü die Option Eigenschaften aus.
Klicken Sie auf die Registerkarte Verzeichnissicherheit.
Klicken Sie im Abschnitt Steuerung des anonymen Zugriffs und der Authentifizierung auf die Schaltfläche Bearbeiten.
Deaktivieren Sie das Kontrollkästchen Anonyme Anmeldung.
Aktivieren Sie das Kontrollkästchen Integrierte Windows-Authentifizierung. Sie haben nun das Verzeichnis für den XML-Webdienst konfiguriert.
Doppelklicken Sie im Projektmappen-Explorer auf die Datei Web.config, um zu dem Projekt in Visual Studio zu wechseln.
Fügen Sie den nachfolgend aufgeführten Tag auf der Zeile nach dem Tag <system.web> ein, um für den XML-Webdienst integrierte Sicherheit zu konfigurieren.
```
<identity impersonate="true"/>
```

So führen Sie die Anwendung aus

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt AuthorsWebClient, und wählen Sie Als Startprojekt festlegen.
Drücken Sie STRG+F5, um die Anwendung auszuführen.

In diesem Abschnitt haben Sie zu einer Projektmappe ein ASP.NET-Webanwendungsprojekt hinzugefügt, das als Browserschnittstelle für Daten fungieren kann. Sie haben die Web Forms-Seite mit dem XML-Webdienst, den Sie im ersten Abschnitt erstellt hatten, verbunden und mit Hilfe eines DataGrid-Steuerelements die Benutzeroberfläche zum Anzeigen und Bearbeiten von Daten erstellt.

Weitergabe der Projektmappe

Im nächsten Schritt wird die Webanwendung an einen Server weitergegeben und ein Installationsprogramm für die Windows-Anwendung erstellt. Weitere Informationen zur Weitergabe einer Webanwendung finden Sie unter Exemplarische Vorgehensweise: Weitergeben einer Webprojektmappe. Weitere Informationen zur Weitergabe einer Webanwendung finden Sie unter Exemplarische Vorgehensweise: Weitergeben einer Windows-Anwendung.

Siehe auch

Webprogrammierung mit XML-Webdiensten | Web Forms-Seiten | Windows Forms | XML-Webdienste in verwaltetem Code | Einführung in verteilte Anwendungen und Datenintegration

Freigeben über