WCF - Kurzanleitung
WCF steht für Windows Communication Foundation. Das elementare Merkmal von WCF ist die Interoperabilität. Es ist eine der neuesten Technologien von Microsoft, mit der serviceorientierte Anwendungen erstellt werden. Basierend auf dem Konzept der nachrichtenbasierten Kommunikation, bei dem eine HTTP-Anforderung einheitlich dargestellt wird, ermöglicht WCF eine einheitliche API unabhängig von verschiedenen Transportmechanismen.
WCF wurde 2006 zum ersten Mal als Teil des .NET-Frameworks mit Windows Vista veröffentlicht und anschließend mehrmals aktualisiert. WCF 4.5 ist die neueste Version, die jetzt weit verbreitet ist.
Eine WCF-Anwendung besteht aus drei Komponenten:
- WCF-Dienst,
- WCF-Diensthost und
- WCF-Service-Client.
Die WCF-Plattform wird auch als Servicemodell bezeichnet.
Grundlegende Konzepte von WCF
Botschaft
Dies ist eine Kommunikationseinheit, die aus mehreren Teilen außer dem Körper besteht. Nachrichteninstanzen werden für alle Arten der Kommunikation zwischen dem Client und dem Dienst gesendet und empfangen.
Endpunkt
Es definiert die Adresse, an die eine Nachricht gesendet oder empfangen werden soll. Außerdem wird der Kommunikationsmechanismus angegeben, der beschreibt, wie die Nachrichten gesendet werden, und der Satz von Nachrichten definiert wird. Eine Struktur eines Endpunkts besteht aus den folgenden Teilen:
Adresse
Die Adresse gibt den genauen Ort für den Empfang der Nachrichten an und wird als URI (Uniform Resource Identifier) angegeben. Es wird ausgedrückt als Schema: // Domäne [: Port] / [Pfad]. Schauen Sie sich die unten angegebene Adresse an -
net.tcp: // localhost: 9000 / ServiceA
Hier ist 'net.tcp' das Schema für das TCP-Protokoll. Die Domäne ist 'localhost', was der Name eines Computers oder einer Webdomäne sein kann, und der Pfad ist 'ServiceA'.
Bindung
Es definiert die Art und Weise, wie ein Endpunkt kommuniziert. Es besteht aus einigen verbindlichen Elementen, die die Infrastruktur für die Kommunikation bilden. Beispielsweise gibt eine Bindung die für den Transport verwendeten Protokolle wie TCP, HTTP usw., das Format der Nachrichtenkodierung und die Protokolle in Bezug auf Sicherheit und Zuverlässigkeit an.
Verträge
Es handelt sich um eine Sammlung von Vorgängen, die angeben, welche Funktionen der Endpunkt dem Client zur Verfügung stellt. Es besteht im Allgemeinen aus einem Schnittstellennamen.
Hosting
Hosting aus Sicht von WCF bezieht sich auf das WCF-Service-Hosting, das über viele verfügbare Optionen wie Self-Hosting, IIS-Hosting und WAS-Hosting erfolgen kann.
Metadaten
Dies ist ein wichtiges Konzept von WCF, da es eine einfache Interaktion zwischen einer Clientanwendung und einem WCF-Dienst ermöglicht. Normalerweise werden Metadaten für einen WCF-Dienst automatisch generiert, wenn sie aktiviert sind. Dies erfolgt durch Überprüfung des Dienstes und seiner Endpunkte.
WCF-Client
Eine Clientanwendung, die zum Anzeigen der Dienstvorgänge in Form von Methoden erstellt wird, wird als WCF-Client bezeichnet. Dies kann von jeder Anwendung gehostet werden, auch von der, die Service-Hosting durchführt.
Kanal
Kanal ist ein Medium, über das ein Client mit einem Dienst kommuniziert. Verschiedene Arten von Kanälen werden gestapelt und als Channel Stacks bezeichnet.
SEIFE
Obwohl SOAP als "Simple Object Access Protocol" bezeichnet wird, ist es kein Transportprotokoll. Stattdessen handelt es sich um ein XML-Dokument, das aus einem Header und einem Body-Abschnitt besteht.
Vorteile von WCF
Es ist in Bezug auf andere Dienste interoperabel. Dies steht in scharfem Gegensatz zu .NET Remoting, bei dem sowohl der Client als auch der Dienst über .Net verfügen müssen.
WCF-Dienste bieten im Vergleich zu ASMX-Webdiensten (Active Server Methods) eine verbesserte Zuverlässigkeit und Sicherheit.
Die Implementierung des Sicherheitsmodells und die Bindungsänderung in WCF erfordern keine wesentliche Änderung der Codierung. Es sind nur wenige Konfigurationsänderungen erforderlich, um die Einschränkungen zu erfüllen.
WCF verfügt über einen integrierten Protokollierungsmechanismus, während bei anderen Technologien die erforderliche Codierung unbedingt erforderlich ist.
WCF hat AJAX integriert und unterstützt JSON (JavaScript-Objektnotation).
Es bietet Skalierbarkeit und Unterstützung für kommende Webdienststandards.
Es verfügt über einen Standardsicherheitsmechanismus, der äußerst robust ist.
Es gibt einige wesentliche Unterschiede zwischen WCF und einem Webdienst, die unten aufgeführt sind.
Attributes - Der WCF-Dienst wird durch die Attribute ServiceContract und OperationContract definiert, während ein Webdienst durch die Attribute WebService und WebMethod definiert wird.
Protocols - WCF unterstützt eine Reihe von Protokollen, z. B. HTTP, Named Pipes, TCP und MSMQ, während ein Webdienst nur das HTTP-Protokoll unterstützt.
Hosting Mechanisms - Für das WCF-Hosting gibt es verschiedene Aktivierungsmechanismen, z. B. IIS (Internetinformationsdienst), WAS (Windows-Aktivierungsdienst), Selbsthosting und Windows-Dienst. Ein Webdienst wird jedoch nur von IIS gehostet.
Services - WCF unterstützt eine robuste Sicherheit, vertrauenswürdiges Messaging, Transaktionen und Interoperabilität, während ein Webdienst nur Sicherheitsdienste unterstützt.
Serializer - WCF unterstützt den DataContract-Serializer mithilfe von System.Runtime.Serialization, während ein Webdienst den XML-Serializer mithilfe von System.Xml.Serialization unterstützt.
Tools - Das ServiceMetadata-Tool (svcutil.exe) wird für die Clientgenerierung für einen WCF-Dienst verwendet, während das WSDL.EXE-Tool für die Generierung desselben für einen Webdienst verwendet wird.
Exception Handling- In WCF werden nicht behandelte Ausnahmen mithilfe von FaultContract besser behandelt. Sie kehren nicht wie in einem Webdienst als SOAP-Fehler zum Client zurück.
Hash Table - Es ist möglich, eine Hash-Tabelle in WCF zu serialisieren, dies ist jedoch in einem Webdienst nicht der Fall.
Bindings - WCF unterstützt verschiedene Arten von Bindungen wie BasicHttpBinding, WSDualHttpBinding, WSHttpBinding usw., während ein Webdienst nur SOAP oder XML unterstützt.
Multithreading - WCF unterstützt Multithreading mithilfe der ServiceBehavior-Klasse, während dies in einem Webdienst nicht unterstützt wird.
Duplex Service Operations - WCF unterstützt Duplexdienstvorgänge, abgesehen von Einweg- und Anforderungsantwortdienstvorgängen, während ein Webdienst keine Duplexdienstvorgänge unterstützt.
Für die Entwicklung einer WCF-Dienstanwendung stehen hauptsächlich zwei Tools zur Verfügung - Microsoft Visual Studio und CodePlex. Microsoft Visual Studio ist ein vollständiges Paket von Entwicklungstools, die für die Entwicklung einer Vielzahl unterschiedlicher Anwendungen wie ASP.NET-Webanwendungen, Desktopanwendungen, Mobilanwendungen und vielem mehr erforderlich sind.
Microsoft Visual Studio verwendet die .NET Framework-Funktionalität. CodePlex hingegen ist eine Open-Source-Projekthosting-Site von Microsoft, die mehrere kostenlose Tools für die Entwicklung von WCF-Dienstanwendungen bietet.
Microsoft Visual Studio
Es gibt viele Editionen von Microsoft Visual Studio und anfangs war es (Visual Studio 2005) kein begeisterter Unterstützer der WCF-Entwicklung. Derzeit ist Visual Studio 2008 die einzige Microsoft IDE, die für die Entwicklung von WCF-Dienstanwendungen verfügbar ist.
Heutzutage ist die neueste Version von Microsoft Visual Studio 2010 auch ein bevorzugtes Tool für die Entwicklung von WCF-Dienstanwendungen. In Visual Studio gibt es auch eine vorgefertigte Vorlage zum Entwickeln der WCF-Dienstanwendung.
Die Auswahl einer solchen Vorlage führt zum Hinzufügen von Dateien für die folgenden Zwecke:
- Servicevertrag
- Service-Implementierung
- Dienst-Konfiguration
Erforderliche Attribute werden automatisch hinzugefügt und ein einfacher "Hello World" -Dienst wird von Microsoft Visual Studio erstellt, ohne dass Code geschrieben werden muss.
CodePlex
CodePlex wurde im Juni 2006 von Microsoft gestartet und seitdem von einer großen Anzahl von Entwicklern auf der ganzen Welt verwendet, um erfolgreich .NET-Projekte zu erstellen. Einige der von CodePlex angebotenen Tools zum Entwickeln von WCF-Dienstanwendungen sind folgende:
wscf.blue- Dies ist ein Microsoft Visual Studio-Add-In sowie ein "Contract-First" -Entwicklungs-Toolset, das das Definieren der WCF-Dienstvorgänge und das entsprechende Generieren eines Codeskeletts erleichtert. Ein wichtiger Link dafür ist -https://wscfblue.codeplex.com
WCFProxyGenerator- Dies ist auch ein Microsoft Visual Studio-Add-In. Das Tool wird verwendet, um die clientseitige Generierung zu erweitern und eine zusätzliche Fehlerbehandlung anzubieten. Weitere Informationen zu diesem speziellen Entwicklungstool finden Sie unterhttps://wcfproxygenerator.codeplex.com
WCFMock- Das Testen von WCF-Diensten kann eine komplizierte Aufgabe sein, und dieses Entwicklungstool bietet eine bequeme Lösung für das Testen von WCF-Diensten durch seine nützlichen Klassen. Weitere Informationen zu diesem Tool finden Sie unterhttps://wcfmock.codeplex.com
Ein weiteres kostenloses Tool für die einfache Entwicklung von WCF-Dienstanwendungen ist WCFStorm. Die LITE-Version bietet viele bemerkenswerte Funktionen zum dynamischen Aufrufen und Testen von WCF-Diensten, zum Bearbeiten der Dienstbindung, zum Ändern des WCF-URL-Endpunkts usw.
WCF verfügt über eine mehrschichtige Architektur, die umfassende Unterstützung für die Entwicklung verschiedener verteilter Anwendungen bietet. Die Architektur wird nachstehend ausführlich erläutert.
Verträge
Die Vertragsschicht befindet sich direkt neben der Anwendungsschicht und enthält Informationen, die denen eines realen Vertrags ähneln und den Betrieb eines Dienstes und die Art der verfügbaren Informationen angeben. Es gibt grundsätzlich vier Arten von Verträgen, die im Folgenden kurz erläutert werden:
Service contract - Dieser Vertrag informiert den Kunden sowie die Außenwelt über die Angebote des Endpunkts und die Protokolle, die im Kommunikationsprozess verwendet werden sollen.
Data contract- Die von einem Dienst ausgetauschten Daten werden durch einen Datenvertrag definiert. Sowohl der Kunde als auch der Service müssen mit dem Datenvertrag einverstanden sein.
Message contract- Ein Datenvertrag wird durch einen Nachrichtenvertrag gesteuert. In erster Linie wird die Typformatierung der SOAP-Nachrichtenparameter angepasst. Hier sollte erwähnt werden, dass WCF zum Zwecke der Kommunikation das SOAP-Format verwendet. SOAP steht für Simple Object Access Protocol.
Policy and Binding- Es gibt bestimmte Voraussetzungen für die Kommunikation mit einem Dienst, und diese Bedingungen werden durch Richtlinien und verbindliche Verträge festgelegt. Ein Kunde muss diesen Vertrag befolgen.
Service-Laufzeit
Die Service-Laufzeitschicht befindet sich direkt unter der Vertragsschicht. Es gibt die verschiedenen Dienstverhalten an, die zur Laufzeit auftreten. Es gibt viele Arten von Verhaltensweisen, die konfiguriert werden können und unter die Dienstlaufzeit fallen.
Throttling Behavior - Verwaltet die Anzahl der verarbeiteten Nachrichten.
Error Behavior - Definiert das Ergebnis eines internen Servicefehlers.
Metadata Behavior - Gibt die Verfügbarkeit von Metadaten für die Außenwelt an.
Instance Behavior - Definiert die Anzahl der Instanzen, die erstellt werden müssen, um sie für den Client verfügbar zu machen.
Transaction Behavior - Aktiviert eine Änderung des Transaktionsstatus bei einem Fehler.
Dispatch Behavior - Steuert die Art und Weise, wie eine Nachricht von der Infrastruktur von WCF verarbeitet wird.
Concurrency Behavior - Steuert die Funktionen, die während einer Client-Server-Kommunikation parallel ausgeführt werden.
Parameter Filtering - Enthält den Prozess der Validierung von Parametern für eine Methode, bevor sie aufgerufen wird.
Messaging
Diese Schicht, die aus mehreren Kanälen besteht, befasst sich hauptsächlich mit dem Nachrichteninhalt, der zwischen zwei Endpunkten kommuniziert werden soll. Eine Reihe von Kanälen bildet einen Kanalstapel, und die beiden Haupttypen von Kanälen, aus denen der Kanalstapel besteht, sind die folgenden:
Transport Channels - Diese Kanäle befinden sich am Ende eines Stapels und sind für das Senden und Empfangen von Nachrichten mithilfe von Transportprotokollen wie HTTP, TCP, Peer-to-Peer, Named Pipes und MSMQ verantwortlich.
Protocol Channels - Diese Kanäle, die am oberen Rand eines Stapels vorhanden sind und auch als geschichtete Kanäle bezeichnet werden, implementieren Protokolle auf Drahtsebene durch Ändern von Nachrichten.
Aktivierung und Hosting
Die letzte Schicht der WCF-Architektur ist der Ort, an dem Dienste tatsächlich gehostet werden oder für den einfachen Zugriff durch den Client ausgeführt werden können. Dies geschieht durch verschiedene Mechanismen, die nachstehend kurz erörtert werden.
IIS- IIS steht für Internet Information Service. Es bietet eine Vielzahl von Vorteilen bei der Verwendung des HTTP-Protokolls durch einen Dienst. Hier ist es nicht erforderlich, den Host-Code zum Aktivieren des Service-Codes zu haben. Stattdessen wird der Servicecode automatisch aktiviert.
Windows Activation Service- Dies ist im Volksmund als WAS bekannt und wird mit IIS 7.0 geliefert. Hier ist sowohl HTTP- als auch nicht HTTP-basierte Kommunikation mithilfe von TCP- oder Namedpipe-Protokollen möglich.
Self-hosting- Dies ist ein Mechanismus, mit dem ein WCF-Dienst als Konsolenanwendung selbst gehostet wird. Dieser Mechanismus bietet eine erstaunliche Flexibilität bei der Auswahl der gewünschten Protokolle und der Einstellung eines eigenen Adressierungsschemas.
Windows Service - Das Hosten eines WCF-Dienstes mit diesem Mechanismus ist vorteilhaft, da die Dienste dann aktiviert bleiben und für den Client zugänglich sind, da keine Laufzeitaktivierung erfolgt.
Das Erstellen eines WCF-Dienstes ist eine einfache Aufgabe mit Microsoft Visual Studio 2012. Im Folgenden wird die schrittweise Methode zum Erstellen eines WCF-Dienstes zusammen mit der erforderlichen Codierung beschrieben, um das Konzept besser zu verstehen.
- Starten Sie Visual Studio 2012.
- Klicken Sie auf neues Projekt und wählen Sie auf der Registerkarte Visual C # die Option WCF.
Es wird ein WCF-Dienst erstellt, der grundlegende arithmetische Operationen wie Addition, Subtraktion, Multiplikation und Division ausführt. Der Hauptcode befindet sich in zwei verschiedenen Dateien - einer Schnittstelle und einer Klasse.
Eine WCF enthält eine oder mehrere Schnittstellen und ihre implementierten Klassen.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
namespace WcfServiceLibrary1 {
// NOTE: You can use the "Rename" command on the "Refactor" menu to
// change the interface name "IService1" in both code and config file
// together.
[ServiceContract]
Public interface IService1 {
[OperationContract]
int sum(int num1, int num2);
[OperationContract]
int Subtract(int num1, int num2);
[OperationContract]
int Multiply(int num1, int num2);
[OperationContract]
int Divide(int num1, int num2);
}
// Use a data contract as illustrated in the sample below to add
// composite types to service operations.
[DataContract]
Public class CompositeType {
Bool boolValue = true;
String stringValue = "Hello ";
[DataMember]
Public bool BoolValue {
get { return boolValue; }
set { boolValue = value; }
}
[DataMember]
Public string StringValue {
get { return stringValue; }
set { stringValue = value; }
}
}
}Der Code hinter seiner Klasse ist unten angegeben.
using System;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Runtime.Serialization;
usingSystem.ServiceModel;
usingSystem.Text;
namespace WcfServiceLibrary1 {
// NOTE: You can use the "Rename" command on the "Refactor" menu to
// change the class name "Service1" in both code and config file
// together.
publicclassService1 :IService1 {
// This Function Returns summation of two integer numbers
publicint sum(int num1, int num2) {
return num1 + num2;
}
// This function returns subtraction of two numbers.
// If num1 is smaller than number two then this function returns 0
publicint Subtract(int num1, int num2) {
if (num1 > num2) {
return num1 - num2;
}
else {
return 0;
}
}
// This function returns multiplication of two integer numbers.
publicint Multiply(int num1, int num2) {
return num1 * num2;
}
// This function returns integer value of two integer number.
// If num2 is 0 then this function returns 1.
publicint Divide(int num1, int num2) {
if (num2 != 0) {
return (num1 / num2);
} else {
return 1;
}
}
}
}Klicken Sie in Visual Studio auf die Schaltfläche Start, um diesen Dienst auszuführen.
Während wir diesen Dienst ausführen, wird der folgende Bildschirm angezeigt.
Wenn Sie auf die Summenmethode klicken, wird die folgende Seite geöffnet. Hier können Sie zwei beliebige Ganzzahlen eingeben und auf die Schaltfläche Aufrufen klicken. Der Dienst gibt die Summe dieser beiden Zahlen zurück.
Wie die Summierung können wir alle anderen arithmetischen Operationen ausführen, die im Menü aufgeführt sind. Und hier sind die Schnappschüsse für sie.
Die folgende Seite wird angezeigt, wenn Sie auf die Methode Subtrahieren klicken. Geben Sie die Ganzzahlen ein, klicken Sie auf die Schaltfläche Aufrufen und erhalten Sie die Ausgabe wie hier gezeigt -
Die folgende Seite wird angezeigt, wenn Sie auf die Multiplikationsmethode klicken. Geben Sie die Ganzzahlen ein, klicken Sie auf die Schaltfläche Aufrufen und erhalten Sie die Ausgabe wie hier gezeigt -
Die folgende Seite wird angezeigt, wenn Sie auf die Divide-Methode klicken. Geben Sie die Ganzzahlen ein, klicken Sie auf die Schaltfläche Aufrufen und erhalten Sie die Ausgabe wie hier gezeigt -
Sobald der Dienst aufgerufen wurde, können Sie direkt von hier aus zwischen ihnen wechseln.
Nach dem Erstellen eines WCF-Dienstes besteht der nächste Schritt darin, ihn zu hosten, damit die Clientanwendungen ihn verwenden können. Dies wird als WCF-Service-Hosting bezeichnet. Ein WCF-Dienst kann auf eine der folgenden vier Arten gehostet werden:
IIS Hosting- IIS steht für Internet Information Services. Das Arbeitsmodell ähnelt dem von ASP.NET beim Hosten eines WCF-Dienstes. Das Beste am IIS-Hosting ist, dass die Dienstaktivierung automatisch verarbeitet wird. Das IIS-Hosting bietet auch Überwachung des Prozesszustands, Herunterfahren im Leerlauf, Prozessrecycling und viele weitere Funktionen, um das Hosting eines WCF-Dienstes zu erleichtern.
Self-Hosting- Wenn ein WCF-Dienst in einer verwalteten Anwendung gehostet wird, spricht man von Self-Hosting. Ein Entwickler muss die erforderliche Codierung für die ServiceHost-Initialisierung schreiben. Beim Selbsthosting kann ein WCF-Dienst in einer Vielzahl von Anwendungen wie Konsolenanwendung, Windows Form usw. gehostet werden.
WAS Hosting - Das Hosten eines WCF-Dienstes im Windows Activation Service (WAS) ist aufgrund seiner Funktionen wie Prozessrecycling, Leerlaufzeitverwaltung, allgemeinem Konfigurationssystem und Unterstützung für HTTP, TCP usw. am vorteilhaftesten.
Windows Service Hosting- Für lokale Systemclients ist es am besten, den WCF-Dienst als Fensterdienst zu hosten. Dies wird als Fensterdiensthosting bezeichnet. Alle Windows-Versionen unterstützen diese Art von Hosting. Hier kann der Service Control Manager den Prozesslebenszyklus des WCF-Dienstes steuern.
Das Hosten eines WCF-Dienstes in IIS (Internet Information Services) erfolgt schrittweise. Das IIS-Hosting wird im Folgenden mit der gewünschten Codierung sowie Screenshots detailliert dargestellt, um den Prozess zu verstehen.
Step 1- Starten Sie Visual Studio 2012 und klicken Sie auf Datei → Neu → Website. Wählen Sie "WCF-Dienst" und Standort als http. Dadurch wird der Dienst in IIS gehostet. OK klicken.
Step 2 - Der Code hinter der Schnittstelle ist unten angegeben.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
// NOTE: You can use the "Rename" command on the "Refactor" menu to
// change the interface name "IService" in both code and config file
// together.
[ServiceContract]
Public interface IService {
[OperationContract]
String GetData(int value);
[OperationContract]
CompositeType GetDataUsingDataContract(CompositeType composite);
// TODO: Add your service operations here
}
// Use a data contract as illustrated in the sample below to add
// composite types to service operations.
[DataContract]
Public class CompositeType {
Bool boolValue = true;
String stringValue = "Hello ";
[DataMember]
Public bool BoolValue {
get { return boolValue; }
set { boolValue = value; }
}
[DataMember]
Public string StringValue {
get { return stringValue; }
set { stringValue = value; }
}
}Step 3 - Der Code hinter der Klassendatei ist unten angegeben.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
// NOTE: You can use the "Rename" command on the "Refactor" menu to
// change the class name "Service" in code, svc and config file
// together.
Public class Service : IService {
Public string GetData(int value) {
Return string.Format("You entered: {0}", value);
}
Public CompositeType GetDataUsingDataContract(CompositeType composite) {
if(composite == null) {
thrownewArgumentNullException("composite");
}
if(composite.BoolValue) {
composite.StringValue += "Suffix";
}
return composite;
}
}Step 4- Die Dienstdatei (.svc) enthält den Namen des Dienstes und den Code hinter dem Dateinamen. Diese Datei wird verwendet, um Informationen über den Dienst zu erhalten.
<%@ ServiceHost Language = "C#" Debug = "true" Service = "Service"
CodeBehind = "~/App_Code/Service.cs" %>Step 5- Serverseitige Konfigurationen werden in der Konfigurationsdatei erwähnt. Hier wird nur ein Endpunkt erwähnt, der für 'wsHttpBinding' konfiguriert ist. Wir können auch mehrere Endpunkte mit unterschiedlichen Bindungen haben. Da wir in IIS hosten werden, müssen wir nur die http-Bindung verwenden.
<?xml version = "1.0"?>
<configuration>
<!--
Note: As an alternative to hand editing this file you can use the
web admin tool to configure settings for your application. Use
the Website->Asp.Net Configuration option in Visual Studio.
A full list of settings and comments can be found in
machine.config.comments usually located in
\Windows\Microsoft.Net\Framework\vx.x\Config
-->
<configSections>
<sectionGroup name = "system.web.extensions"
ype = "System.Web.Configuration.SystemWebExtensionsSectionGroup,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35">
<sectionGroup name = "scripting"
type = "System.Web.Configuration.ScriptingSectionGroup,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35">
<section name = "scriptResourceHandler"
type = "System.Web.Configuration.ScriptingScriptResourceHandlerSection,
System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
requirePermission = "false"
allowDefinition = "MachineToApplication"/>
<sectionGroup name = "webServices"
type = "System.Web.Configuration.ScriptingWebServicesSectionGroup,
System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35">
<section name = "jsonSerialization"
type = "System.Web.Configuration.ScriptingJsonSerializationSection,
System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
requirePermission = "false" allowDefinition = "Everywhere"/>
<section name = "profileService"
type = "System.Web.Configuration.ScriptingProfileServiceSection,
System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
requirePermission = "false"
allowDefinition = "MachineToApplication"/>
<section name = "authenticationService"
type = "System.Web.Configuration.ScriptingAuthenticationServiceSection,
System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
requirePermission = "false"
allowDefinition = "MachineToApplication"/>
<section name = "roleService"
type = "System.Web.Configuration.ScriptingRoleServiceSection,
System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
requirePermission = "false"
allowDefinition = "MachineToApplication"/>
</sectionGroup>
</sectionGroup>
</sectionGroup>
</configSections>
<appSettings/>
<connectionStrings/>
<system.web>
<!--
Set compilation debug="true" to insert debugging
symbols into the compiled page. Because this
affects performance, set this value to true only
during development.
-->
<compilation debug = "true">
<assemblies>
<add assembly = "System.Core, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = B77A5C561934E089"/>
<add assembly = "System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>
<add assembly = "System.Data.DataSetExtensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = B77A5C561934E089"/>
<add assembly = "System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>
<add assembly = "System.Xml.Linq, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = B77A5C561934E089"/>
</assemblies>
</compilation>
<!--
The <authentication> section enables configuration
of the security authentication mode used by
ASP.NET to identify an incoming user.
-->
<authentication mode="Windows"/>
<!--
The <customErrors> section enables configuration
of what to do if/when an unhandled error occurs
during the execution of a request. Specifically,
it enables developers to configure html error pages
to be displayed in place of a error stack trace.
<customErrors mode = "RemoteOnly" defaultRedirect = "GenericErrorPage.htm">
<error statusCode = "403" redirect = "NoAccess.htm" />
<error statusCode = "404" redirect = "FileNotFound.htm" />
</customErrors>
-->
<pages>
<controls>
<add tagPrefix = "asp" namespace = "System.Web.UI"
assembly = "System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>
<add tagPrefix = "asp" namespace = "System.Web.UI.WebControls"
assembly = "System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>
</controls>
</pages>
<httpHandlers>
<remove verb = "*" path = "*.asmx"/>
<add verb = "*" path = "*.asmx" validate = "false"
type = "System.Web.Script.Services.ScriptHandlerFactory,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add verb = "*" path = "*_AppService.axd" validate = "false"
type = "System.Web.Script.Services.ScriptHandlerFactory,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add verb = "GET,HEAD" path = "ScriptResource.axd"
type = "System.Web.Handlers.ScriptResourceHandler,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35" validate = "false"/>
</httpHandlers>
<httpModules>
<add name = "ScriptModule"
type = "System.Web.Handlers.ScriptModule,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
</httpModules>
</system.web>
<system.codedom>
<compilers>
<compiler language = "c#;cs;csharp" extension = ".cs"
warningLevel = "4" type = "Microsoft.CSharp.CSharpCodeProvider,
System, Version = 2.0.0.0, Culture = neutral,
PublicKeyToken = b77a5c561934e089">
<providerOption name = "CompilerVersion" value = "v3.5"/>
<providerOption name = "WarnAsError" value = "false"/>
</compiler>
<compiler language = "vb;vbs;visualbasic;vbscript" extension = ".vb"
warningLevel = "4" type = "Microsoft.VisualBasic.VBCodeProvider,
System, Version = 2.0.0.0, Culture = neutral,
PublicKeyToken = b77a5c561934e089">
<providerOption name = "CompilerVersion" value = "v3.5"/>
<providerOption name = "OptionInfer" value = "true"/>
<providerOption name = "WarnAsError" value = "false"/>
</compiler>
</compilers>
</system.codedom>
<!--
The system.webServer section is required for running ASP.NET AJAX
under Internet Information Services 7.0.
It is not necessary for previous version of IIS.
-->
<system.webServer>
<validation validateIntegratedModeConfiguration="false"/>
<modules>
<remove name = "ScriptModule"/>
<add name = "ScriptModule" preCondition = "managedHandler"
type = "System.Web.Handlers.ScriptModule,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
</modules>
<handlers>
<remove name = "WebServiceHandlerFactory-Integrated"/>
<remove name = "ScriptHandlerFactory"/>
<remove name = "ScriptHandlerFactoryAppServices"/>
<remove name = "ScriptResource"/>
<add name = "ScriptHandlerFactory" verb = "*" path = "*.asmx"
preCondition = "integratedMode"
type = "System.Web.Script.Services.ScriptHandlerFactory,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add name = "ScriptHandlerFactoryAppServices"
verb = "*" path = "*_AppService.axd" preCondition = "integratedMode"
type = "System.Web.Script.Services.ScriptHandlerFactory,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add name = "ScriptResource" preCondition = "integratedMode"
verb = "GET,HEAD" path = "ScriptResource.axd"
type = "System.Web.Handlers.ScriptResourceHandler,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
</handlers>
<!--To browse web app root directory during debugging,
set the value below to true. Set to false before deployment to
avoid disclosing web app folder information.-->
<directoryBrowse enabled = "true"/>
</system.webServer>
<runtime>
<assemblyBinding appliesTo = "v2.0.05727" xmlns =" urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name = "System.Web.Extensions" publicKeyToken = "31bf3856ad364e35"/>
<bindingRedirect oldVersion = "1.0.0.0-1.1.0.0" newVersion = "3.5.0.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name = "System.Web.Extensions.Design" publicKeyToken =" 31bf3856ad364e35"/>
<bindingRedirect oldVersion = "1.0.0.0-1.1.0.0" newVersion = "3.5.0.0"/>
</dependentAssembly>
</assemblyBinding>
</runtime>
<system.serviceModel>
<services>
<service name = "Service" behaviorConfiguration = "ServiceBehavior">
<!-- Service Endpoints -->
<endpoint address = "" binding = "basicHttpBinding" contract = "IService">
<!--
Upon deployment, the following identity element should be removed or replaced
to reflect the identity under which the deployed service runs. If removed,
WCF will infer an appropriate identity automatically.
-->
<identity>
<dns value="localhost"/>
</identity>
</endpoint>
<endpoint address = "mex" binding = "mexHttpBinding" contract = "IMetadataExchange"/>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name = "ServiceBehavior">
<!-- To avoid disclosing metadata information, set the value below
to false before deployment -->
<serviceMetadata httpGetEnabled = "true"/>
<!-- To receive exception details in faults for debugging purposes,
set the value below to true.
Set to false before deployment to false avoid
disclosing exception information -->
<serviceDebug includeExceptionDetailInFaults = "false"/>
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>Step 6- Sie müssen den Namen der Servicedatei zusammen mit der in der Konfigurationsdatei angegebenen Adresse angeben. Der Screenshot von IIS ist hier angegeben.
Klicken Sie auf Start → Ausführen → Inetmgr, um das folgende Fenster zu öffnen.
Step 7 - Führen Sie die Anwendung aus, die den folgenden Bildschirm erzeugt.
Hier wird der WCF-Dienst in einer Konsolenanwendung gehostet. Im Folgenden wird der Prozess mit geeigneten Schritten nacheinander beschrieben, der den gesamten Prozess erklärt.
Step 1- Lassen Sie uns zunächst den Servicevertrag und dessen Implementierung erstellen. Erstellen Sie eine Konsolenanwendung und nennen Sie sie MyCalculatorService. Dies ist ein einfacher Dienst, um die Addition von zwei Zahlen zurückzugeben.
Step 2- Klicken Sie nun mit der rechten Maustaste auf die Referenzen im Projektmappen-Explorer und klicken Sie auf Referenzen hinzufügen. Das folgende Fenster wird geöffnet. Fügen Sie dem Projekt einen System.ServiceModel-Verweis hinzu.
Step 3- Erstellen Sie eine ISimpleCalculator-Schnittstelle, und fügen Sie der Klasse und Funktion die Attribute ServiceContract und OperationContract hinzu, wie unten gezeigt. Weitere Informationen zu diesen Verträgen erhalten Sie in der späteren Sitzung. Durch diese Verträge wird die Methode zur Nutzung dieses Dienstes der Außenwelt zugänglich gemacht.
Step 4 - Der Code hinter dieser Datei lautet wie folgt: -
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
namespace MyCalculatorWCFService {
[ServiceContract()]
Public interface ISimpleCalculator {
[OperationContract()]
int Add(int num1, int num2);
}
}Step 5 - MyCalculatorService ist die Implementierungsklasse für die IMyCalculatorService-Schnittstelle (siehe unten).
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MyCalculatorWCFService {
Class SimpleCalculator : ISimpleCalculator {
Public int Add(int num1, int num2) {
return num1 + num2;
}
}
}Step 6- Jetzt sind wir mit dem Service fertig. Lassen Sie uns den Hosting-Prozess implementieren. Erstellen Sie eine neue Konsolenanwendung und nennen Sie sie "MyCalculatorWCFServiceHost".
Step 7 - Fügen Sie die Referenz von system.servicemodel und das Projekt MyCalculatorWCFService hinzu.
Der Code dahinter lautet wie folgt:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCalculatorWCFService;
using System.ServiceModel;
using System.ServiceModel.Description;
namespace MyCalculatorWCFServiceHost {
class Program {
static void Main(string[] args) {
//Create a URI to serve as the base address
UrihttpUrl = newUri("http://localhost:8090/MyCalculatorWCFService/SimpleCalculator");
//Create ServiceHost
ServiceHost host = newServiceHost(typeof(MyCalculatorWCFService.ISimpleCalculator), httpUrl);
//Add a service endpoint
host.AddServiceEndpoint(typeof(MyCalculatorWCFService.ISimpleCal culator), newWSHttpBinding(), "");
//Enable metadata exchange
ServiceMetadataBehaviorsmb = newServiceMetadataBehavior();
smb.HttpGetEnabled = true;
host.Description.Behaviors.Add(smb);
//Start the Service
host.Open();
Console.WriteLine("Service is host at " + DateTime.Now.ToString());
Console.WriteLine("Host is running... Press key to stop");
Console.ReadLine();
}
}
}
Um das Konzept des WAS-Hostings zu verstehen, müssen wir verstehen, wie ein System konfiguriert und wie ein Servicevertrag erstellt wird, um eine unterschiedliche Bindung an den gehosteten Service zu ermöglichen.
Aktivieren Sie zunächst WCF für Nichtprotokolle. Bevor wir mit der Erstellung des Dienstes beginnen, müssen wir das System so konfigurieren, dass WAS unterstützt wird. Im Folgenden finden Sie die Schritte zum Konfigurieren von WAS -
Klicken Sie auf Startmenü → Systemsteuerung → Programme und Funktionen und klicken Sie im linken Bereich auf "Windows-Komponenten ein- oder ausschalten".
Erweitern Sie "Microsoft .Net Framework 3.0" und aktivieren Sie "Windows Communication Foundation-HTTP-Aktivierung" und "Windows Communication Foundation-Nicht-HTTP-Aktivierung".
Als nächstes müssen wir der Standardwebsite Bindung hinzufügen. Als Beispiel binden wir die Standardwebsite an das TCP-Protokoll. Gehen Sie zu Startmenü → Programme → Zubehör. Klicken Sie mit der rechten Maustaste auf die "Eingabeaufforderung" und wählen Sie "Als Administrator ausführen" aus dem Kontextmenü.
Führen Sie den folgenden Befehl aus:
C:\Windows\system32\inetsrv> appcmd.exe set site "Default Web Site" -+bindings.[protocol='net.tcp',bindingInformation='808:*']Dieser Befehl fügt die net.tcp-Site-Bindung zur Standardwebsite hinzu, indem die Datei applicationHost.config im Verzeichnis "C: \ Windows \ system32 \ inetsrv \ config" geändert wird. Ebenso können wir der Standardwebsite verschiedene Protokolle hinzufügen.
Erstellen Sie einen gehosteten WAS-Dienst
Step-1 - Öffnen Sie Visual Studio 2008, klicken Sie auf Neu → Website und wählen Sie WCF-Dienst aus der Vorlage und dem Speicherort als HTTP aus, wie unten gezeigt. -
Step-2- Erstellen Sie den Vertrag, indem Sie eine Schnittstelle IMathService erstellen. Fügen Sie der Schnittstelle das ServiceContract-Attribut und der Methodendeklaration das OperationContract-Attribut hinzu.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
// NOTE: You can use the "Rename" command on the "Refactor" menu to
// change the interface name "IService" in both code and config file
// together.
[ServiceContract]
Public interface IMathService {
[OperationContract]
int Add(int num1, int num2);
[OperationContract]
int Subtract(int num1, int num2);
}Step-3 - Die Implementierung der IMathService-Schnittstelle ist unten dargestellt. -
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
// NOTE: You can use the "Rename" command on the "Refactor" menu to
// change the class name "Service" in code, svc and config file
// together.
Public class MathService : IMathService {
Public int Add(int num1, int num2) {
return num1 + num2;
}
Public int Subtract(int num1, int num2) {
return num1 - num2;
}
}Step-4 - Die Servicedatei wird unten angezeigt.
<%@ServiceHostLanguage="C#"Debug="true"Service="MathService"CodeBehind="~/App_Code/MathService.cs"%>Step-5- Erstellen Sie in der Datei web.Config einen Endpunkt mit der Bindung 'netTcpBinding', und die Dienstmetadaten werden mithilfe des Metadatenaustauschpunkts veröffentlicht. Erstellen Sie daher den Metadata Exchange-Endpunkt mit der Adresse 'mex' und der Bindung 'mexTcpBinding'. Ohne Veröffentlichung der Service-Metadaten können wir den Proxy nicht mit der Adresse net.tcp erstellen, z.
svcutil.exe net.tcp://localhost/WASHostedService/MathService.svc).<?xml version = "1.0" ?>
<configuration>
<!--
Note: As an alternative to hand editing this file you can use the
web admin tool to configure settings for your application. Use
the Website->Asp.Net Configuration option in Visual Studio.
A full list of settings and comments can be found in
machine.config.comments usually located in
\Windows\Microsoft.Net\Framework\vx.x\Config
-->
<configSections>
<sectionGroup name = "system.web.extensions"
type = "System.Web.Configuration.SystemWebExtensionsSectionGroup,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35">
<sectionGroup name = "scripting"
type = "System.Web.Configuration.ScriptingSectionGroup,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken =3 1BF3856AD364E35">
<section name = "scriptResourceHandler"
type = "System.Web.Configuration.ScriptingScriptResourceHandlerSection,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"
requirePermission = "false"
allowDefinition = "MachineToApplication"/>
<sectionGroup name = "webServices"
type = "System.Web.Configuration.ScriptingWebServicesSectionGroup,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35">
<section name = "jsonSerialization"
type = "System.Web.Configuration.ScriptingJsonSerializationSection,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35" requirePermission = "false"
allowDefinition = "Everywhere"/>
<section name = "profileService"
type = "System.Web.Configuration.ScriptingProfileServiceSection,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35" requirePermission = "false"
allowDefinition = "MachineToApplication"/>
<section name = "authenticationService"
type = "System.Web.Configuration.ScriptingAuthenticationServiceSection,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35" requirePermission = "false"
allowDefinition = "MachineToApplication"/>
<section name = "roleService"
type = "System.Web.Configuration.ScriptingRoleServiceSection,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35" requirePermission = "false"
allowDefinition = "MachineToApplication"/>
</sectionGroup>
</sectionGroup>
</sectionGroup>
</configSections>
<appSettings/>
<connectionStrings/>
<system.web>
<!--
Set compilation debug="true" to insert debugging
symbols into the compiled page. Because this
affects performance, set this value to true only
during development.
-->
<compilation debug = "true">
<assemblies>
<add assembly = "System.Core, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = B77A5C561934E089"/>
<add assembly = "System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>
<add assembly = "System.Data.DataSetExtensions,
Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = B77A5C561934E089"/>
<add assembly = "System.Web.Extensions, Version = 3.5.0.0,
Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>
<add assembly = "System.Xml.Linq,
Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = B77A5C561934E089"/>
</assemblies>
</compilation>
<!--
The <authentication> section enables configuration
of the security authentication mode used by
ASP.NET to identify an incoming user.
-->
<authentication mode="Windows"/>
<!--
The <customErrors> section enables configuration
of what to do if/when an unhandled error occurs
during the execution of a request. Specifically,
it enables developers to configure html error pages
to be displayed in place of a error stack trace.
<customErrors mode = "RemoteOnly" defaultRedirect = "GenericErrorPage.htm">
<error statusCode = "403" redirect = "NoAccess.htm" />
<error statusCode = "404" redirect = "FileNotFound.htm" />
</customErrors>
-->
<pages>
<controls>
<add tagPrefix = "asp" namespace = "System.Web.UI"
assembly = "System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add tagPrefix = "asp" namespace = "System.Web.UI.WebControls"
assembly = "System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
</controls>
</pages>
<httpHandlers>
<remove verb = "*" path = "*.asmx"/>
<add verb =" *" path =" *.asmx" validate="false"
type = "System.Web.Script.Services.ScriptHandlerFactory,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add verb = "*" path = "*_AppService.axd" validate = "false"
type = "System.Web.Script.Services.ScriptHandlerFactory,System.Web.Extensions,
Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add verb = "GET,HEAD" path = "ScriptResource.axd"
type = "System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions,
Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35" validate = "false"/>
</httpHandlers>
<httpModules>
<add name = "ScriptModule"
type = "System.Web.Handlers.ScriptModule,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
</httpModules>
</system.web>
<system.codedom>
<compilers>
<compiler language = "c#;cs;csharp" extension = ".cs" warningLevel = "4"
type = "Microsoft.CSharp.CSharpCodeProvider, System,
Version = 2.0.0.0, Culture = neutral,
PublicKeyToken = b77a5c561934e089">
<providerOption name = "CompilerVersion" value = "v3.5"/>
<providerOption name = "WarnAsError" value = "false"/>
</compiler>
<compiler language = "vb;vbs;visualbasic;vbscript"
extension = ".vb" warningLevel = "4"
type = "Microsoft.VisualBasic.VBCodeProvider, System,
Version = 2.0.0.0, Culture = neutral,
PublicKeyToken = b77a5c561934e089">
<providerOption name = "CompilerVersion" value = "v3.5"/>
<providerOption name = "OptionInfer" value = "true"/>
<providerOption name = "WarnAsError" value = "false"/>
</compiler>
</compilers>
</system.codedom>
<!--
The system.webServer section is required for running ASP.NET AJAX under
Internet Information Services 7.0. It is not necessary for previous version of IIS.
-->
<system.webServer>
<validation validateIntegratedModeConfiguration = "false"/>
<modules>
<remove name = "ScriptModule"/>
<add name = "ScriptModule" preCondition = "managedHandler"
type = "System.Web.Handlers.ScriptModule, System.Web.Extensions,
Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
</modules>
<handlers>
<remove name = "WebServiceHandlerFactory-Integrated"/>
<remove name = "ScriptHandlerFactory"/>
<remove name = "ScriptHandlerFactoryAppServices"/>
<remove name = "ScriptResource"/>
<add name = "ScriptHandlerFactory"
verb = "*" path = "*.asmx" preCondition = "integratedMode"
type = "System.Web.Script.Services.ScriptHandlerFactory,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add name = "ScriptHandlerFactoryAppServices"
verb = "*" path = "*_AppService.axd" preCondition = "integratedMode"
type = "System.Web.Script.Services.ScriptHandlerFactory,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
<add name = "ScriptResource" preCondition = "integratedMode"
verb = "GET,HEAD" path = "ScriptResource.axd"
type = "System.Web.Handlers.ScriptResourceHandler,
System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
PublicKeyToken = 31BF3856AD364E35"/>
</handlers>
<!--
To browse web app root directory during debugging, set the value below to true.
Set to false before deployment to avoid disclosing web app folder information.
-->
<directoryBrowse enabled="true"/>
</system.webServer>
<runtime>
<assemblyBinding appliesTo = "v2.0.05727" xmlns = "urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name = "System.Web.Extensions" publicKeyToken = "31bf3856ad364e35"/>
<bindingRedirect oldVersion = "1.0.0.0-1.1.0.0" newVersion = "3.5.0.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name = "System.Web.Extensions.Design" publicKeyToken = "31bf3856ad364e35"/>
<bindingRedirect oldVersion = "1.0.0.0-1.1.0.0" newVersion = "3.5.0.0"/>
</dependentAssembly>
</assemblyBinding>
</runtime>
<system.serviceModel>
<services>
<service behaviorConfiguration = "ServiceBehavior" name = "Service">
<endpoint address = "" binding = "basicHttpBinding" contract = "IMathService">
<identity>
<dns value = "localhost" />
</identity>
</endpoint>
<endpoint address = "mex" binding = "mexHttpBinding" contract = "IMetadataExchange"/>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name = "ServiceBehavior">
<!--
To avoid disclosing metadata information, set the value below
to false before deployment.
-->
<serviceMetadata httpGetEnabled="true"/>
<!--
To receive exception details in faults for debugging purposes,
set the value below to true. Set to false before deployment to avoid
disclosing exception information
-->
<serviceDebug includeExceptionDetailInFaults="false"/>
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>Aktivieren Sie verschiedene Bindungen zum gehosteten Dienst
Gehen Sie zu Startmenü → Programme → Zubehör. Klicken Sie mit der rechten Maustaste auf die "Eingabeaufforderung" und wählen Sie "Als Administrator ausführen" aus dem Kontextmenü.
Führen Sie den folgenden Befehl aus:
C:\Windows\system32\inetsrv>appcmd set app "Default Web Site/WASHostedService" /enabledProtocols:http,net.tcpEs wird die folgende Ausgabe erzeugt -
Die Bedienung des Windows-Diensthostings ist einfach. Im Folgenden sind die Schritte mit der erforderlichen Codierung und Screenshots aufgeführt, die den Vorgang auf einfache Weise erläutern.
Step 1- Jetzt erstellen wir einen WCF-Dienst. Öffnen Sie Visual Studio 2008, klicken Sie auf Neu → Projekt und wählen Sie Klassenbibliothek aus der Vorlage aus.
Step 2- Fügen Sie dem Projekt die Referenz System.ServiceModel hinzu. Dies ist die Kernbaugruppe, die zum Erstellen des WCF-Dienstes verwendet wird.
Step 3- Als nächstes können wir die ISimpleCalulator-Schnittstelle erstellen. Fügen Sie das Attribut Service- und Betriebsvertrag wie unten gezeigt hinzu -
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
namespace WindowsServiceHostedService{
[ServiceContract]
public interfaceISimpleCalculator {
[OperationContract]
int Add(int num1, int num2);
[OperationContract]
int Subtract(int num1, int num2);
[OperationContract]
int Multiply(int num1, int num2);
[OperationContract]
double Divide(int num1, int num2);
}
}Step 4 - Implementieren Sie die ISimpleCalculator-Schnittstelle wie unten gezeigt -
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsServiceHostedService {
Class SimpleCalulator : ISimpleCalculator {
Public int Add(int num1, int num2) {
return num1 + num2;
}
Public int Subtract(int num1, int num2) {
return num1 - num2;
}
Public int Multiply(int num1, int num2) {
return num1 * num2;
}
Public double Divide(int num1, int num2) {
if (num2 != 0)
return num1 / num2;
else
return 0;
}
}
}Step 5- Erstellen Sie das Projekt und holen Sie sich die DLL. Jetzt sind wir mit dem WCF-Service fertig. Wir werden sehen, wie der WCF-Dienst im Windows-Dienst gehostet wird.
Note- In diesem Projekt wird erwähnt, dass wir sowohl Vertrag als auch Service (Implementierung) im selben Projekt erstellen. Es ist jedoch immer eine gute Praxis, wenn Sie beide in verschiedenen Projekten haben.
Step 6 - Öffnen Sie Visual Studio 2008 und klicken Sie auf Neu → Projekt und wählen Sie Windows-Dienst.
Step 7- Fügen Sie 'WindowsServiceHostedService.dll' als Referenz zum Projekt hinzu. Diese Baugruppe wird als Service dienen.
Step 8- Mit der OnStart-Methode des Dienstes kann der Hosting-Code für WCF geschrieben werden. Wir müssen sicherstellen, dass wir nur ein Service-Host-Objekt verwenden. Die OnStop-Methode wird verwendet, um den Service Host zu schließen. Der folgende Code zeigt, wie der WCF-Dienst im Windows-Dienst gehostet wird.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;
namespace WCFHostedWindowsService {
Partial class WCFHostedWindowsService : ServiceBase {
ServiceHostm_Host;
Public WCFHostedWindowsService() {
InitializeComponent();
}
Private void InitializeComponent() {
thrownewNotImplementedException();
}
protectedoverridevoidOnStart(string[] args) {
if (m_Host != null) {
m_Host.Close();
}
//Create a URI to serve as the base address
UrihttpUrl = newUri("http://localhost:8090/WindowsServiceHostedService/SimpleCalculator");
//Create ServiceHost
m_Host = newServiceHost typeof(WindowsServiceHostedService.SimpleCalulator), httpUrl);
//Add a service endpoint
m_Host.AddServiceEndpoint (typeof(WindowsServiceHostedService.ISimpleCalculator), newWSHttpBinding(), "");
//Enable metadata exchange
ServiceMetadataBehaviorsmb = newServiceMetadataBehavior();
smb.HttpGetEnabled = true;
m_Host.Description.Behaviors.Add(smb);
//Start the Service
m_Host.Open();
}
protectedoverridevoidOnStop() {
if (m_Host != null) {
m_Host.Close();
m_Host = null;
}
}
staticvoid Main() {
ServiceBase[] ServicesToRun;
ServicesToRun = newServiceBase[] {
newWCFHostedWindowsService();
}
ServiceBase.Run(ServicesToRun);
}
}
}Step 9- Um den Dienst installieren zu können, benötigen wir die Installer-Klasse für den Windows-Dienst. Fügen Sie dem Projekt also eine neue Installer-Klasse hinzu, die von der Installer-Klasse geerbt wird. Im Folgenden wird der Code angegeben, der den Dienstnamen, den StartUp-Typ usw. des Dienstes anzeigt.
using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceProcess;
using System.Configuration.Install;
using System.ComponentModel;
using System.Configuration;
namespace WCFHostedWindowsService {
[RunInstaller(true)]
Public class WinServiceInstaller : Installer {
Private ServiceProcessInstaller process;
Private ServiceInstaller service;
Public WinServiceInstaller() {
process = newServiceProcessInstaller();
process.Account = ServiceAccount.NetworkService;
service = newServiceInstaller();
service.ServiceName = "WCFHostedWindowsService";
service.DisplayName = "WCFHostedWindowsService";
service.Description = "WCF Service Hosted";
service.StartType = ServiceStartMode.Automatic;
Installers.Add(process);
Installers.Add(service);
}
}
}Step 10- Erstellen Sie das Projekt, um die ausführbare Datei WCFHostedWindowsService.exe abzurufen. Als Nächstes müssen wir den Dienst mithilfe der Visual Studio-Eingabeaufforderung installieren. Öffnen Sie daher die Eingabeaufforderung, indem Sie auf Start → Alle Programme → Microsoft Visual Studio 2008 → Visual Studio-Tools → Visual Studio-Eingabeaufforderung klicken. Mit der Dienstprogramminstallation install util können Sie den Dienst wie unten gezeigt installieren.
Mit WCF-Diensten können andere Anwendungen auf sie zugreifen oder sie nutzen. Ein WCF-Dienst kann je nach Hosting-Typ auf viele Arten genutzt werden. Hier erklären wir die schrittweise Methode, um einen WCF-Dienst für jede der folgenden beliebten Hosting-Optionen zu nutzen:
- In IIS 5/6 gehosteter WCF-Dienst verbrauchen
- Konsumieren eines selbst gehosteten WCF-Dienstes
- Im Windows-Aktivierungsdienst gehosteten WCF-Dienst verbrauchen
- In Windows-Dienst gehosteten WCF-Dienst verbrauchen
In IIS 5/6 gehosteten WCF-Dienst verbrauchen
Der Prozess des Verbrauchs eines in IIS 5/6 gehosteten WCF-Dienstes wird nachstehend ausführlich erläutert. Darüber hinaus wird erläutert, wie Proxy- und Konsolenanwendungen erstellt werden.
Step 1- Sobald ein Dienst in IIS gehostet ist, müssen wir ihn in Clientanwendungen verwenden. Vor dem Erstellen der Clientanwendung müssen wir einen Proxy für den Dienst erstellen. Dieser Proxy wird von der Clientanwendung verwendet, um mit dem Dienst zu interagieren. Führen Sie zum Erstellen eines Proxys die Eingabeaufforderung von Visual Studio 2008 aus. Mit dem Dienstprogramm können wir die Proxy-Klasse und ihre Konfigurationsinformationen erstellen.
svcutilhttp: //localhost/IISHostedService/Service.svc
Nach Ausführung dieses Befehls werden zwei Dateien am Standardspeicherort generiert.
MyService.cs - Proxy-Klasse für den WCF-Dienst
output.config - Konfigurationsinformationen zum Dienst
Step 2 - Jetzt beginnen wir mit der Erstellung der Konsolenanwendung mit Visual Studio 2008 (Clientanwendung).
Step 3- Fügen Sie die Referenz 'System.ServiceModel' hinzu. Dies ist die Kern-DLL für WCF.
Step 4 - Erstellen Sie eine Proxy-Klasse.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MyServiceClient {
Class Program {
Static void Main(string[] args) {
// Creating Proxy for the MyService
ServiceClient Client = newServiceClient();
Console.WriteLine("Client calling the service...");
Console.WriteLine("Hello Ram");
Console.Read();
}
}
}Die Ausgabe sieht wie folgt aus:
Konsumieren eines selbst gehosteten WCF-Dienstes
Hier wird der gesamte Prozess des Verbrauchs eines selbst gehosteten WCF-Dienstes Schritt für Schritt erklärt, zusammen mit umfangreicher Codierung und Screenshots, wo immer dies erforderlich ist.
Step 1- Der Dienst wird gehostet, jetzt müssen wir die Proxy-Klasse für den Client implementieren. Es gibt verschiedene Möglichkeiten, den Proxy zu erstellen.
Mit SvcUtil.exe können wir die Proxy-Klasse und ihre Konfigurationsdatei mit Endpunkten erstellen.
Hinzufügen eines Dienstverweises zur Clientanwendung.
Implementieren der ClientBase <T> -Klasse
Von diesen drei Methoden ist die Implementierung von ClientBase <T> die beste Vorgehensweise. Wenn Sie die beiden anderen Methoden verwenden, müssen wir jedes Mal eine Proxy-Klasse erstellen, wenn wir Änderungen an der Service-Implementierung vornehmen. Dies ist jedoch bei ClientBase <T> nicht der Fall. Der Proxy wird nur zur Laufzeit erstellt und kümmert sich um alles.
Erstellen Sie zu diesem Zweck eine Proxy-Klasse, die die Referenzen von System.ServiceModel und MyCalculatorService enthält.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using MyCalculatorService;
namespace MyCalculatorServiceProxy {
// WCF create proxy for ISimpleCalculator using ClientBase
Public class MyCalculatorServiceProxy :
ClientBase<ISimpleCalculator>,
ISimpleCalculator {
Public int Add(int num1, int num2) {
//Call base to do funtion
returnbase.Channel.Add(num1, num2);
}
}
}Erstellen Sie jetzt eine Konsolenanwendung, die die Referenzen von System.ServiceModel und MyCalculatorServiceProxy enthält.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using MyCalculatorServiceProxy;
namespace MyCalculatorServiceClient {
classProgram {
Static void Main(string[] args) {
MyCalculatorServiceProxy.MyCalculatorServiceProxy proxy = newMyCalculatorServiceProxy.MyCalculatorServiceProxy();
Console.WriteLine("Client is running at " + DateTime.Now.ToString());
Console.WriteLine("Sum of two numbers. 5 + 5 =" + proxy.Add(5,5));
Console.ReadLine();
}
}
}Step 2 - Endpunktinformationen (wie Service) sollten zur Konfigurationsdatei der Clientanwendung hinzugefügt werden.
<?xmlversion = "1.0"encoding = "utf-8" ?>
<configuration>
<system.serviceModel>
<client>
<endpoint address
="http://localhost:8090/MyCalculatorServiceProxy/ISimpleCalculator"
binding = "wsHttpBinding" contract "MyCalculatorServiceProxy.ISimpleCalculator">
</endpoint>
</client>
</system.serviceModel>
</configuration>Step 3- Bevor Sie die Clientanwendung ausführen, müssen Sie den Dienst ausführen. Unten ist die Ausgabe der Client-Anwendung dargestellt.
In WAS gehosteten WCF-Dienst verbrauchen
Das Konsumieren eines WCF-Dienstes, der in WAS gehostet wird, ist ein einfacher Vorgang, der nur wenige Schritte umfasst. Die Schritte sind wie folgt:
- Fügen Sie der Clientanwendung die Proxy-Klasse und die Konfigurationsdatei hinzu.
- Erstellen Sie das Objekt für den MathServiceClient und rufen Sie die Methode auf.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespaceWASHostedClient {
classProgram {
staticvoid Main(string[] args) {
MathServiceClient client = newMathServiceClient();
Console.WriteLine("Sum of two number 5,6");
Console.WriteLine(client.Add(5, 6));
Console.ReadLine();
}
}
}Die Ausgabe wird wie unten gezeigt angezeigt.
In Windows-Dienst gehosteten WCF-Dienst verbrauchen
Die schrittweise Anleitung zum Verwenden eines in Windows Service gehosteten WCF-Dienstes wird im Folgenden mit Codierung und Anweisungen ausführlich beschrieben.
Sobald es erfolgreich gehostet wurde, können wir eine Proxy-Klasse für den Dienst erstellen und in der Client-Anwendung verwenden. Hier wird gezeigt, wie der IIS-Hosting-Typ verbraucht.
Fügen Sie die Referenz von ServiceModel hinzu.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespaceWindowServiceClient {
classProgram {
staticvoid Main(string[] args) {
//Creating Proxy for the MyService
MyServiceClient client = newMyServiceClient();
Console.WriteLine("Client calling the service...");
Console.WriteLine("Sum of two numbers 5,6");
Console.WriteLine(client.Add(5, 6));
Console.WriteLine("Subtraction of two numbers 6,5");
Console.WriteLine(client.Sub(6, 5));
Console.WriteLine("Multiplication of two numbers 6,5");
Console.WriteLine(client.Mul(6, 5));
Console.WriteLine("Division of two numbers 6,3");
Console.WriteLine(client.Div(6, 3));
Console.Read();
}
}
}Die Ausgabe sieht wie folgt aus:
Die WCF-Dienstbindung besteht aus mehreren Elementen, in denen jedes Element die Art und Weise definiert, wie der Dienst mit dem Client kommuniziert. Ein Transportelement und ein Nachrichtenkodierungselement sind die beiden wichtigsten Komponenten jeder Bindung. In diesem Kapitel werden verschiedene häufig verwendete WCF-Dienstbindungen erläutert.
Grundbindung
Die Basisbindung wird von der BasicHttpBinding-Klasse angeboten. Es verwendet das HTTP-Protokoll, um einen WCF-Dienst als ASP.NET-Webdienst (ASMX-Webdienst) zu transportieren und darzustellen, sodass alte Clients, die ASMX-Webdienste verwenden, die neuen Dienste bequem nutzen können.
Die Basisbindung wird als Standardbindung in einem von Silverlight aktivierten WCF-Webdienst festgelegt und ist eine Standardbindung für die Kommunikation im Webdienststil. Es unterstützt kein zuverlässiges Messaging.
Im Folgenden finden Sie ein Code-Snippet mit den Standardeinstellungen für die Basisbindung.
<basicHttpBinding>
<binding name = "basicHttpBindingDefaults" allowCookies = "false"
bypassProxyOnLocal = "false" hostNameComparisonMode = "StrongWildcard"
maxBufferPoolSize = "524288" maxBufferSize = "65536"
maxReceivedMessageSize = "65536" messageEncoding = "Text" proxyAddress = ""
textEncoding = "utf-8" transferMode = "Buffer" useDefaultWebProxy = "true"
closeTimeout = "00:01:00" openTimeout = "00:01:00" receiveTimeout = "00:10:00"
sendTimeout = "00:01:00">
<readerQuotas maxArrayLength = "16384" maxBytesPerRead = "4096"
maxDepth = "32"
maxNameTableCharCount = "16384" maxStringContentLength = "8192"/>
<security mode = "None">
<transport clientCredentialType = "None" proxyCredentialType = "None" realm = ""/>
<message algorithmSuite = "Basic256" clientCredentialType = "UserName" />
</security>
</binding>
</basicHttpBinding>Die oben genannten Standardeinstellungen haben ihre offensichtlichen Einschränkungen, da die Nachrichtengröße begrenzt ist und es keinen Sicherheitsmodus gibt. Die Anpassung der Basisbindung löst dieses Problem jedoch wie das folgende.
<basicHttpBinding>
<binding name = "basicHttpSecure" maxBufferSize = "100000" maxReceivedMessageSize = "100000">
<readerQuotas maxArrayLength = "100000" maxStringContentLength = "100000"/>
<security mode = "TransportWithMessageCredential" />
</binding>
</basicHttpBinding>Webdienstbindung
Die WS-Bindung (Web Service) wird von der WSHttpBinding-Klasse bereitgestellt. Es ist der Basisbindung ziemlich ähnlich und verwendet dieselben Protokolle für den Transport, bietet jedoch mehrere WS- * -Spezifikationen wie WS-zuverlässiges Messaging, WS-Transaktionen, WS-Sicherheit und viele mehr. Kurz gesagt, WSHttpBinding entspricht der Summe der grundlegenden HttpBinding- und WS– * -Spezifikationen. Im Folgenden finden Sie ein Code-Snippet mit den Standardeinstellungen für die WS-Bindung.
<wsHttpBinding>
<binding name = "wsHttpBindingDefaults" allowCookies = "false"
bypassProxyOnLocal = "false" closeTimeout = "00:01:00"
hostNameComparisonMode = "StrongWildcard"
maxBufferPoolSize = "524288" maxReceivedMessageSize = "65536"
messageEncoding = "Text" openTimeout = "00:01:00"
receiveTimeout = "00:10:00" proxyAddress = "" sendTimeout = "00:01:00"
textEncoding = "utf-8" transactionFlow = "false"
useDefaultWebProxy = "true" >
<readerQuotas maxArrayLength = "16384" maxBytesPerRead = ."4096"
maxDepth = "32" maxNameTableCharCount = "16384"
maxStringContentLength = "8192"/>
<reliableSession enabled = "false" ordered = "true"
inactivityTimeout = "oo:10:00" />
<security mode = "Message">
<message algorithmSuite = "Basic256" clientCredentialType = "Windows"
esatalishSecurityContext = "true"
negotiateServiceCredential = "true" />
<transport clientCredentialType = "Windows"
proxyCredentialType = "None" realm = ""/>
</security>
</binding>
</wsHttpBinding>IPC-Bindung
Die IPC-Bindung verwendet Named Pipe und wird von der Klasse netNamedPipeBinding angeboten. Dies ist die schnellste und sicherste Bindung unter allen verfügbaren Bindungen. Obwohl die Sicherheit auf Nachrichtenebene hier nicht unterstützt wird, sind Nachrichten aufgrund einer robusten Transportsicherheit standardmäßig sicher. Im Folgenden finden Sie das Code-Snippet mit den Standardeinstellungen für die IPC-Bindung.
<netNamedPipeBinding>
<binding name = "netPipeDefaults" closeTimeout = "00:01:00"
hostNameComparisonMode = "StrongWildcard" maxBufferPoolSize = "524288"
maxBufferSize = "65536" maxConnections = "10"
maxReceivedMessageSize = "65536" openTimeout = "00:01:00"
receiveTimeout = "00:10:00" sendTimeout = "00:01:00" transactionFlow = "false"
transactionProtocol = "OleTransactions" transferMode = "Buffered">
<readerQuotas maxArrayLength = "16384" maxBytesPerRead = "4096"
maxDepth = "32" maxNameTableCharCount = "16384"
maxStringContentLength = "8192"/>
<security mode = "Transport">
</security>
</binding>
</netNamedPipeBinding>Andere Arten von Servicebindungen
TCP Binding- Diese von der NetTCPBinding-Klasse bereitgestellte Bindung verwendet das TCP-Protokoll für die Kommunikation innerhalb desselben Netzwerks und führt die Nachrichtenkodierung im Binärformat durch. Diese Bindung gilt im Gegensatz zu anderen als die zuverlässigste.
WS Dual Binding- Diese Art der Bindung ähnelt eher der WSHttpBinding mit der einzigen Ausnahme, dass sie die bidirektionale Kommunikation erleichtert, dh, Nachrichten können sowohl von Clients als auch von Diensten gesendet und empfangen werden. Es wird von der WSDualHttpBinding-Klasse angeboten.
Web binding - Die Webbindung dient zur Darstellung von WCF-Diensten in Form von HTTP-Anforderungen mithilfe von HTTP-GET, HTTP-POST usw. Sie wird von der WebHttpBinding-Klasse angeboten und häufig in sozialen Netzwerken verwendet.
MSMQ Binding- Es wird von der NetMsmqBinding-Klasse angeboten und dient zur Bereitstellung von Lösungen für den Fall, dass der Dienst eine Nachricht zu einem anderen Zeitpunkt als dem vom Client gesendeten verarbeitet. Die MSMQ-Bindung verwendet MSMQ für den Transport und bietet Unterstützung für getrennte Nachrichten in der Warteschlange. MSMQ ist eine Implementierung für die Nachrichtenwarteschlange, die von Microsoft angeboten wird.
Federated WS Binding- Es handelt sich um eine spezielle Form der WS-Bindung, die Unterstützung für Verbundsicherheit bietet. Es wird von der WSFederationHttpBinding-Klasse angeboten.
Peer Network Binding- Wird von der NetPeerTCPBinding-Klasse angeboten und hauptsächlich in Dateifreigabesystemen verwendet. Es verwendet das TCP-Protokoll, nutzt jedoch Peer-Netzwerke als Transportmittel. In diesem Netzwerk fungiert jeder Computer (Knoten) als Client und Server für die anderen Knoten. Peer-Netzwerkbindung wird in Dateifreigabesystemen wie Torrent verwendet.
MSMQ Integration Binding - Wird von der MsmqIntegrationBinding-Klasse angeboten und unterstützt die Kommunikation mit vorhandenen Systemen, die über MSMQ (Microsoft Message Queuing) kommunizieren.
Abgesehen davon ist es auch möglich, benutzerdefinierte Bindungen zu erstellen. Da es jedoch möglich ist, die Konfigurationseigenschaften jeder WCF-Bindung zu optimieren, besteht selten die Notwendigkeit, benutzerdefinierte Bindungen zu erstellen.
Die von WCF verwendeten Techniken zum Binden einer Reihe von Nachrichten (Clientanforderungen) an Dienstinstanzen werden als Instanzverwaltung bezeichnet. WCF unterstützt drei Arten der Instanzaktivierung, die in diesem Kapitel erläutert werden.
Per-Call-Service
Der Anrufdienst ist der Standardinstanzaktivierungsmodus von WCF. Wenn ein WCF-Dienst für einen Anrufdienst konfiguriert ist, wird ein CLR-Objekt für die Zeitspanne erstellt, in der ein Clientanruf oder eine Anforderung ausgeführt wird. CLR steht für Common Language Runtime und enthält Dienstinstanzen in WCF.
Beim Anrufdienst erreicht jede Clientanforderung eine neue dedizierte Dienstinstanz, und der Speicherverbrauch ist im Vergleich zu anderen Arten der Instanzaktivierung geringer.
Die InstanceContextMode-Eigenschaft muss auf InstanceContextMode.PerCall festgelegt werden, um einen WCF-Dienst anzugeben, der als Anrufdienst fungiert. Die InstanceContextMode-Eigenschaft gehört zum ServiceBehavior-Attribut. Daher kann ein Anrufdienst wie folgt konfiguriert werden:
[ServiceContract]
interface IMyContract
{...}
[ServiceBehavior (InstanceContextMode = InstanceContextMode.PerCall)]
class MyService : IMyContract
{...}Ein Service wird hier als IMyContract ausgedrückt. Die folgende Abbildung zeigt den Prozess der Aktivierung der Dienstinstanz pro Anruf.
Implementieren eines Per-Call-Dienstes
[DataContract]
class Param {....}
[ServiceContract]
interface IMyContract {
[OperationContract]
void MyMethod(Param objectIdentifier);
}
class MyPerCallService : IMyContract, IDisposable {
public void MyMethod(Param objectIdentifier) {
GetState(objectIdentifier);
DoWork();
SaveState(objectIdentifier);
}
void GetState(Param objectIdentifier) {....}
void DoWork() {....}
void SaveState(Param objectIdentifier) {....}
public void Dispose() {....}
}Hier ist Param der Pseudotyp-Parameter, der für das obige Beispiel erfunden wurde.
Sitzungsdienst
In diesem Aktivierungsmodus von WCF wird eine private oder eine vertrauliche Sitzung zwischen den beiden Entitäten, dh dem Client und einer bestimmten Dienstinstanz, aufrechterhalten. Der Sitzungsdienst, der auch als privater Sitzungsdienst bezeichnet wird, bietet eine neue Dienstinstanz, die für jede Clientanforderung reserviert bleibt und unabhängig von allen anderen Instanzen ist, die diesen sitzungsbewussten Dienst betreffen.
Um einen Sitzungsdienst zu initiieren, muss die InstanceContextMode-Eigenschaft auf PerSession festgelegt werden. Hier bleibt die Dienstinstanz während der gesamten Sitzungsdauer im Speicher.
Der Aktivierungsmodus leidet unter Skalierbarkeit, da der konfigurierte Dienst aufgrund der mit jeder dieser dedizierten Dienstinstanzen verbundenen Kosten keine weiteren ausstehenden Clients außer einigen wenigen (oder möglicherweise bis zu einigen hundert) unterstützen kann.
Ein Dienst pro Sitzung kann wie folgt konfiguriert werden:
[ServiceBehavior (InstanceContextMode = InstanceContextMode.PerSession)]
class MyService : IMyContract
{...}Der Prozess des Sitzungsdienstes kann wie in der folgenden Abbildung dargestellt beschrieben werden:
Der folgende Code zeigt einen Vertrag und einen Dienst, die für die Verwendung einer privaten Sitzung konfiguriert sind. Die Ausgabe zeigt an, dass der Client tatsächlich eine dedizierte Dienstinstanz erhalten hat.
Service code
[ServiceContract(Session = true)]
interface IMyContract {
[OperationContract]
void MyMethod();
}
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
class MyService : IMyContract, IDisposable {
int m_Counter = 0; MyService() {Console.WriteLine("MyService.MyService()"); }
public void MyMethod() {
m_Counter++;
Console.WriteLine("Counter = " + m_Counter);
}
public void Dispose() {
Console.WriteLine("MyService.Dispose()");
}
}Kundencode
MyContractProxy proxy = new MyContractProxy(); proxy.MyMethod(); proxy.MyMethod();
proxy.Close();Ausgabe
MyService.MyService() Counter = 1 Counter = 2 MyService.Dispose()Singleton Service
In diesem Aktivierungsmodus von WCF werden alle voneinander unabhängigen Clientanforderungen unabhängig von ihrer Verbindung zu den Service-Endpunkten mit derselben bekannten Einzelinstanz verbunden. Der Singleton-Dienst wird nur entsorgt, wenn der Host geschlossen wird.
Dieser Dienst wird nur einmal erstellt, wenn der Host erstellt wird. Falls dem Host keine Singleton-Instanz bereitgestellt wird, gibt der Dienst NULL zurück. Der Aktivierungsmodus ist am besten, wenn der Arbeitsaufwand in jedem Methodenaufruf gering ist und keine ausstehenden Vorgänge im Hintergrund vorhanden sind.
Die InstanceContextMode-Eigenschaft muss auf InstanceContextMode.Single festgelegt werden, um diesen Singleton-Dienst zu initiieren.
Daher kann ein Singleton-Dienst wie folgt konfiguriert werden:
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
class MySingleton : ...
{...}Der Prozess des Singleton-Dienstes ist in der folgenden Abbildung dargestellt:
Der folgende Code wird zum Initialisieren und Hosten einer Singleton-Instanz verwendet.
Service code
[ServiceContract]
interface IMyContract {
[OperationContract]
void MyMethod( );
}
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
class MySingleton : IMyContract {
int m_Counter = 0;
public int Counter {
get {
return m_Counter;
}
set {
m_Counter = value;
}
}
public void MyMethod( ) {
m_Counter++;
Trace.WriteLine("Counter = " + Counter);
}
}Host-Code
MySingleton singleton = new MySingleton( );
singleton.Counter = 42;
ServiceHost host = new ServiceHost(singleton);
host.Open( );
//Do some blocking calls then
host.Close( );Client-Code
MyContractClient proxy = new MyContractClient( );
proxy.MyMethod( );
proxy.Close( );Ausgabe
Counter = 43Eine Transaktion in WCF ist eine Reihe von Vorgängen, die einigen Eigenschaften folgen, die zusammen als ACID bezeichnet werden. Wenn hier ein einzelner Vorgang fehlschlägt, fällt das gesamte System automatisch aus. Wenn eine Bestellung online aufgegeben wird, findet eine Transaktion statt. Das folgende Beispiel kann hilfreich sein, um den Transaktionsprozess einfacher zu verstehen.
Beispiel
Angenommen, Sie haben einen LCD-Fernseher in einem Online-Shop bestellt und zahlen den Betrag mit Ihrer Kreditkarte. Wenn Sie die erforderlichen Informationen eingeben, um die Bestellung aufzugeben, werden zwei Vorgänge gleichzeitig ausgeführt.
Erstens wird der angegebene Betrag von Ihrem Bankkonto abgebucht, und zweitens wird dem Anbieterkonto derselbe Betrag gutgeschrieben. Beide Operationen müssen erfolgreich ausgeführt werden, um eine erfolgreiche Transaktion zu haben.
WCF-Transaktionseigenschaften
Die vier Eigenschaften, denen eine WCF-Transaktion folgt, sind die folgenden:
Atomic - Alle Operationen müssen nach Abschluss einer Transaktion als eine einzige unteilbare Operation fungieren.
Consistency - Unabhängig von der eingestellten Operation befindet sich das System immer in einem konsistenten Zustand, dh das Ergebnis der Transaktion entspricht immer den Erwartungen.
Isolation - Der Zwischenzustand des Systems ist für keine Einheiten der Außenwelt sichtbar, bis die Transaktion abgeschlossen ist.
Durability - Der festgeschriebene Status bleibt unabhängig von Fehlern (Hardware, Stromausfall usw.) erhalten.
Bei der Konfiguration einer WCF-Transaktion müssen einige Faktoren berücksichtigt werden. Dies sind Bindungs- und Betriebsverhalten.
Binding- Es gibt nur wenige Bindungen, die Transaktionen in WCF unterstützen, und es ist wichtig, nur aus diesen Bindungen auszuwählen, die standardmäßig deaktiviert bleiben und aktiviert werden sollten, um die erforderliche Unterstützung für Transaktionen zu erhalten. Diese Bindungen sind wie folgt:
- NetTcpBinding
- NetNamedPipeBinding
- WSHttpBinding
- WSDualHttpBinding
- WSFederationHttpBinding
Operation behavior- Während eine Bindung den Pfad für die Transaktionsweitergabe erleichtert, kümmert sich eine Operation um die Transaktionsverarbeitung sowie die Operationskonfiguration. Das Betriebsverhalten verwendet hauptsächlich zwei Attribute: TransactionFlow und TransactionScopeRequired. Hierbei ist zu beachten, dass TransactionFlow hauptsächlich drei Werte hat: Zulässig, Obligatorisch und Nicht zulässig.
Der folgende Code zeigt, ob das Ändern der Konfiguration des Bindungs- und Betriebsvertrags die Weitergabe des Clients erleichtert.
<bindings>
<wsHttpBinding>
<binding name = "MandatoryTransBinding" transactionFlow = "true">
<reliableSession enabled ="true"/>
</binding>
</wsHttpBinding>
</bindings>Transaktionsprotokoll
WCF verwendet drei Arten von Protokollen für Transaktionen -
- Lightweight
- Ole Transaktion
- WS-Atomtransaktion (WS-AT)
Von allen dreien ist WS-AT ein interoperables Protokoll und ermöglicht den Fluss verteilter Transaktionen über Firewalls hinweg. Dieses Protokoll sollte jedoch nicht verwendet werden, wenn die Transaktion ausschließlich auf der Microsoft-Technologie basiert.
Phasen der WCF-Transaktion
Eine WCF-Transaktion besteht aus zwei Phasen, wie in der folgenden Abbildung dargestellt.
Prepare Phase - In dieser Phase prüft der Transaktionsmanager, ob alle Entitäten bereit sind, sich für die Transaktion zu verpflichten oder nicht.
Commit Phase - In dieser Phase beginnt das Engagement von Unternehmen in der Realität.
Die folgende Abbildung zeigt die Funktionen beider Phasen einer WCF-Transaktion.
Aktivieren einer WCF-Transaktion
Um eine WCF-Transaktion erfolgreich zu aktivieren, müssen Sie eine Reihe von sechs Schritten nacheinander ausführen. Die erforderlichen Schritte werden unten erläutert.
Step 1 − Creation of two WCF Services
Der wichtigste Schritt in dieser Hinsicht besteht darin, zwei Serviceprojekte in WCF zu erstellen, um an einer einzigen Transaktion teilzunehmen. Datenbanktransaktionen werden für beide Dienste ausgeführt, und es versteht sich, dass sie durch eine WCF-Transaktion vereinheitlicht werden. Es wurde auch eine Webanwendung von WCFTransactions erstellt, um die beiden erstellten Services in einem einzigen Transaktionsbereich zu nutzen.
Step 2 − Method creation and its attribution with TransactionFlow attribute
Hier wird eine UpdateData-Methode erstellt, die beide WCF-Dienste mit dem OperationContract-Attribut in die Datenbank einfügen können. Um diese Aufgabe auszuführen, wird zunächst mithilfe des ServiceContract-Attributs eine Schnittstellenklasse erstellt. Um die Transaktion in der neu erstellten Methode zu aktivieren, wird sie TransactionFlow zugeordnet, und Transaktionen sind mit dem Wert Zulässig zulässig.
[ServiceContract]
public interface IService1 {
[OperationContract]
[TransactionFlow(TransactionFlowOption.Allowed)]
void UpdateData();
}Step 3− Implementation of WCF service with TransactionScopeRequired attribute
Dies geschieht mit dem unten gezeigten Code -
[OperationBehavior(TransactionScopeRequired = true)]
public void UpdateData() {
try {
SqlConnection objConnection = new SqlConnection(strConnection);
objConnection.Open();
using(SqlTransaction transaction = Program.dbConnection.BeginTransaction()) {
Boolean doRollback = false;
using(SqlCommand cmd = new SqlCommand(
"insert into Customer (Customer name, Customer code) values ('sss', 'sss')"objConnection))
try {
cmd.ExecuteNonQuery();
} catch(SqlException) {
doRollback = true;
break;
}
}
if(doRollback)
transaction.Rollback();
else
transaction.Commit();
}
finally {
objConection.Close();
}
}Step 4 − Enabling Transaction Flow by WCF Service Config File
Die Codierung erfolgt wie folgt:
<bindings>
<wsHttpBinding>
<binding name = "TransactionalBind" transactionFlow = "true"/>
</wsHttpBinding>
</bindings>Es ist wichtig, die für die Transaktion zulässige Bindung an den Endpunkt anzuhängen, um den WCF-Dienst verfügbar zu machen.
<endpoint address = "" binding = "wsHttpBinding" bindingConfiguration = "TransactionalBind" contract = "WcfService1.IService1">Step 5 − Calling both the services in a single transaction
Hier werden die beiden oben genannten Dienste in einer Transaktion aufgerufen. Zu diesem Zweck wird das TransactionScope-Objekt verwendet, um beide Dienste zu gruppieren. Die Complete-Methode des obigen Objekts wird aufgerufen, um eine WCF-Transaktion festzuschreiben. Zum Rollback ist die Dispose-Methode aufzurufen.
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.RequiresNew)) {
try {
// Call your webservice transactions here
ts.Complete();
} catch (Exception ex) {
ts.Dispose();
}
}Das kleine Stück des vollständigen Codes, in dem WCF-Transaktionen in einem Bereich zusammengefasst wurden, ist unten dargestellt -
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.RequiresNew)) {
try {
ServiceReference1.Service1Client obj = newServiceReference1.Service1Client();
obj.UpdateData();
ServiceReference2.Service1Client obj1 = new ServiceReference2.Service1Client();
obj1.UpdateData();
ts.Complete();
} catch (Exception ex) {
ts.Dispose();
}
}Step 6 − Testing WCF transaction
Das Testen wird im 6. und letzten Schritt durchgeführt und nach dem Aufrufen des 1. WCF-Dienstes wird eine Ausnahme erzwungen.
Der WCF RIA Service ist ein übergeordnetes Framework und eine neue Komponente von Frameworks wie .NET 4 und Silverlight 4, die das Erstellen einer komplexen Geschäftsanwendung in Silverlight durch clientseitige Validierung vereinfacht. RIA steht für Rich Internet Applications.
Hierbei ist zu beachten, dass Silverlight ein von Microsoft angebotenes Framework ist, das sich ideal für umfangreiche Internetanwendungen eignet und genau wie Adobe Flash als Browser-Plug-In zur Verfügung steht.
Der WCF-RIA-Dienst basiert hauptsächlich auf der Standardversion des WCF-Dienstes. Die folgende Abbildung zeigt einen Teil der WCF-Architektur, auf die sich die WCF-RIA-Dienste im Allgemeinen konzentrieren.
Das Erstellen eines WCF-RIA-Dienstes ist der nächste Schritt, um das Konzept besser zu verstehen. Die schrittweise Vorgehensweise ist unten angegeben.
Step 1 - Erstellen Sie mit Silverlight 5 ein neues Webprojekt mit dem Namen SLWCFRiaServices.Web und fügen Sie dann ein neues Element hinzu, indem Sie dasselbe ADO.NET-Entitätsdatenmodell auswählen.
Step 2 - Wählen Sie nun den Modellinhalt im Assistenten für Entitätsdatenmodelle aus, indem Sie das Modell aus der Datenbank generieren.
Step 3 - Wählen Sie im selben Assistenten Ihre Datenverbindung und Datenbankobjekte aus.
Step 4 - Erstellen Sie die Lösung so, dass das Erkennen des Datenmodells in Zukunft für den zu erstellenden Domänendienst kein Problem darstellt.
Step 5 - Erstellen Sie jetzt einen Domänendienst im Webprojekt, indem Sie ein neues Element hinzufügen, und stellen Sie sicher, dass der Clientzugriff aktiviert ist.
Step 6 - Im nächsten Schritt werden einige Klassen generiert, und es ist wichtig, sie erneut zu erstellen.
Step 7 - In diesem Schritt wird DataDomainContext im Datenquellenfenster angezeigt.
Step 8 - In diesem Schritt sollte der Artikel unter dem DataDomainContext ausgewählt und angepasst werden.
Step 9- Das Anhängen des DataGrid-Steuerelements an die Datenquelle ist der hier festgelegte Schritt, zusammen mit der Auswahl der Themen. Hier wurde das BureauBlue-Thema ausgewählt.
Step 10- Der letzte und letzte Schritt besteht darin, zum Entwurfsbildschirm zu wechseln und durch einfaches Ziehen und Ablegen eine Entität im Layoutbereich der Hauptseite hinzuzufügen. Es ist auch wichtig, AutoGenerateColumns = "True" sicherzustellen und auszuführen, um die Ausgabe anzuzeigen.
Voraussetzungen
Es gibt einige Voraussetzungen, um das volle Potenzial der WCF-RIA-Dienste auszuschöpfen -
- Visual Studio 2010 / Visual Studio 2012
- Silverlight Developer Runtime
- Neueste Version des RIA Services Toolkit
- SDK (Software Development Kit)
WCF RIA Domain Service
Ein Domänendienst umfasst eine Reihe von Datenvorgängen, die sich auf das Geschäft beziehen. Es ist nichts anderes als ein WCF-Dienst, der die Geschäftslogik einer WCF-RIA-Dienstanwendung verfügbar macht.
Ein WCF-RIA-Domänendienst verfügt intern über die Hosting-Klasse DomainServiceHost, die wiederum die WCF-ServiceHost-Klasse zum Hosten der Anwendung verwendet. Um den Domänendienst für das Clientprojekt zugänglich zu machen, sollte er über das Attribut EnableClientAccessAttribute verfügen. Das Attribut wird automatisch angewendet, wenn eine neue Domänendienstklasse hinzugefügt wird.
Die folgende Abbildung zeigt die Architektur eines WCF-RIA-Domänendienstes -
WCF RIA Services - Daten abfragen
Die folgende Abbildung zeigt, wie eine Abfrage auf der Clientseite erstellt und auf der Serverseite ausgeführt wird, um abfragbare Ergebnisse zurückzugeben. DAL steht für Data Access Layer.
WCF RIA Services - Aktualisieren von Daten
Die folgende Abbildung zeigt, wie Daten aktualisiert werden, indem der CUD-Vorgang (Create Update Delete) auf der Serverseite ausgeführt wird. Hierbei ist zu beachten, dass der WCF-RIA-Dienst auf der Serverseite immer zustandslos ist.
Ein WCF-Dienst verfügt über ein robustes Sicherheitssystem mit zwei Sicherheitsmodi oder -stufen, sodass nur ein vorgesehener Client auf die Dienste zugreifen kann. Die Sicherheitsbedrohungen, die bei einer verteilten Transaktion häufig auftreten, werden von WCF weitgehend gemildert.
Wichtige Sicherheitsfunktionen
Der WCF-Dienst verfügt über vier wichtige Sicherheitsfunktionen, wie in der folgenden Abbildung dargestellt.
Authentication - Hier beschränkt sich die Authentifizierung nicht auf die Identifizierung des Absenders der Nachricht, sondern ist gegenseitig, dh die Authentifizierung des Nachrichtenempfängers ist erforderlich, um die Möglichkeit eines Mittelsmannangriffs auszuschließen.
Authorization- Dies ist der nächste Schritt eines WCF-Dienstes zur Gewährleistung der Sicherheit. Hier wird festgelegt, ob der Dienst den Anrufer autorisieren soll, weiterzumachen oder nicht. Obwohl die Autorisierung nicht von der Authentifizierung abhängig ist, folgt sie normalerweise der Authentifizierung.
Confidentiality- Der Informationsaustausch zwischen einem Anrufer und einem Dienst wird vertraulich behandelt, um seine Interpretation durch andere Personen einzuschränken, für die die Nachricht nicht bestimmt ist. Um dies zu ermöglichen, wird die Verschlüsselung zusammen mit einer Vielzahl anderer Mechanismen verwendet.
Integrity - Das letzte Schlüsselkonzept ist die Wahrung der Integrität, dh die Gewissheit, dass die Nachricht auf ihrem Weg vom Absender zum Empfänger von niemandem manipuliert wurde.
Sicherheitsmodus übertragen
WCF bietet die folgenden Übertragungssicherheitsmodi, um eine sichere Kommunikation zwischen einem Client und einem Server sicherzustellen. Die verschiedenen Übertragungssicherheitsmodi werden unten erwähnt.
None- Dieser Modus garantiert keinerlei Nachrichtensicherheit und der Dienst erhält keine Anmeldeinformationen über den Client. Dieser Modus ist sehr riskant, da er möglicherweise Manipulationen an Nachrichten zulässt und daher nicht empfohlen wird.
<wsHttpBinding>
<binding name = "WCFSecurityExample">
<security mode = "None"/>
</binding>
</wsHttpBinding>Transport- Dieser Modus ist der einfachste Weg, um eine sichere Nachrichtenübertragung mithilfe von Kommunikationsprotokollen wie TCP, IPC, Https und MSMQ zu erreichen. Dieser Modus ist effektiver, wenn die Übertragung von Punkt zu Punkt erfolgt und hauptsächlich in einer kontrollierten Umgebung, dh in Intranetanwendungen, verwendet wird.
<wsHttpBinding>
<binding name = "WCFSecurityExample">
<security mode = "Transport"/>
</binding>
</wsHttpBinding>Message- Der Sicherheitsmodus ermöglicht die gegenseitige Authentifizierung und bietet in hohem Maße Datenschutz, da die Nachrichten verschlüsselt sind und über http transportiert werden können, was nicht als sicheres Protokoll angesehen wird. Hier wird die Sicherheit durchgängig bereitgestellt, ohne zu berücksichtigen, wie viele Vermittler an einer Nachrichtenübertragung beteiligt sind und ob ein gesicherter Transport vorliegt oder nicht. Der Modus wird normalerweise von Internetanwendungen verwendet.
<wsHttpBinding>
<binding name = "WCFSecurityExample">
<security mode = "Message"/>
</binding>
</wsHttpBinding>Mixed - Dieser Sicherheitsmodus wird nicht häufig verwendet und die Clientauthentifizierung wird nur auf Clientebene angeboten.
<wsHttpBinding>
<binding name = "WCFSecurityExample">
<security mode = "TransportWithMessageCredential"/>
</binding>
</wsHttpBinding>Both- Dieser Sicherheitsmodus umfasst sowohl Transportsicherheit als auch Nachrichtensicherheit, um eine robuste Sicherheitsabdeckung zu bieten, führt jedoch häufig zu einer Überlastung der Gesamtleistung. Dieser wird nur von MSMQ unterstützt.
<netMsmqBinding>
<binding name = "WCFSecurityExample">
<security mode = "Both"/>
</binding>
</netMsmqBinding>Alle WCF-Bindungen mit Ausnahme von BasicHttpBinding verfügen standardmäßig über ein gewisses Maß an Übertragungssicherheit.
Sicherheitsstufe für Nachrichten
Die Sicherheit auf Nachrichtenebene hängt nicht von den WCF-Protokollen ab. Es wird mit Nachrichtendaten selbst verwendet, indem die Daten unter Verwendung eines Standardalgorithmus verschlüsselt werden. Für verschiedene Bindungen für die Nachrichtensicherheitsstufe stehen eine Reihe von Clientanmeldeinformationen zur Verfügung, die im Folgenden erläutert werden.
Client credentials for message level security in WCF
None- Hier wird die Nachricht durch Verschlüsselung gesichert, während keine Clientauthentifizierung durchgeführt wird, sodass ein anonymer Client auf den Dienst zugreifen kann. Mit Ausnahme von BasicHttpBinding unterstützen alle WCF-Bindungen diesen Client-Berechtigungsnachweis. Es ist jedoch zu beachten, dass dieser Client-Berechtigungsnachweis für NetNamedPipeBinding überhaupt nicht verfügbar ist.
Windows- Hier finden sowohl die Nachrichtenverschlüsselung als auch die Clientauthentifizierung für einen in Echtzeit angemeldeten Benutzer statt. Auch in diesem Fall ist NetNamedPipeBinding im Gegensatz zu allen anderen WCF-Bindungen nicht verfügbar, und BasicHttpBinding bietet keine Unterstützung.
UserName- Hier werden Nachrichten verschlüsselt und durch Anbieten eines Benutzernamens gesichert, und Clients werden authentifiziert, wenn sie ein Kennwort angeben müssen. BasicHttpBinding unterstützt genau wie die beiden oben genannten Client-Anmeldeinformationen UserName nicht und ist für NetNamedPipeBinding nicht verfügbar.
Certificate- Zusammen mit der Nachrichtenverschlüsselung erhalten sowohl der Client als auch der Dienst eine Authentifizierung mit Zertifikat. Dieser Client-Berechtigungsnachweis ist verfügbar und wird von allen WCF-Bindungen mit Ausnahme von NetNamedPipeBinding unterstützt.
IssuedToken- Ausgestellte Token von einer Behörde wie Cardspace werden zur Authentifizierung der Nachrichten verwendet. Hier wird auch die Verschlüsselung von Nachrichten durchgeführt.
Der folgende Code zeigt, wie Client-Anmeldeinformationen in der Sicherheitsstufe / im Sicherheitsmodus für WCF-Nachrichten konfiguriert werden.
<netTcpBinding>
<binding name = "WCFMessageSecurityExample">
<security mode = "Message">
<message clientCredentialType = "None"/>
</security>
</binding>
</netTcpBinding>
<netMsmqBinding>...</netMsmqBinding>
</bindings>
<behaviors>...</behaviors>Hierbei ist zu beachten, dass der Transportsicherheitsmodus einen Vorteil gegenüber der Nachrichtensicherheitsstufe hat, da ersterer schneller ist. Es erfordert keine zusätzliche Codierung und bietet Interoperabilitätsunterstützung und verringert somit nicht die Gesamtleistung.
Unter Sicherheitsgesichtspunkten ist der Nachrichtensicherheitsmodus jedoch robuster, protokollunabhängig und bietet End-to-End-Sicherheit.
Ein WCF-Serviceentwickler kann auf einige unvorhergesehene Fehler stoßen, die eine geeignete Berichterstattung an den Client erfordern. Solche Fehler, bekannt alsexceptionswerden normalerweise mit Try / Catch-Blöcken behandelt, aber auch dies ist sehr technologiespezifisch.
Da es im Problembereich eines Clients nicht darum geht, wie ein Fehler aufgetreten ist oder welche Faktoren zu einem Fehler beitragen, wird der SOAP-Fehlervertrag verwendet, um die Fehlermeldung vom Dienst an den Client in WCF zu übermitteln.
Ein Fehlervertrag ermöglicht es dem Kunden, eine dokumentierte Ansicht der in einem Service aufgetretenen Fehler zu erhalten. Das folgende Beispiel gibt ein besseres Verständnis.
Step 1 - Mit der Divide-Operation wird ein einfacher Rechnerservice erstellt, der allgemeine Ausnahmen generiert.
using System;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Runtime.Serialization;
usingSystem.ServiceModel;
usingSystem.Text;
namespace Calculator {
// NOTE: You can use the "Rename" command on the "Refactor" menu to change
// the interface name "IService1" in both code and config file together.
[ServiceContract]
public interface IService1 {
[OperationContract]
int divide(int num1, int num2);
// TODO: Add your service operations here
}
}Die Codierung für die Klassendatei ist unten dargestellt -
Wenn wir nun versuchen, die Zahl 10 durch Null zu teilen, löst der Rechnerservice eine Ausnahme aus.
Die Ausnahme kann durch den try / catch-Block behandelt werden.
Wenn wir nun versuchen, eine Ganzzahl durch 0 zu teilen, wird der Wert 10 zurückgegeben, da wir ihn im catch-Block behandelt haben.
Step 2 - In diesem Schritt wird FaultException verwendet, um die Ausnahmeinformationen vom Dienst an den Client zu übermitteln.
public int Divide(int num1, int num2) {
//Do something
throw new FaultException("Error while dividing number");
}
Step 3- Es ist auch möglich, einen benutzerdefinierten Typ zum Senden der Fehlermeldung mit FaultContract zu erstellen. Die Schritte zum Erstellen eines benutzerdefinierten Typs sind nachstehend aufgeführt:
Ein Typ wird durch die Verwendung eines Datenvertrags definiert und die Felder, die zurückgegeben werden sollen, werden angegeben.
Die Serviceoperation wird durch das Attribut FaultContract dekoriert. Der Typname wird ebenfalls angegeben.
Eine Dienstinstanz wird erstellt, um Ausnahmen auszulösen, und benutzerdefinierte Ausnahmeeigenschaften werden zugewiesen.