Offenlegen von WCF-Diensten für Clientskript

Artikel
10/22/2014

Aktualisiert: November 2007

Windows Communication Foundation (WCF) ist das einheitliche Programmiermodell von Microsoft zum Erstellen von dienstorientierten Anwendungen. Es unterstützt ASP.NET-AJAX und das Datenformat JSON (JavaScript Object Notation). Das Modell ermöglicht WCF-Diensten das Offenlegen von Funktionalität für Webseiten, die ECMAScript (JavaScript) ausführen. Diese können auf die Dienste daher mithilfe von HTTP-Anforderungen zugreifen.

Wenn Sie bereits WCF-Dienste erstellt haben, können Sie Endpunkte hinzufügen, um Skript in AJAX-fähigen Webseiten den Zugriff auf diese Dienste zu ermöglichen. In diesem Thema wird beschrieben, wie ein WCF-Dienst für im Browser ausgeführtes JavaScript verfügbar gemacht wird.

Das .NET Framework erstellt für die WCF-Dienste zur Seitenladezeit automatisch JavaScript-Proxyklassen und lädt das Proxyklassenskript in den Browser herunter. Diese Proxyklassen werden von der Sys.Net.WebServiceProxy-Klasse in der Microsoft AJAX Library abgeleitet.

Sie können einen WCF-Dienstvorgang aufrufen, indem Sie die entsprechende Methode der JavaScript-Proxyklasse aufrufen. Weitere Informationen finden Sie unter Aufrufen von Webdiensten vom Clientskript.

Ermöglichen des Zugriffs auf einen WCF-Dienst aus Clientskript

Um den Zugriff auf einen WCF-Dienst aus Clientskript zu ermöglichen, müssen die folgenden Anforderungen erfüllt sein:

Der Dienst muss von einer Webanwendung gehostet werden, die eine Datei mit der Erweiterung SVC enthält. Diese Datei enthält eine @ ServiceHost-Direktive, die auf den WCF-Dienst zeigt. Das folgende Beispiel zeigt eine @ ServiceHost-Direktive.
```
<%@ ServiceHost Language=C# Service="Aspnet.Samples.SimpleService" CodeBehind="~/App_Code/SimpleService.cs"%> 
```
```
<%@ ServiceHost Language=VB Service="Aspnet.Samples.SimpleService" CodeBehind="~/App_Code/SimpleService.vb"%> 
```
Sie müssen die Webanwendung konfigurieren, um das Aufrufen von Webdiensten aus Skript zu unterstützen. Weitere Informationen finden Sie unter Gewusst wie: Konfigurieren von WCF-Diensten in ASP.NET AJAX.
Der Dienst muss eine Klasse sein, die eine mit ServiceContractAttribute gekennzeichnete Schnittstelle implementiert. Einzelne Dienstvorgänge (Methoden), die im Skript aufgerufen werden sollen, müssen mit dem OperationContractAttribute-Attribut qualifiziert werden.

Das folgende Beispiel zeigt eine Klasse, die eine Schnittstelle implementiert, die mit ServiceContractAttribute gekennzeichnet ist.

namespace Samples.Aspnet
{
    [ServiceContract(Namespace="MyServices.org")]
    public interface ISimpleService
    {
        [OperationContract]
        string HelloWorld1(string value1);
        [OperationContract]
        string HelloWorld2(DataContractType dataContractValue1);
    }

    [ServiceBehavior(IncludeExceptionDetailInFaults = true)]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class SimpleService : ISimpleService
    {
        public SimpleService()
        { }

        public string HelloWorld1(string value1)
        {
            return "Hello " + value1;
        }
        public string HelloWorld2(DataContractType dataContractValue1)
        {
            return "Hello " + dataContractValue1.FirstName +
                                " " + dataContractValue1.LastName;
        }
    }

    [DataContract]
    public class DataContractType
    {
        string firstName;
        string lastName;

        [DataMember]
        public string FirstName
        {
            get { return firstName; }
            set { firstName = value; }
        }
        [DataMember]
        public string LastName
        {
            get { return lastName; }
            set { lastName = value; }
        }
    }

Namespace Aspnet.Samples.SimpleService

    <ServiceContract(NameSpace="MyServices.org")> _
    Public Interface ISimpleService
        <OperationContract()> _
        Function HelloWorld1(ByVal value1 As String) As String
        <OperationContract()> _
        Function HelloWorld2(ByVal dataContractValue1 _
        As DataContractType) As String
    End Interface 'ISimpleService

    <ServiceBehavior(IncludeExceptionDetailInFaults:=True), _
    AspNetCompatibilityRequirements(RequirementsMode:= _
    AspNetCompatibilityRequirementsMode.Allowed)> _
    Public Class SimpleService
        Implements ISimpleService

        Public Sub New()

        End Sub 'New

        Public Function HelloWorld1(ByVal value1 As String) As String _
        Implements ISimpleService.HelloWorld1
            Return "Hello " + value1
        End Function 'HelloWorld1

        Public Function HelloWorld2(ByVal dataContractValue1 _
        As DataContractType) As String _
        Implements ISimpleService.HelloWorld2
            Return "Hello " + dataContractValue1.FirstName + " " + _
            dataContractValue1.LastName
        End Function 'HelloWorld2
    End Class 'SimpleService

    <DataContract()> _
    Public Class DataContractType
        Private _firstName As String
        Private _lastName As String


        <DataMember()> _
        Public Property FirstName() As String
            Get
                Return _firstName
            End Get
            Set(ByVal value As String)
                _firstName = value
            End Set
        End Property

        <DataMember()> _
        Public Property LastName() As String
            Get
                Return _lastName
            End Get
            Set(ByVal value As String)
                _lastName = value
            End Set
        End Property
    End Class 'DataContractType 
End Namespace

Weitere Informationen finden Sie unter Erstellen von WCF-Diensten für ASP.NET-AJAX (möglicherweise in englischer Sprache).

Verwenden eines WCF-Dienstes aus Clientskript auf einer ASP.NET-Webseite

Um einen WCF-Dienst aus Clientskript auf einer ASP.NET-Webseite aufzurufen, müssen Sie der Seite zuerst ein ScriptManager-Steuerelement hinzufügen. Sie können das ServiceReference-Objekt dann deklarativ festlegen, indem Sie dem ScriptManager-Steuerelement ein untergeordnetes asp:ServiceReference-Element hinzufügen und dessen path-Attribut auf den WCF-Dienst zeigen lassen. Das folgende Beispiel zeigt einen Dienstverweis.

<asp:ScriptManager ID="ScriptManager1" >
  <Services>
    <asp:ServiceReference 
      Path="http://<serverhost>/SimpleService.svc"/>
  </Services>
</asp:ScriptManager>

Das ServiceReference-Objekt kann nur in derselben Domäne auf einen Webdienst verweisen. Der Webdienstpfad kann ein relativer, ein zur Anwendung relativer, ein zur Domäne relativer oder ein absoluter Pfad sein. Bei absoluten Pfaden müssen Sie sicherstellen, dass sich der Pfad auf dieselbe Domäne bezieht.

Beim Rendern einer Seite, die dieses ScriptManager-Steuerelement enthält, wird von der Seite eine JavaScript-Proxyklasse für den WCF-Dienst erstellt. Die Proxyklasse verfügt über Funktionen, die jeweils einem einzelnen Dienstvorgang entsprechen. Die Seite enthält außerdem JavaScript-Proxyklassen, die den als Eingabeparameter oder Rückgabewerte für Webdienstmethoden verwendeten Serverdatentypen entsprechen. Dies ermöglicht Ihnen, Clientskript zur Initialisierung dieser Parameter zu schreiben und die Parameter dann dem Methodenaufruf zu übergeben.