ServiceContractAttribute Classe

Definizione

public ref class ServiceContractAttribute sealed : Attribute

[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple=false, Inherited=false)]
public sealed class ServiceContractAttribute : Attribute

[System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, Inherited=false)]
public sealed class ServiceContractAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple=false, Inherited=false)>]
type ServiceContractAttribute = class
    inherit Attribute

[<System.AttributeUsage(System.AttributeTargets.Class | System.AttributeTargets.Interface, Inherited=false)>]
type ServiceContractAttribute = class
    inherit Attribute

Public NotInheritable Class ServiceContractAttribute
Inherits Attribute

Ereditarietà

Object

Attribute

ServiceContractAttribute

Attributi

AttributeUsageAttribute

Esempio

Nell'esempio di codice seguente viene mostrato come applicare l'attributo ServiceContractAttribute a un'interfaccia per definire un contratto di servizio avente un solo metodo di servizio, indicato dall'attributo OperationContractAttribute. In questo caso, il livello di protezione che le associazioni devono applicare a tutti i messaggi è ProtectionLevel.EncryptAndSign.

L'esempio di codice prevede quindi l'implementazione del suddetto contratto nella classe SampleService.

using System;
using System.Collections.Generic;
using System.Net.Security;
using System.ServiceModel;
using System.Text;

namespace Microsoft.WCF.Documentation
{
  [ServiceContract(
    Namespace="http://microsoft.wcf.documentation",
    Name="SampleService",
    ProtectionLevel=ProtectionLevel.EncryptAndSign
  )]
  public interface ISampleService{
    [OperationContract]
    string SampleMethod(string msg);
  }

  class SampleService : ISampleService
  {
  #region ISampleService Members

  public string  SampleMethod(string msg)
  {
      return "The service greets you: " + msg;
  }

  #endregion
  }
}

Imports System.Collections.Generic
Imports System.Net.Security
Imports System.ServiceModel
Imports System.Text

Namespace Microsoft.WCF.Documentation
  <ServiceContract(Namespace:="http://microsoft.wcf.documentation", Name:="SampleService", ProtectionLevel:=ProtectionLevel.EncryptAndSign)> _
  Public Interface ISampleService
    <OperationContract> _
    Function SampleMethod(ByVal msg As String) As String
  End Interface

  Friend Class SampleService
      Implements ISampleService
  #Region "ISampleService Members"

  Public Function SampleMethod(ByVal msg As String) As String Implements ISampleService.SampleMethod
       Return "The service greets you: " & msg
  End Function

  #End Region
  End Class
End Namespace

Nell'esempio di codice seguente viene mostrato un semplice file di configurazione del servizio precedente che crea un solo endpoint.

<configuration>
  <system.serviceModel>
    <services>
      <service 
        name="Microsoft.WCF.Documentation.SampleService"
        behaviorConfiguration="mex"
      >
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:8080/SampleService"/>
          </baseAddresses>
        </host>
        <endpoint
          address=""
          binding="wsHttpBinding"
          contract="Microsoft.WCF.Documentation.ISampleService"
         />
        <endpoint
          address="mex"
          binding="mexHttpBinding"
          contract="IMetadataExchange"
        />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="mex">
          <serviceMetadata httpGetEnabled="true" httpGetUrl=""/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Nell'esempio di codice seguente viene mostrato un semplice client che richiama la classe SampleService precedente.

using System;
using System.ServiceModel;
using System.ServiceModel.Channels;

public class Client
{
  public static void Main()
  {
    // Picks up configuration from the config file.
    SampleServiceClient wcfClient = new SampleServiceClient();
    try
    {
        // Making calls.
        Console.WriteLine("Enter the greeting to send: ");
        string greeting = Console.ReadLine();
        Console.WriteLine("The service responded: " + wcfClient.SampleMethod(greeting));

        Console.WriteLine("Press ENTER to exit:");
        Console.ReadLine();

        // Done with service.
        wcfClient.Close();
        Console.WriteLine("Done!");
    }
    catch (TimeoutException timeProblem)
    {
      Console.WriteLine("The service operation timed out. " + timeProblem.Message);
      wcfClient.Abort();
      Console.Read();
    }
    catch(CommunicationException commProblem)
    {
      Console.WriteLine("There was a communication problem. " + commProblem.Message);
      wcfClient.Abort();
      Console.Read();
    }
  }
}

Imports System.ServiceModel
Imports System.ServiceModel.Channels

Public Class Client
  Public Shared Sub Main()
    ' Picks up configuration from the config file.
    Dim wcfClient As New SampleServiceClient()
    Try
        ' Making calls.
        Console.WriteLine("Enter the greeting to send: ")
            Dim greeting = Console.ReadLine()
        Console.WriteLine("The service responded: " & wcfClient.SampleMethod(greeting))

        Console.WriteLine("Press ENTER to exit:")
        Console.ReadLine()

        ' Done with service. 
        wcfClient.Close()
        Console.WriteLine("Done!")
    Catch timeProblem As TimeoutException
      Console.WriteLine("The service operation timed out. " & timeProblem.Message)
      wcfClient.Abort()
      Console.Read()
    Catch commProblem As CommunicationException
      Console.WriteLine("There was a communication problem. " & commProblem.Message)
      wcfClient.Abort()
      Console.Read()
    End Try
  End Sub
End Class

Commenti

Utilizzare l'attributo ServiceContractAttribute su un'interfaccia (o su una classe) per definire un contratto di servizio. Utilizzare quindi l'attributo OperationContractAttribute in uno o più metodi della classe (o dell'interfaccia) per definire le operazioni di servizio del contratto. Quando il contratto di servizio viene implementato e combinato con un binding e un EndpointAddress oggetto, il contratto di servizio viene esposto per l'uso da parte dei client. Per una panoramica del processo usando esempi semplici, vedere esercitazione Introduzione. Per altre informazioni sulla creazione di contratti di servizio, vedere Progettazione e implementazione dei servizi.

Le informazioni espresse da un attributo ServiceContractAttribute e dalla relativa interfaccia presentano una correlazione ridotta con l'elemento <portType> del linguaggio WSDL (Web Services Description Language). Un contratto di servizio viene usato sul lato servizio per specificare l'endpoint del servizio esposto ai chiamanti. I contratti di servizio vengono inoltre utilizzati sul lato client per specificare il contratto dell'endpoint con cui il client comunica e, se tale contratto è duplex, per specificare (mediante la proprietà CallbackContract) il contratto di callback che il client deve implementare per poter partecipare a una conversazione duplex.

Utilizzare le proprietà dell'attributo ServiceContractAttribute per modificare il contratto di servizio.

• La proprietà ConfigurationName specifica il nome dell'elemento di servizio da utilizzare fra quelli contenuti nel file di configurazione.

• Le proprietà Name e Namespace controllano il nome e lo spazio dei nomi del contratto nell'elemento <portType> del linguaggio WSDL.

• La proprietà SessionMode specifica se il contratto richiede un'associazione che supporta le sessioni.

• La proprietà CallbackContract specifica il contratto di callback in una conversazione bidirezionale (duplex).

• Le proprietà HasProtectionLevel e ProtectionLevel indicano se la proprietà ProtectionLevel è stata definita in modo esplicito per tutti i messaggi che supportano il contratto e, in tal caso, il valore impostato per questa proprietà.

I servizi implementano i contratti di servizio, che rappresentano lo scambio di dati supportato da un tipo di servizio. Una classe di servizio può implementare un contratto di servizio mediante l'implementazione di un'interfaccia contrassegnata con l'attributo ServiceContractAttribute e che presenta metodi contrassegnati con l'attributo OperationContractAttribute. In alternativa, una classe di servizio può essere contrassegnata con l'attributo ServiceContractAttribute e applicare l'attributo OperationContractAttribute ai propri metodi. Se una classe implementa un'interfaccia contrassegnata con ServiceContractAttribute, non può essere contrassegnata con ServiceContractAttribute.) I metodi sui tipi di servizio contrassegnati con l'oggetto OperationContractAttribute vengono considerati come parte di un contratto di servizio predefinito specificato dal tipo di servizio stesso. Per informazioni dettagliate sulle operazioni di servizio, vedere OperationContractAttribute.

Per impostazione predefinita, le proprietà Name e Namespace corrispondono rispettivamente al nome del tipo di contratto e allo spazio dei nomi http://tempuri.org e la proprietà ProtectionLevel è impostata su ProtectionLevel.None. È consigliabile utilizzare queste proprietà per impostare in modo esplicito i nomi, gli spazi dei nomi e i livelli di protezione dei contratti di servizio. Ciò consente di raggiungere due obiettivi. Il primo è che il contratto compilato con queste proprietà non è connesso direttamente alle informazioni sui tipi gestiti, il che consente di eseguire il refactoring del codice e degli spazi dei nomi gestiti senza violare il contratto secondo quanto espresso in WSDL. Il secondo è che la richiesta esplicita di un certo livello di protezione all'interno del contratto stesso consente di verificare in fase di esecuzione se la configurazione dell'associazione supporta tale livello di sicurezza. Ciò consente di evitare la divulgazione di informazioni riservate a causa di una configurazione inappropriata. Per altre informazioni sui livelli di protezione, vedere Informazioni sul livello di protezione.

Per esporre un servizio da usare dalle applicazioni client, creare un'applicazione host per registrare l'endpoint del servizio con Windows Communication Foundation (WCF). È possibile ospitare i servizi WCF usando Windows Activation Services (WAS), nelle applicazioni console, nelle applicazioni del servizio Windows, nelle applicazioni ASP.NET, nelle applicazioni Windows Forms o in qualsiasi altro tipo di dominio applicazione.

L'hosting in WAS è molto simile alla creazione di un'applicazione ASP.NET. Per informazioni dettagliate, vedere Procedura: ospitare un servizio WCF in IIS.

I client utilizzano l'interfaccia del contratto di servizio (ovvero l'interfaccia contrassegnata con l'attributo ServiceContractAttribute) per creare un canale connesso al servizio oppure utilizzano gli oggetti client (che combinano le informazioni sui tipi dell'interfaccia del contratto di servizio con la classe ClientBase<TChannel> ) per comunicare con il servizio. Per informazioni dettagliate sui canali client ai servizi, vedere Panoramica della classe e del ChannelFactory<TChannel> client WCF.

L'utilizzo di una classe o di un'interfaccia ServiceContractAttribute per ereditare da un'altra classe o interfaccia ServiceContractAttribute consente di estendere il contratto padre. Ad esempio, se un'interfaccia IChildContract è contrassegnata con l'attributo ServiceContractAttribute e ha ereditato da un'altra interfaccia di contratto di servizio, ad esempio IParentContract, il contratto di servizio IChildContract contiene sia i metodi dell'interfaccia IParentContract sia i metodi di dell'interfaccia IChildContract. L'estensione dei contratti (sia di classi sia di interfacce) è molto simile all'estensione di classi e interfacce gestite.

L'approccio più flessibile alla creazione dei servizi è definire anzitutto l'interfaccia del contratto di servizio e quindi fare in modo che la classe di servizio implementi tale interfaccia. Questo è anche il modo più semplice per compilare i servizi se è necessario implementare contratti di servizio definiti da altri utenti. La creazione di servizi direttamente contrassegnando una classe con ServiceContractAttribute e i relativi metodi OperationContractAttribute con funziona quando il servizio espone un solo contratto (ma tale contratto può essere esposto da più di un endpoint).

Utilizzare la CallbackContract proprietà per indicare un altro contratto di servizio che, se associato con il contratto di servizio originale, definire uno scambio di messaggi che può scorrere in due modi in modo indipendente. Per informazioni dettagliate, vedere CallbackContract.

Costruttori

Proprietà

Metodi

Implementazioni dell'interfaccia esplicita

Si applica a

Vedi anche

• OperationContractAttribute
• Definizione dei contratti di servizio
• Hosting di un servizio
• Panoramica della creazione del servizio
• Creazione di un client
• Panoramica della creazione del proxy