Condividi tramite

Utilizzo dei servizi Web in ASP.NET AJAX

  • Articolo

Aggiornamento: novembre 2007

In questo argomento viene descritto come accedere ai servizi Web da script client nelle pagine Web ASP.NET con supporto AJAX. I servizi possono essere servizi personalizzati creati dall'utente o servizi dell'applicazione incorporati. I servizi dell'applicazione sono forniti come parte di ASP.NET AJAX e includono autenticazione, ruoli e servizi profili.

I servizi Web personalizzati possono essere servizi Web ASP.NET (ASMX) o servizi Windows Communication Foundation (WCF) (SVC).

Di seguito sono riportate le informazioni contenute nel presente argomento:

  • Scenari

  • Informazioni di supporto

  • Esempi

  • Risorse supplementari

  • Riferimento alle classi

  • Novità

Scenari

WCF e ASP.NET sono utilizzati nei seguenti casi:

  • Se sono già stati creati servizi WCF, è possibile aggiungere endpoint per consentirne l'accesso allo script nelle pagine Web con supporto AJAX. Per ulteriori informazioni, vedere Esposizione di servizi WCF a script client.

  • Se sono già stati creati servizi Web ASP.NET (ASMX), è possibile modificarli per consentirne l'accesso allo script nelle pagine Web con supporto AJAX. Per ulteriori informazioni, vedere Esposizione di servizi Web a script client.

  • Per creare un servizio Web personalizzato al quale si accederà dalle pagine Web ASP.NET AJAX, è possibile implementarlo come servizio WCF o come servizio Web ASP.NET (file ASMX).

  • È possibile utilizzare i servizi delle applicazioni ASP.NET incorporati per accedere all'autenticazione di utenti, ai ruoli e alle informazioni sul profilo da script client in esecuzione in una pagina Web con supporto AJAX. Per ulteriori informazioni, vedere Utilizzo dell'autenticazione basata su form con ASP.NET AJAX.

Informazioni di supporto

ASP.NET consente di creare servizi Web ai quali è possibile accedere da script client nelle pagine Web. Le pagine comunicano con il server tramite un livello di comunicazione dei servizi Web che utilizza la tecnologia AJAX per effettuare le chiamate a tali servizi. I dati vengono scambiati in modo asincrono fra client e server, in genere nel formato JSON.

Comunicazione client-server per client AJAX

Nelle pagine Web con supporto AJAX il browser effettua una richiesta iniziale al server per la pagina, quindi effettua richieste asincrone successive ai servizi Web per i dati. Gli elementi di comunicazione del client sono le classi proxy scaricate dal server e la libreria di script client di base. Gli elementi di comunicazione del server sono gestori e servizi personalizzati. Nell'illustrazione seguente vengono mostrati gli elementi coinvolti nella comunicazione tra il client e il server.

Comunicazione client-server

Architettura client AJAX

I browser chiamano i metodi dei servizi Web utilizzando le classi proxy. Una classe proxy è uno script generato automaticamente dal server e scaricato nel browser durante il caricamento della pagina. Fornisce un oggetto client che rappresenta i metodi esposti di un servizio Web.

Per chiamare un metodo del servizio Web, lo script client chiama i metodi corrispondenti della classe proxy. Le chiamate vengono eseguite in modo asincrono, tramite l'oggetto XMLHTTP (informazioni in lingua inglese).

Il livello di comunicazione dei servizi Web contiene i tipi di script della libreria che consentono alle classi proxy di effettuare le chiamate ai servizi. Per ulteriori informazioni, vedere le classi contenute nello spazio dei nomi Sys.Net.

Il codice nelle classi proxy e nel livello di comunicazione dei servizi Web principale nasconde la complessità di XMLHTTP (informazioni in lingua inglese) e le differenze tra browser. Ciò semplifica lo script client necessario per chiamare il servizio Web.

Esistono due approcci per effettuare una richiesta di servizio Web:

  • Chiamare i servizi Web utilizzando il verbo HTTP POST. Una richiesta POST è costituita da un corpo contenente i dati che il browser invia al server. Non vi sono limitazioni di dimensione. Pertanto, è possibile utilizzare una richiesta POST quando la dimensione dei dati supera la limitazione di dimensione intrinseca per una richiesta GET. Il client serializza la richiesta in formato JSON e la invia al server sotto forma di dati POST. Il server deserializza i dati JSON in tipi°.NET Framework ed effettua la chiamata al servizio Web effettiva. Durante la risposta, il server serializza i valori restituiti e li passa nuovamente al client, il quale li deserializza in oggetti JavaScript per l'elaborazione.

  • Chiamare i servizi Web utilizzando il verbo HTTP GET. La funzionalità è simile a quella di una richiesta POST, con le seguenti differenze:

    • Il client utilizza una stringa di query per inviare i parametri al server.

    • Una richiesta GET può chiamare solo un metodo del servizio Web configurato tramite l'attributo ScriptMethodAttribute.

    • La dimensione dei dati è limitata alla lunghezza dell'URL consentita dal browser.

      Nota:

      È preferibile evitare le richieste GET nel caso di chiamate al metodo che modificano i dati nel server o che espongono informazioni critiche. Nelle richieste GET il messaggio viene codificato dal browser nell'URL, pertanto è maggiormente soggetto al rischio di alterazione. Per entrambi i tipi di richiesta è necessario attenersi alle linee guida di sicurezza al fine di proteggere i dati sensibili.

Nell'illustrazione seguente viene mostrata l'architettura client ASP.NET AJAX.

Architettura client AJAX

Gli elementi dell'architettura client includono il livello di comunicazione dei servizi Web nella libreria principale e le classi proxy scaricate per i servizi utilizzati nella pagina. Di seguito sono riportati i singoli elementi illustrati nella figura:

  • Classi proxy dei servizi personalizzati. Si tratta di script client generato automaticamente dal server e scaricato nel browser. Le classi proxy forniscono un oggetto per ogni servizio WCF o ASMX utilizzato nella pagina. Vale a dire, forniscono un oggetto per ciascun elemento contenuto nell'elemento ServiceReferences del controllo ScriptManager nella pagina. La chiamata a un metodo proxy nello script client crea una richiesta asincrona al metodo del servizio Web corrispondente nel server.

  • Classe proxy Authentication. La classe proxy AuthenticationService viene generata dal servizio dell'applicazione di autenticazione del server. Consente all'utente di connettersi o disconnettersi tramite JavaScript nel browser senza effettuare un round trip nel server.

  • Classe proxy Role. La classe proxy RoleService viene generata dal servizio dell'applicazione dei ruoli del server. Consente di raggruppare gli utenti e trattare ogni gruppo alla stregua di un'unità tramite JavaScript senza effettuare round trip nel server. Può rivelarsi utile per consentire o negare l'accesso alle risorse nel server.

  • Classe proxy Profile. La classe ProfileService viene generata dal servizio dell'applicazione dei profili del server. Rende le informazioni sul profilo dell'utente corrente disponibili per il client tramite JavaScript senza effettuare round trip nel server.

  • Classe proxy Page Methods. Fornisce l'infrastruttura di scripting che consente allo script client di chiamare i metodi statici in una pagina ASP.NET come fossero metodi del servizio Web. Per ulteriori informazioni, vedere Chiamata a servizi Web da script client.

  • Livello di comunicazione dei servizi Web. Si tratta della libreria che contiene i tipi di script client. Questi tipi consentono al browser (client) di comunicare con i servizi nel server. Proteggono inoltre le applicazioni client dalle complessità che insorgono quando si stabilisce e gestisce la comunicazione asincrona fra client e server. Incapsulano l'oggetto XMLHTTP del browser che fornisce la funzionalità asincrona e consentono alle applicazioni client di essere indipendenti dal browser. Vengono di seguito riportati gli elementi principali del livello di comunicazione dei servizi Web:

    • WebRequest. Fornisce la funzionalità dello script client per effettuare una richiesta Web. Per ulteriori informazioni, vedere la classe WebRequest.

    • WebRequestManager. Gestisce il flusso delle richieste Web rilasciate dall'oggetto WebRequest all'oggetto esecutore associato. Per ulteriori informazioni, vedere la classe WebRequestManager.

    • XmlHttpExecutor. Effettua richieste di rete asincrone utilizzando il supporto XMLHTTP del browser. Per ulteriori informazioni, vedere la classe XmlHttpExecutor.

    • Serializzazione JSON. Serializza oggetti JavaScript in formato JSON. Per la deserializzazione, utilizzare la funzione eval di JavaScript. Per ulteriori informazioni, vedere la classe JavaScriptSerializer.

Il formato di serializzazione predefinito è JSON, ma è possibile che i singoli metodi nei servizi Web e nelle pagine Web ASP.NET restituiscano formati alternativi, ad esempio XML. Il formato di serializzazione di un metodo può essere specificato mediante attributi. Ad esempio, per un servizio ASMX, è possibile impostare l'attributo ScriptMethodAttribute in modo tale che un metodo del servizio Web restituisca dati XML, come illustrato nell'esempio che segue:

[ScriptMethod(ResponseFormat.Xml)] 

<ScriptMethod(ResponseFormat.Xml)>

Architettura server AJAX

Nell'illustrazione seguente viene mostrata l'architettura server AJAX, la quale include gli elementi che consentono la comunicazione con le applicazioni client.

Architettura server AJAX

Gli elementi dell'architettura server includono il livello di comunicazione dei servizi Web con un gestore HTTP e classi di serializzazione, servizi personalizzati, metodi di pagina e servizi dell'applicazione. Vengono di seguito riportati i singoli elementi illustrati nella figura:

  • Servizi Web personalizzati. Forniscono la funzionalità dei servizi implementata e restituiscono la risposta appropriata al client. I servizi Web personalizzati possono essere servizi ASP.NET o WCF. Il livello di comunicazione dei servizi Web genera automaticamente classi proxy di script client che possono essere chiamate in modo asincrono da script client.

  • Metodi di pagina. Questo componente consente di chiamare un metodo in una pagina ASP.NET come fosse un metodo del servizio Web. I metodi di pagina devono essere definiti nella pagina che esegue la chiamata a tali metodi.

  • Servizio di autenticazione. Genera una classe proxy di autenticazione che consente all'utente di connettersi e disconnettersi tramite JavaScript sul lato client. Questo servizio dell'applicazione è sempre disponibile e non è necessario crearne un'istanza. Per ulteriori informazioni, vedere Utilizzo dell'autenticazione basata su form con ASP.NET AJAX.

  • Servizio ruolo. Genera una classe proxy del ruolo che consente a JavaScript sul lato client di accedere alle informazioni sui ruoli per l'utente attualmente autenticato. Questo servizio dell'applicazione è sempre disponibile e non è necessario crearne un'istanza. Per ulteriori informazioni, vedere Utilizzo delle informazioni sui ruoli con ASP.NET AJAX.

  • Servizio profili. Genera una classe proxy del profilo che consente a JavaScript sul lato client di ottenere e impostare le proprietà del profilo per l'utente associato alla richiesta corrente. Questo servizio dell'applicazione è sempre disponibile e non è necessario crearne un'istanza. Per ulteriori informazioni, vedere Utilizzo delle informazioni sul profilo con ASP.NET AJAX.

  • Serializzazione JSON. Il componente di serializzazione JSON del server consente la serializzazione e deserializzazione personalizzabile di tipi°.NET Framework comuni nel e dal formato JSON. Per ulteriori informazioni, vedere JavaScriptSerializer.

  • Serializzazione XML. Il livello di comunicazione dei servizi Web supporta la serializzazione XML per le richieste SOAP ai servizi Web e per la restituzione di tipi XML da una richiesta JSON a un servizio Web.

Esempi

Negli esempi seguenti viene illustrato come chiamare i servizi ASP.NET e WCF da script client. Esempi di chiamata ai servizi dell'applicazione da script client vengono forniti in altre sezioni della documentazione. I relativi collegamenti saranno forniti più avanti in questo argomento.

Chiamata ai metodi dei servizi Web in AJAX

.NET Framework consente di chiamare in modo asincrono i metodi dei servizi Web ASP.NET (ASMX) dal browser tramite script client. La pagina può chiamare metodi basati su server senza alcun postback e senza aggiornare l'intera pagina, poiché solo i dati vengono trasferiti tra il browser e il server.

Nell'esempio che segue viene illustrato come esporre un metodo di servizio Web in una pagina Web ASP.NET.

<%@ 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>

Nell'esempio che segue viene illustrata una pagina Web con il relativo servizio Web chiamato dallo script della pagina.

<%@ 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);

        }

    }

}

Effettuare richieste HTTP da un client AJAX

Nell'esempio precedente viene illustrato come chiamare servizi Web da script client chiamando le classi proxy generate automaticamente per un determinato servizio. È anche possibile effettuare chiamate di livello inferiore ai servizi Web da script client. Si tratta di una procedura utile nel caso in cui si debba gestire il livello di comunicazione o esaminare i dati inviati al o dal server. Per chiamare i servizi Web in questo modo, utilizzare la classe WebRequest.

Nell'esempio che segue viene illustrato come utilizzare un oggetto WebRequest per implementare le richieste Web GET e POST che connettono agli URL specificati (endpoint HTTP).

// 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();

Chiamata a operazioni dei servizi WCF in AJAX

È possibile chiamare in modo asincrono i servizi Windows Communication Foundation (WCF) (.svc) da uno script client, in maniera pressoché analoga°alla chiamata dei servizi basati su .asmx. Nell'esempio riportato di seguito viene illustrato come esporre e chiamare le operazioni dei servizi WCF in una pagina Web ASP.NET.

<%@ 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; }
        }
    }

}

Esempi aggiuntivi

Torna all'inizio

Riferimento alle classi

Nelle tabelle seguenti sono elencate le classi principali associate ai servizi Web che possono essere chiamati da script client.

Spazi dei nomi client

Nome

Descrizione

Spazio dei nomi Sys.Net

Contiene le classi che gestiscono la comunicazione tra le applicazioni client ASP.NET AJAX e i servizi Web nel server. Lo spazio dei nomi Sys.Net appartiene alla Microsoft AJAX Library.

Spazio dei nomi Sys.Serialization

Contiene le classi correlate alla serializzazione dei dati per le applicazioni client ASP.NET AJAX.

Spazio dei nomi Sys.Services

Contiene i tipi che consentono l'accesso dello script nelle applicazioni client ASP.NET AJAX al servizio di autenticazione ASP.NET, al servizio profili e ad altri servizi dell'applicazione. Lo spazio dei nomi Sys.Services appartiene alla Microsoft AJAX Library.

Spazi dei nomi server

Nome

Descrizione

System.Web.Script.Serialization

Contiene le classi che forniscono la serializzazione e deserializzazione JSON (JavaScript Object Notation) per i tipi gestiti. Fornisce anche funzionalità di estensibilità per personalizzare il comportamento di serializzazione.

Torna all'inizio

Risorse supplementari

About Native XMLHTTP

http://www.json.org

What is the Windows Communication Foundation?

XML Web Services Infrastructure

WCF Services and ASP.NET

Understanding Service-Oriented Architecture

Novità

Vengono di seguito riportate le nuove funzionalità di ASP.NET versione 3.0:

  • Servizi dell'applicazione in Windows Communication Foundation (WCF).

  • Servizi dell'applicazione in AJAX chiamati da un'applicazione client .NET Framework.

Torna all'inizio

Vedere anche

Attività

Procedura dettagliata: creazione e utilizzo di un servizio Web con supporto AJAX

Concetti

Utilizzo dell'autenticazione basata su form con ASP.NET AJAX

Cenni preliminari sui servizi delle applicazioni ASP.NET