Verwenden von Webdiensten in ASP.NET-AJAX

Artikel
10/22/2014

Aktualisiert: November 2007

In diesem Thema wird beschrieben, wie von Clientskript in AJAX-fähigen ASP.NET-Webseiten auf Webdienste zugegriffen wird. Diese Dienste können entweder selbst erstellte, benutzerdefinierte Dienste oder integrierte Anwendungsdienste sein. Die Anwendungsdienste werden als Teil von ASP.NET-AJAX bereitgestellt und umfassen Authentifizierungs-, Rollen- und Profildienste.

Benutzerdefinierte Webdienste können das Format von ASP.NET-Webdiensten (.asmx-Diensten) oder Windows Communication Foundation (WCF)-Diensten (.svc-Diensten) haben.

Dieses Thema enthält folgende Informationen:

Szenarien
Hintergrund
Beispiele
Zusätzliche Ressourcen
Klassenreferenz
Neues

Szenarien

WCF und ASP.NET wird in den folgenden Fällen verwendet:

Wenn Sie bereits WCF-Dienste erstellt haben, können Sie Endpunkte hinzufügen, um Skript in AJAX-fähigen Webseiten den Zugriff auf die Dienste zu ermöglichen. Weitere Informationen finden Sie unter Offenlegen von WCF-Diensten für Clientskript.
Wenn Sie bereits ASP.NET-Webdienste (.asmx) erstellt haben, können Sie diese bearbeiten, um Skript in AJAX-fähigen Webseiten den Zugriff auf diese Dienste zu ermöglichen. Weitere Informationen finden Sie unter Verfügbarmachen von Webdiensten für Clientskript.
Wenn Sie einen benutzerdefinierten Webdienst erstellen möchten, auf den in ASP.NET-AJAX-Webseiten zugegriffen werden soll, können Sie diesen als WCF-Dienst oder als ASP.NET-Webdienst (ASMX-Datei) implementieren.
Sie können die integrierten ASP.NET-Anwendungsdienste verwenden, um von Clientskript, das in einer AJAX-fähigen Webseite ausgeführt wird, auf Benutzerinformationen zu Authentifizierung, Rollen und Profilen zuzugreifen. Weitere Informationen finden Sie unter Verwenden der Formularauthentifizierung mit ASP.NET-AJAX.

Hintergrund

Mit ASP.NET können Sie Webdienste erstellen, auf die von Clientskript in Webseiten zugegriffen werden kann. Die Seiten kommunizieren mit dem Server über eine Kommunikationsebene für Webdienste, auf der mittels AJAX-Technologie Webdienstaufrufe ausgeführt werden. Die Daten werden asynchron zwischen Client und Server ausgetauscht, üblicherweise im JSON-Format.

Client/Server-Kommunikation für AJAX-Clients

Bei AJAX-fähigen Webseiten wird vom Browser eine anfängliche Anforderung an den Server für die Seite ausgeführt. Anschließend werden nachfolgende asynchrone Anforderungen für Daten an die Webdienste gesendet. Die Clientkommunikationselemente haben das Format heruntergeladener Proxyklassen des Servers sowie der Hauptbibliothek für Clientskript. Bei den Serverkommunikationselementen handelt es sich um Handler und benutzerdefinierte Dienste. Die folgende Abbildung zeigt die Elemente, die in die Kommunikation zwischen Client und Server eingebunden sind.

Client/Server-Kommunikation

AJAX-Clientarchitektur

Webdienstmethoden werden von Browsern mittels Proxyklassen aufgerufen. Eine Proxyklasse ist ein Skript, das automatisch vom Server generiert und beim Laden der Seite in den Browser heruntergeladen wird. Von der Proxyklasse wird ein Clientobjekt bereitgestellt, das die verfügbar gemachten Methoden eines Webdiensts darstellt.

Um eine Webdienstmethode aufzurufen, werden vom Clientskript die entsprechenden Methoden der Proxyklasse aufgerufen. Die Aufrufe werden asynchron durch das XMLHTTP-Objekt ausgeführt.

Die Kommunikationsebene für Webdienste enthält die Bibliothekskripttypen, mit deren Hilfe Proxyklassen Webdienstaufrufe durchführen können. Weitere Informationen finden Sie bei den im Sys.Net-Namespace enthaltenen Klassen.

Der Code in den Proxyklassen und in der Kernkommunikationsebene für Webdienste verbirgt die Komplexität von XMLHTTP und den Unterschieden zwischen Browsern. Dadurch wird das Clientskript vereinfacht, das für den Aufruf des Webdiensts erforderlich ist.

Für die Durchführung einer Webdienstanforderung gibt es zwei Ansätze:

Aufrufen der Webdienste unter Verwendung des HTTP-POST-Verbs. Eine POST-Anforderung enthält einen Hauptteil mit den Daten, die vom Browser an den Server gesendet werden. Eine Größeneinschränkung besteht nicht. Daher können Sie eine POST-Anforderung verwenden, wenn der Umfang der Daten die systeminterne Größeneinschränkung für eine GET-Anforderung überschreitet. Die Anforderung wird vom Client in das JSON-Format serialisiert und anschließend als POST-Daten an den Server gesendet. Der Server deserialisiert die JSON-Daten in .NET Framework-Typen und führt den eigentlichen Webdienstaufruf aus. Während der Antwort werden die Rückgabewerte vom Server serialisiert und zurück an den Client gesendet, der sie zur Verarbeitung wiederum in JavaScript-Objekte deserialisiert.

Aufrufen der Webdienste unter Verwendung des HTTP-GET-Verbs. Die Funktionalität ähnelt einer POST-Anforderung, jedoch mit den folgenden Unterschieden:

Der Client verwendet eine Abfragezeichenfolge, um die Parameter an den Server zu senden.
Von einer GET-Anforderung können nur Webdienstmethoden aufgerufen werden, die mithilfe des ScriptMethodAttribute-Attributs konfiguriert sind.

Die Datengröße ist auf die vom Browser zugelassene URL-Länge beschränkt.

Hinweis:
GET-Anforderungen sollten bei Methodenaufrufen vermieden werden, bei denen Daten auf dem Server geändert werden oder die wichtige Informationen enthalten. Bei GET-Anforderungen wird die Nachricht vom Browser in die URL codiert und kann daher leichter ein Ziel für unerlaubtes Eingreifen darstellen. Bei GET- und POST-Anforderungen sollten Sie zum Schutz vertraulicher Daten Sicherheitsrichtlinien befolgen.

GET-Anforderungen sollten bei Methodenaufrufen vermieden werden, bei denen Daten auf dem Server geändert werden oder die wichtige Informationen enthalten. Bei GET-Anforderungen wird die Nachricht vom Browser in die URL codiert und kann daher leichter ein Ziel für unerlaubtes Eingreifen darstellen. Bei GET- und POST-Anforderungen sollten Sie zum Schutz vertraulicher Daten Sicherheitsrichtlinien befolgen.

Die folgende Abbildung zeigt die ASP.NET-AJAX-Clientarchitektur.

AJAX-Clientarchitektur

Zu den Elementen der Clientarchitektur zählen die Kommunikationsebene für Webdienste in der Hauptbibliothek sowie die heruntergeladenen Proxyklassen für die in der Seite verwendeten Dienste. Die folgenden einzelnen Elemente sind in der Abbildung enthalten:

Benutzerdefinierte Dienstproxyklassen. Diese bestehen aus Clientskript, das automatisch vom Server generiert und in den Browser heruntergeladen wird. Die Proxyklassen enthalten ein Objekt für jeden in der Seite verwendeten WCF- oder ASMX-Dienst. (Das bedeutet, sie enthalten ein Objekt für jedes Element im ServiceReferences-Element des ScriptManager-Steuerelements in der Seite.) Beim Aufrufen einer Proxymethode im Clientskript wird eine asynchrone Anforderung an die entsprechende Webdienstmethode auf dem Server erstellt.
Authentifizierungsproxyklasse. Die AuthenticationService-Proxyklasse wird vom Anwendungsdienst für die Serverauthentifizierung generiert. Dadurch kann sich der Benutzer über JavaScript im Browser an- oder abmelden, ohne dass ein Roundtrip zum Server erforderlich ist.
Rollenproxyklasse. Die RoleService-Proxyklasse wird vom Anwendungsdienst für Serverrollen generiert. Dadurch können Sie Benutzer gruppieren und jede Gruppe über JavaScript als Einheit behandeln, ohne dass Roundtrips zum Server erforderlich sind. Dies kann nützlich sein, um den Zugriff auf Ressourcen des Servers zu gewähren oder zu verweigern.
Profilproxyklasse. Die ProfileService-Klasse wird vom Anwendungsdienst für Serverprofile generiert. Dadurch werden die Profilinformationen des jeweiligen Benutzers für den Client über JavaScript verfügbar gemacht, ohne dass Roundtrips zum Server erforderlich sind.
Seitenmethodenproxyklasse. Dadurch wird die Skriptinfrastruktur für Clientskript zum Aufrufen statischer Methoden in einer ASP.NET-Seite bereitgestellt, als seien es Webdienstmethoden. Weitere Informationen finden Sie unter Aufrufen von Webdiensten vom Clientskript.
Kommunikationsebene für Webdienste. Dies ist die Bibliothek, die die Clientskripttypen enthält. Mithilfe dieser Typen kann der Browser (Client) mit den Diensten auf dem Server kommunizieren. Sie bewahren Clientanwendungen außerdem vor der Komplexität des Aufbaus und Aufrechterhaltens der asynchronen Kommunikation zwischen Client und Server. Sie kapseln das XMLHTTP-Objekt des Browsers, mit dem die asynchrone Funktionalität bereitgestellt wird, und ermöglichen, dass Clientanwendungen unabhängig vom Browser funktionieren. Die Kommunikationsebene für Webdienste umfasst folgende Hauptelemente:
- WebRequest. Dadurch wird die Clientskriptfunktionalität zum Durchführen einer Webanforderung bereitgestellt. Weitere Informationen finden Sie im Zusammenhang mit der WebRequest-Klasse.
- WebRequestManager. Dadurch wird der Fluss von Webanforderungen verwaltet, die vom WebRequest-Objekt an das zugehörige Executorobjekt ausgegeben werden. Weitere Informationen finden Sie in den Ausführungen zur WebRequestManager-Klasse.
- XmlHttpExecutor. Dadurch werden mithilfe der XMLHTTP-Unterstützung des Browsers asynchrone Netzwerkanforderungen ausgeführt. Weitere Informationen finden Sie in den Ausführungen zur XmlHttpExecutor-Klasse.
- JSON-Serialisierung. Dabei werden JavaScript-Objekte in das JSON-Format serialisiert. Die Deserialisierung wird mithilfe der JavaScript eval-Funktion durchgeführt. Weitere Informationen finden Sie in den Ausführungen zur JavaScriptSerializer-Klasse.

Das Standardformat für die Serialisierung ist JSON, einzelne Methoden in Webdiensten und in ASP.NET-Webseiten können jedoch alternative Formate wie XML zurückgeben. Das Serialisierungsformat einer Methode kann durch Attribute angegeben werden. Beispielsweise können Sie für einen ASMX-Dienst das ScriptMethodAttribute-Attribut so festlegen, dass eine Webdienstmethode XML-Daten zurückgibt, wie im folgenden Beispiel gezeigt wird:

[ScriptMethod(ResponseFormat.Xml)] 

<ScriptMethod(ResponseFormat.Xml)>

AJAX-Serverarchitektur

In der folgenden Abbildung wird die AJAX-Serverarchitektur mit den Elementen dargestellt, die die Kommunikation mit Clientanwendungen ermöglichen.

AJAX-Serverarchitektur

Zu den Elementen der Serverarchitektur zählen die Kommunikationsebene für Webdienste mit einem HTTP-Handler sowie Serialisierungsklassen, benutzerdefinierte Dienste, Seitenmethoden und Anwendungsdienste. Die folgenden einzelnen Elemente sind in der Abbildung enthalten:

Benutzerdefinierte Webdienste. Dadurch wird die von Ihnen implementierte Dienstfunktionalität bereitgestellt und die entsprechende Antwort an den Client zurückgegeben. Benutzerdefinierte Webdienste können ASP.NET- oder WCF-Dienste sein. Von der Kommunikationsebene für Webdienste werden automatisch Clientskript-Proxyklassen generiert, die asynchron von Clientskript aufgerufen werden können.
Seitenmethoden. Mithilfe dieser Komponente kann eine Methode in einer ASP.NET-Seite so aufgerufen werden, als handele es sich um eine Webdienstmethode. Seitenmethoden müssen in der Seite definiert werden, die den Seitenmethodenaufruf durchführt.
Authentifizierungsdienst. Vom Authentifizierungsdienst wird eine Authentifizierungsproxyklasse generiert, durch die sich Benutzer über clientseitiges JavaScript an- oder abmelden können. Dieser Anwendungsdienst ist immer verfügbar und muss nicht instanziiert werden. Weitere Informationen finden Sie unter Verwenden der Formularauthentifizierung mit ASP.NET-AJAX.
Rollendienst. Vom Rollendienst wird eine Rollenproxyklasse erstellt, durch die clientseitiges JavaScript auf Rolleninformationen für den jeweils authentifizierten Benutzer zugreifen kann. Dieser Anwendungsdienst ist immer verfügbar und muss nicht instanziiert werden. Weitere Informationen finden Sie unter Verwenden von Rolleninformationen mit ASP.NET-AJAX.
Profildienst. Vom Profildienst wird eine Profilproxyklasse generiert, durch die clientseitiges JavaScript Profileigenschaften für den zur jeweiligen Anforderung gehörenden Benutzer abrufen und festlegen kann. Dieser Anwendungsdienst ist immer verfügbar und muss nicht instanziiert werden. Weitere Informationen finden Sie unter Verwenden von Profilinformationen mit ASP.NET-AJAX.
JSON-Serialisierung. Die JSON-Serialisierungskomponente des Servers ermöglicht eine anpassbare Serialisierung und Deserialisierung allgemeiner .NET Framework-Typen in das JSON-Format und umgekehrt. Weitere Informationen finden Sie unter JavaScriptSerializer.
XML-Serialisierung. Die Kommunikationsebene für Webdienste unterstützt die XML-Serialisierung für SOAP-Anforderungen an Webdienste und für die Rückgabe von XML-Typen von einer JSON-Anforderung an einen Webdienst.

Beispiele

In den folgenden Beispielen wird gezeigt, wie ASP.NET- und WCF-Dienste von Clientskript aufgerufen werden. Beispiele dafür, wie Anwendungsdienste von Clientskript aufgerufen werden, sind in anderen Abschnitten der Dokumentation enthalten. Die zugehörigen Links sind weiter unten in diesem Thema enthalten.

Aufrufen von Webdienstmethoden in AJAX

Mit .NET Framework können Sie Methoden von ASP.NET-Webdiensten (.asmx) mithilfe von Clientskript asynchron über den Browser aufrufen. Serverbasierte Methoden können von dieser Seite ohne Postback und ohne Aktualisierung der ganzen Seite aufgerufen werden, da zwischen dem Browser und dem Server lediglich Daten übertragen werden.

Im folgenden Beispiel wird gezeigt, wie eine Webdienstmethode in einer ASP.NET-Webseite verfügbar gemacht wird.

<%@ Page Language="VB" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

    <head id="Head1" >
        <style type="text/css">
            body {  font: 11pt Trebuchet MS;
                    font-color: #000000;
                    padding-top: 72px;
                    text-align: center }

            .text { font: 8pt Trebuchet MS }
        </style>

        <title>Simple Web Service</title>

            <script type="text/javascript">

            // This function calls the Web Service method.  
            function GetServerTime()
            {
                Samples.AspNet.ServerTime.GetServerTime(OnSucceeded);
            }

            // This is the callback function that
            // processes the Web Service return value.
            function OnSucceeded(result)
            {
                var RsltElem = document.getElementById("Results");
                RsltElem.innerHTML = result;
            }

        </script>

    </head>

    <body>
        <form id="Form1" >
         <asp:ScriptManager  ID="scriptManager">
                <Services>
                    <asp:ServiceReference path="ServerTime.asmx" />
                </Services>
            </asp:ScriptManager>
            <div>
                <h2>Server Time</h2>
                    <p>Calling a service that returns the current server time.</p>

                    <input id="EchoButton" type="button" 
                        value="GetTime" onclick="GetServerTime()" />
            </div>
        </form>

        <hr/>

        <div>
            <span id="Results"></span>
        </div>   

    </body>

</html>

<%@ Page Language="C#" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

    <head id="Head1" >
        <style type="text/css">
            body {  font: 11pt Trebuchet MS;
                    font-color: #000000;
                    padding-top: 72px;
                    text-align: center }

            .text { font: 8pt Trebuchet MS }
        </style>

        <title>Simple Web Service</title>

            <script type="text/javascript">

            // This function calls the Web Service method.  
            function GetServerTime()
            {
                Samples.AspNet.ServerTime.GetServerTime(OnSucceeded);
            }

            // This is the callback function that
            // processes the Web Service return value.
            function OnSucceeded(result)
            {
                var RsltElem = document.getElementById("Results");
                RsltElem.innerHTML = result;
            }

        </script>

    </head>

    <body>
        <form id="Form1" >
         <asp:ScriptManager  ID="scriptManager">
                <Services>
                    <asp:ServiceReference path="ServerTime.asmx" />
                </Services>
            </asp:ScriptManager>
            <div>
                <h2>Server Time</h2>
                    <p>Calling a service that returns the current server time.</p>

                    <input id="EchoButton" type="button" 
                        value="GetTime" onclick="GetServerTime()" />
            </div>
        </form>

        <hr/>

        <div>
            <span id="Results"></span>
        </div>   

    </body>

</html>

Das folgende Beispiel zeigt eine Webseite und den zugehörigen Webdienst, der vom Seitenskript aufgerufen wird.

<%@ WebService Language="VB" Class="Samples.AspNet.ServerTime" %>

Imports System.Web
Imports System.Web.Services
Imports System.Xml
Imports System.Web.Services.Protocols
Imports System.Web.Script.Services

Namespace Samples.AspNet

    <WebService(Namespace:="http://tempuri.org/")> _
    <WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
    <ScriptService()> _
    Public Class ServerTime
        Inherits System.Web.Services.WebService

        <WebMethod()> _
        Public Function GetServerTime() As String
            Return String.Format("The current time is {0}.", _
                DateTime.Now)

        End Function
    End Class

End Namespace

<%@ WebService Language="C#" Class="Samples.AspNet.ServerTime" %>

using System;
using System.Web;
using System.Web.Services;
using System.Xml;
using System.Web.Services.Protocols;
using System.Web.Script.Services;

namespace Samples.AspNet
{

    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [ScriptService]
    public class ServerTime : System.Web.Services.WebService
    {

        [WebMethod]
        public string GetServerTime()
        {
            return String.Format("The server time is {0}.", 
                DateTime.Now);

        }

    }

}

Durchführen von HTTP-Anforderungen von einem AJAX-Client aus

Im vorherigen Beispiel wird gezeigt, wie Webdienste in Clientskript aufgerufen werden, indem die automatisch generierten Proxyklassen für den Webdienst aufgerufen werden. Von Clientskript können auch Aufrufe auf niedrigerer Ebene an Webdienste ausgeführt werden. Dies kann der Fall sein, wenn die Kommunikationsebene verwaltet werden muss oder die Daten, die vom oder an den Server gesendet werden, überprüft werden müssen. Zum Aufrufen von Webdiensten auf diese Weise wird die WebRequest-Klasse verwendet.

Im folgenden Beispiel wird gezeigt, wie mithilfe eines WebRequest-Objekts GET- und POST-Webanforderungen implementiert werden, die eine Verbindung mit den angegeben URLs (HTTP-Endpunkten) herstellen.

// ConnectingEndPoints.js

var resultElement;

function pageLoad()
{
    resultElement = $get("ResultId");
}

// This function performs a GET Web request.
function GetWebRequest()
{
    alert("Performing Get Web request.");

    // Instantiate a WebRequest.
    var wRequest = new Sys.Net.WebRequest();

    // Set the request URL.      
    wRequest.set_url("getTarget.htm");
    alert("Target Url: getTarget.htm");

    // Set the request verb.
    wRequest.set_httpVerb("GET");

    // Set the request callback function.
    wRequest.add_completed(OnWebRequestCompleted);

    // Clear the results area.
    resultElement.innerHTML = "";

    // Execute the request.
    wRequest.invoke();  
}

// This function performs a POST Web request.
function PostWebRequest()
{
    alert("Performing Post Web request.");

    // Instantiate a WebRequest.
    var wRequest = new Sys.Net.WebRequest();

    // Set the request URL.      
    wRequest.set_url("postTarget.aspx");
    alert("Target Url: postTarget.aspx");

    // Set the request verb.
    wRequest.set_httpVerb("POST");

    // Set the request handler.
    wRequest.add_completed(OnWebRequestCompleted);

    // Set the body for he POST.
    var requestBody = 
        "Message=Hello! Do you hear me?";
    wRequest.set_body(requestBody);
    wRequest.get_headers()["Content-Length"] = 
        requestBody.length;

    // Clear the results area.
   resultElement.innerHTML = "";

    // Execute the request.
    wRequest.invoke();              
}


// This callback function processes the 
// request return values. It is called asynchronously 
// by the current executor.
function OnWebRequestCompleted(executor, eventArgs) 
{    
    if(executor.get_responseAvailable()) 
    {
        // Clear the previous results. 

       resultElement.innerHTML = "";

        // Display Web request status. 
       resultElement.innerHTML +=
          "Status: [" + executor.get_statusCode() + " " + 
                    executor.get_statusText() + "]" + "<br/>";

        // Display Web request headers.
       resultElement.innerHTML += 
            "Headers: ";

       resultElement.innerHTML += 
            executor.getAllResponseHeaders() + "<br/>";

        // Display Web request body.
       resultElement.innerHTML += 
            "Body:";

      if(document.all)
        resultElement.innerText += 
           executor.get_responseData();
      else
        resultElement.textContent += 
           executor.get_responseData();
    }

}
if (typeof(Sys) !== "undefined") Sys.Application.notifyScriptLoaded();

Aufrufen von WCF-Dienstvorgängen in AJAX

Windows Communication Foundation (WCF)-Dienste (.svc) können im Grunde wie ASMX-basierte Dienste asynchron in Clientskript aufgerufen werden. Im folgenden Beispiel wird gezeigt, wie WCF-Dienstvorgänge für eine ASP.NET-Webseite verfügbar gemacht und aufgerufen werden.

<%@ Page Language="VB" AutoEventWireup="true" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head >
    <style type="text/css">
        body {  font: 11pt Trebuchet MS;
                font-color: #000000;
                padding-top: 72px;
                text-align: center }

        .text { font: 8pt Trebuchet MS }
    </style>
    <title>Simple WCF Service Page</title>

</head>
<body>
    <form id="form1" >
        <asp:ScriptManager ID="ScriptManager1" >
            <Services>
                <asp:ServiceReference 
                    Path="SimpleService.svc/ws"/>
            </Services>
            <Scripts>
                <asp:ScriptReference Path="service.js" />
            </Scripts>
        </asp:ScriptManager>
        
        <div>
            <h2>Simple WCF Service</h2>
            <input type='button' name="clickme"  value="Greetings" 
                onclick="javascript:OnClick()" /> &nbsp; &nbsp;
            <input type='button' name="clickme2"  value="Greetings2" 
                onclick="javascript:OnClick2()" />
            <hr/>
            <div>
                <span id="Results"></span>
            </div> 
        </div>

    </form>
</body>
</html>

<%@ Page Language="C#" AutoEventWireup="true"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head >
    <style type="text/css">
        body {  font: 11pt Trebuchet MS;
                font-color: #000000;
                padding-top: 72px;
                text-align: center }

        .text { font: 8pt Trebuchet MS }
    </style>
    <title>Simple WCF Service Page</title>

</head>
<body>
    <form id="form1" >
        <asp:ScriptManager ID="ScriptManager1" >
            <Services>
                <asp:ServiceReference 
                    Path="SimpleService.svc/ws"/>
            </Services>
            <Scripts>
                <asp:ScriptReference Path="service.js" />
            </Scripts>
        </asp:ScriptManager>
        
        <div>
            <h2>Simple WCF Service</h2>
            <input type='button' name="clickme"  value="Greetings" 
                onclick="javascript:OnClick()" /> &nbsp; &nbsp;
            <input type='button' name="clickme2"  value="Greetings2" 
                onclick="javascript:OnClick2()" />
            <hr/>
            <div>
                <span id="Results"></span>
            </div> 
        </div>

    </form>
</body>
</html>

var ServiceProxy;

function pageLoad()
{
    ServiceProxy = new ISimpleService();
    ServiceProxy.set_defaultSucceededCallback(SucceededCallback);
}

function OnClick()
{
    // var myService = new ISimpleService();
    ServiceProxy.HelloWorld1("George");
}

function OnClick2()
{
    var dc = new DataContractType();
    dc.FirstName = "George";
    dc.LastName = "Washington";
    ServiceProxy.HelloWorld2(dc);      
}

// This is the callback function that
// processes the Web Service return value.
function SucceededCallback(result, userContext, methodName)
{
    var RsltElem = document.getElementById("Results");
    RsltElem.innerHTML = result + " from " + methodName + ".";
}
if (typeof(Sys) !== "undefined") Sys.Application.notifyScriptLoaded();

Imports System
Imports System.Web
Imports System.Collections
Imports System.Collections.Generic
Imports System.Threading
Imports System.Xml
Imports System.Xml.Serialization
Imports System.Text
Imports System.IO
Imports System.Runtime.Serialization
Imports System.ServiceModel
Imports System.ServiceModel.Description
Imports System.ServiceModel.Dispatcher
Imports System.ServiceModel.Channels
Imports System.ServiceModel.Activation


' This a WCF service which consists of a contract, 
' defined below as ISimpleService, and DataContractType, 
' a class which implements that interface, see SimpleService, 
' and configuration entries that specify behaviors associated with 
' that implementation (see <system.serviceModel> in web.config)
Namespace Aspnet.Samples.SimpleService

    <ServiceContract()> _
    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

using System;
using System.Web;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.Xml;
using System.Xml.Serialization;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Channels;
using System.ServiceModel.Activation;

// This a WCF service which consists of a contract, 
// defined below as ISimpleService, and DataContractType, 
// a class which implements that interface, see SimpleService, 
// and configuration entries that specify behaviors associated with 
// that implementation (see <system.serviceModel> in web.config)

namespace Aspnet.Samples
{
    [ServiceContract()]
    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; }
        }
    }

}

Weitere Beispiele

Zurück nach oben

Klassenreferenz

In den folgenden Tabellen werden die Hauptklassen aufgeführt, die mit Webdiensten verknüpft sind, die von Clientskript aufgerufen werden können.

Clientnamespaces

Name	Beschreibung
Sys.Net-Namespace	Enthält Klassen, mit denen die Kommunikation zwischen ASP.NET-AJAX-Clientanwendungen und Webdiensten auf dem Server verwaltet werden. Der Sys.Net-Namespace ist Teil von Microsoft AJAX Library.
Sys.Serialization-Namespace	Enthält Klassen für die Datenserialisierung in ASP.NET-AJAX-Clientanwendungen.
Sys.Services-Namespace	Enthält Typen, die in ASP.NET-AJAX-Clientanwendungen den Skriptzugriff auf den Authentifizierungsdienst, Profildienst und andere Anwendungsdienste von ASP.NET ermöglichen. Der Sys.Services-Namespace ist Teil von Microsoft AJAX Library.

Servernamespaces

Name	Beschreibung
System.Web.Script.Serialization	Enthält Klassen, die Serialisierung und Deserialisierung im JSON-Format (JavaScript Object Notation) ermöglichen. Außerdem werden Erweiterungsfeatures zum Anpassen des Serialisierungsverhaltens bereitgestellt.