Como: migrar código gerenciador do DCOM para o WCFHow to: Migrate Managed-Code DCOM to WCF

O WCF (Windows Communication Foundation) é a opção recomendada e uma escolha segura no lugar do DCOM (Distributed Component Object Model) para chamadas de código gerenciado entre servidores e clientes em um ambiente distribuído.Windows Communication Foundation (WCF) is the recommended and secure choice over Distributed Component Object Model (DCOM) for managed code calls between servers and clients in a distributed environment. Este artigo mostra como migrar código de DCOM para o WCF para os cenários a seguir.This article shows how you to migrate code from DCOM to WCF for the following scenarios.

  • O serviço remoto retorna um objeto por valor para o clienteThe remote service returns an object by-value to the client

  • O cliente envia um objeto por valor para o serviço remotoThe client sends an object by-value to the remote service

  • O serviço remoto retorna um objeto por referência para o clienteThe remote service returns an object by-reference to the client

Por motivos de segurança, enviar um objeto por referência do cliente para o serviço não é permitido no WCF.For security reasons, sending an object by-reference from the client to the service is not allowed in WCF. Um cenário que requer uma conversa de ida e volta entre o cliente e o servidor pode ser obtido no WCF usando um serviço duplex.A scenario that requires a conversation back and forth between client and server can be achieved in WCF using a duplex service. Para obter mais informações sobre serviços duplex, consulte Serviços duplex.For more information about duplex services, see Duplex Services.

Para obter mais detalhes sobre a criação de serviços do WCF e clientes para esses serviços, consulte Programação WCF básica, Projetando e Implementando serviços e Compilando clientes.For more details about creating WCF services and clients for those services, see Basic WCF Programming, Designing and Implementing Services, and Building Clients.

Código de exemplo do DCOMDCOM example code

Nesses cenários, as interfaces DCOM ilustradas usando o WCF têm a seguinte estrutura:For these scenarios, the DCOM interfaces that are illustrated using WCF have the following structure:

[ComVisible(true)]  
[Guid("AA9C4CDB-55EA-4413-90D2-843F1A49E6E6")]  
public interface IRemoteService  
{  
   Customer GetObjectByValue();  
   IRemoteObject GetObjectByReference();  
   void SendObjectByValue(Customer customer);  
}  
  
[ComVisible(true)]  
[Guid("A12C98DE-B6A1-463D-8C24-81E4BBC4351B")]  
public interface IRemoteObject  
{  
}  
  
public class Customer  
{  
}  

O serviço retorna um objeto por valorThe service returns an object by-value

Para este cenário, você faz uma chamada para um serviço e método retorna um objeto, que é passado por valor do servidor para o cliente.For this scenario, you make a call to a service and it method returns an object, which is passed by-value from the server to the client. Esse cenário representa a chamada COM a seguir:This scenario represents the following COM call:

public interface IRemoteService  
{  
    Customer GetObjectByValue();  
}  

Nesse cenário, o cliente recebe uma cópia desserializada de um objeto do serviço remoto.In this scenario, the client receives a deserialized copy of an object from the remote service. O cliente pode interagir com essa cópia local sem fazer uma chamada de volta para o serviço.The client can interact with this local copy without calling back to the service. Em outras palavras, o cliente tem certeza de que o serviço não estará envolvido de nenhum modo quando os métodos na cópia local forem chamados.In other words, the client is guaranteed the service will not be involved in any way when methods on the local copy are called. O WCF sempre retorna objetos do serviço por valor, portanto, as etapas a seguir descrevem a criação de um serviço WCF normal.WCF always returns objects from the service by value, so the following steps describe creating a regular WCF service.

Etapa 1: definir a interface do serviço WCFStep 1: Define the WCF service interface

Defina uma interface pública para o serviço WCF e marque-a com o atributo [ServiceContractAttribute].Define a public interface for the WCF service and mark it with the [ServiceContractAttribute] attribute. Marcar os métodos que você deseja expor para clientes com o atributo [OperationContractAttribute].Mark the methods you want to expose to clients with the [OperationContractAttribute] attribute. O exemplo a seguir mostra o uso desses atributos para identificar a interface do lado do servidor e métodos de interface que um cliente pode chamar.The following example shows using these attributes to identify the server-side interface and interface methods a client can call. O método usado para esse cenário é mostrado em negrito.The method used for this scenario is shown in bold.

using System.Runtime.Serialization;  
using System.ServiceModel;  
using System.ServiceModel.Web;   
. . .  
[ServiceContract]  
public interface ICustomerManager  
{  
    [OperationContract]  
    void StoreCustomer(Customer customer);  
  
    [OperationContract]     Customer GetCustomer(string firstName, string lastName);   
  
}  

Etapa 2: definir o contrato de dadosStep 2: Define the data contract

Em seguida, você deve criar um contrato de dados para o serviço, que descreve como os dados serão trocados entre o serviço e seus clientes.Next you should create a data contract for the service, which will describe how the data will be exchanged between the service and its clients. Classes descritas no contrato de dados devem ser marcadas com o atributo [DataContractAttribute].Classes described in the data contract should be marked with the [DataContractAttribute] attribute. As propriedades ou os campos individuais que você quiser que sejam visíveis para o cliente e o servidor deverão ser marcados com o atributo [DataMemberAttribute].The individual properties or fields you want visible to both client and server should be marked with the [DataMemberAttribute] attribute. Se quiser que os tipos derivados de uma classe no contrato de dados sejam permitidos, você deverá identificá-los com o atributo [KnownTypeAttribute].If you want types derived from a class in the data contract to be allowed, you must identify them with the [KnownTypeAttribute] attribute. WCF só será serializar ou desserializará tipos na interface do serviço e tipos identificados como conhecidos.WCF will only serialize or deserialize types in the service interface and types identified as known types. Se você tentar usar um tipo que não for um tipo conhecido, ocorrerá uma exceção.If you attempt to use a type that is not a known type, an exception will occur.

Para obter mais informações sobre contratos de dados, consulte Contratos de dados.For more information about data contracts, see Data Contracts.

[DataContract]  
[KnownType(typeof(PremiumCustomer))]  
public class Customer  
{  
    [DataMember]  
    public string Firstname;  
    [DataMember]  
    public string Lastname;  
    [DataMember]  
    public Address DefaultDeliveryAddress;  
    [DataMember]  
    public Address DefaultBillingAddress;  
}  
 [DataContract]  
public class PremiumCustomer : Customer  
{  
    [DataMember]  
    public int AccountID;  
}  
  
 [DataContract]  
public class Address  
{  
    [DataMember]  
    public string Street;  
    [DataMember]  
    public string Zipcode;  
    [DataMember]  
    public string City;  
    [DataMember]  
    public string State;  
    [DataMember]  
    public string Country;  
}  

Etapa 3: implementar o serviço WCFStep 3: Implement the WCF service

Em seguida, você deve implementar a classe do serviço WCF que implementa a interface definida na etapa anterior.Next, you should implement the WCF service class that implements the interface you defined in the previous step.

public class CustomerService: ICustomerManager    
{  
    public void StoreCustomer(Customer customer)  
    {  
        // write to a database  
    }  
    public Customer GetCustomer(string firstName, string lastName)  
    {  
        // read from a database  
    }  
}  

Etapa 4: configurar o serviço e o clienteStep 4: Configure the service and the client

Para executar um serviço WCF, é necessário declarar um ponto de extremidade que expõe essa interface de serviço em uma URL específica usando uma associação do WCF específica.To run a WCF service, you need to declare an endpoint that exposes that service interface at a specific URL using a specific WCF binding. Uma associação especifica os detalhes de transporte, codificação e protocolo para a comunicação entre o servidor e os clientes.A binding specifies the transport, encoding and protocol details for the clients and server to communicate. Geralmente, você adiciona associações ao arquivo de configuração do projeto de serviço (web.config).You typically add bindings to the service project’s configuration file (web.config). O exemplo a seguir mostra uma entrada de associação para o serviço de exemplo:The following shows a binding entry for the example service:

<configuration>  
  <system.serviceModel>  
    <services>  
      <service name="Server.CustomerService">  
        <endpoint address="http://localhost:8083/CustomerManager"   
                  binding="basicHttpBinding"  
                  contract="Shared.ICustomerManager" />  
      </service>  
    </services>  
  </system.serviceModel>  
</configuration>  

Em seguida, você precisa configurar o cliente de acordo com as informações de associação especificadas pelo serviço.Next, you need to configure the client to match the binding information specified by the service. Para fazer isso, adicione o seguinte ao arquivo de configuração (app.config) do aplicativo do cliente.To do so, add the following to the client’s application configuration (app.config) file.

<configuration>  
  <system.serviceModel>  
    <client>  
      <endpoint name="customermanager"   
                address="http://localhost:8083/CustomerManager"   
                binding="basicHttpBinding"   
                contract="Shared.ICustomerManager"/>  
    </client>  
  </system.serviceModel>  
</configuration>  

Etapa 5: executar o serviçoStep 5: Run the service

Por fim, você pode fazer auto-hospedagem em um aplicativo de console, adicionando as linhas a seguir ao aplicativo de serviço e iniciando o aplicativo.Finally, you can self-host it in a console application by adding the following lines to the service app, and starting the app. Para obter mais informações sobre outras maneiras de hospedar um aplicativo de serviço WCF, consulte Serviços de hospedagem.For more information about other ways to host a WCF service application, Hosting Services.

ServiceHost customerServiceHost = new ServiceHost(typeof(CustomerService));  
customerServiceHost.Open();  

Etapa 6: chamar o serviço do clienteStep 6: Call the service from the client

Para chamar o serviço do cliente, você precisa criar uma fábrica de canais para o serviço e solicitar um canal, o que permitirá que você chame diretamente o método GetCustomer, diretamente do cliente.To call the service from the client, you need to create a channel factory for the service, and request a channel, which will enable you to directly call the GetCustomer method directly from the client. O canal implementa a interface do serviço e manipula a lógica subjacente de solicitação/resposta para você.The channel implements the service’s interface and handles the underlying request/reply logic for you. O valor retornado dessa chamada de método que é a cópia desserializada da resposta do serviço.The return value from that method call is the deserialized copy of the service response.

ChannelFactory<ICustomerManager> factory =   
     new ChannelFactory<ICustomerManager>("customermanager");  
ICustomerManager service = factory.CreateChannel();  
Customer customer = service.GetCustomer("Mary", "Smith");  

O cliente envia um objeto por valor para o servidorThe client sends a by-value object to the server

Nesse cenário, o cliente envia um objeto para o servidor, por valor.In this scenario, the client sends an object to the server, by-value. Isso significa que o servidor receberá uma cópia desserializada do objeto.This means that the server will receive a deserialized copy of the object. O servidor pode chamar métodos de cópia e obter a garantia de que não há nenhum retorno de chamada no código do cliente.The server can call methods on that copy and be guaranteed there is no callback into client code. Conforme mencionado anteriormente, as trocas de dados de WCF normais são por valor.As mentioned previously, normal WCF exchanges of data are by-value. Isso garante que chamar métodos em um desses objetos resultará apenas em execução local – não invocará código no cliente.This guarantees that calling methods on one of these objects executes locally only – it will not invoke code on the client.

Esse cenário representa a chamada de método COM a seguir:This scenario represents the following COM method call:

public interface IRemoteService  
{  
    void SendObjectByValue(Customer customer);  
}  

Esse cenário usa o mesmo contrato de dados e interface de serviço, conforme mostrado no primeiro exemplo.This scenario uses the same service interface and data contract as shown in the first example. Além disso, o cliente e o serviço serão configurados da mesma maneira.In addition, the client and service will be configured in the same way. Neste exemplo, um canal é criado para enviar o objeto e executar da mesma maneira.In this example, a channel is created to send the object and run the same way. No entanto, neste exemplo, você criará um cliente que chamará o serviço, passando um objeto por valor.However, for this example, you will create a client that calls the service, passing an object by-value. O método de serviço que o cliente chamará no contrato de serviço é mostrado em negrito:The service method the client will call in the service contract is shown in bold:

[ServiceContract]  
public interface ICustomerManager  
{  
    [OperationContract]     void StoreCustomer(Customer customer);  
  
    [OperationContract]  
    Customer GetCustomer(string firstName, string lastName);  
}  

Adicionar código para o cliente que envia um objeto por valorAdd code to the client that sends a by-value object

O código a seguir mostra como o cliente cria um novo objeto de cliente por valor, cria um canal para se comunicar com o serviço ICustomerManager e envia o objeto de cliente para ele.The following code shows how the client creates a new by-value customer object, creates a channel to communicate with the ICustomerManager service, and sends the customer object to it.

O objeto de cliente será serializado e enviado para o serviço, em que ele será desserializado pelo serviço gerando uma nova cópia desse objeto.The customer object will be serialized, and sent to the service, where it is deserialized by the service into a new copy of that object. Qualquer método que o serviço chamar nesse objeto será executado apenas localmente no servidor.Any methods the service calls on this object will execute only locally on the server. É importante observar que esse código ilustra o envio de um tipo derivado (PremiumCustomer).It’s important to note that this code illustrates sending a derived type (PremiumCustomer). O contrato de serviço espera um objeto Customer, mas o contrato de dados de serviço usa o atributo [KnownTypeAttribute] para indicar que PremiumCustomer também é permitido.The service contract expects a Customer object, but the service data contract uses the [KnownTypeAttribute] attribute to indicate that PremiumCustomer is also allowed. As tentativas do WCF de serializar ou desserializar qualquer outro tipo via interface de serviço falharão.WCF will fail attempts to serialize or deserialize any other type via this service interface.

PremiumCustomer customer = new PremiumCustomer();  
customer.Firstname = "John";  
customer.Lastname = "Doe";  
customer.DefaultBillingAddress = new Address();  
customer.DefaultBillingAddress.Street = "One Microsoft Way";  
customer.DefaultDeliveryAddress = customer.DefaultBillingAddress;  
customer.AccountID = 42;  
  
ChannelFactory<ICustomerManager> factory =  
   new ChannelFactory<ICustomerManager>("customermanager");  
ICustomerManager customerManager = factory.CreateChannel();  
customerManager.StoreCustomer(customer);  

O serviço retorna um objeto por referênciaThe service returns an object by reference

Para este cenário, o aplicativo cliente faz uma chamada para o serviço remoto e o método retorna um objeto, que é passado por referência do serviço para o cliente.For this scenario, the client app makes a call to the remote service and the method returns an object, which is passed by reference from the service to the client.

Conforme mencionado anteriormente, os serviços WCF sempre retornam o objeto por valor.As mentioned previously, WCF services always return object by value. No entanto, você pode obter um resultado semelhante usando a classe EndpointAddress10.However, you can achieve a similar result by using the EndpointAddress10 class. O EndpointAddress10 é um objeto serializável por valor que pode ser usado pelo cliente para obter um objeto por referência de sessão no servidor.The EndpointAddress10 is a serializable by-value object that can be used by the client to obtain a sessionful by-reference object on the server.

O comportamento do objeto por referência no WCF mostrado nesse cenário é diferente do observado com DCOM.The behavior of the by-reference object in WCF shown in this scenario is different than DCOM. No DCOM, o servidor pode retornar um objeto por referência para o cliente diretamente e o cliente pode chamar os métodos desse objeto, que são executados no servidor.In DCOM, the server can return a by-reference object to the client directly, and the client can call that object’s methods, which execute on the server. No entanto, no WCF, o objeto retornado é sempre por valor.In WCF, however, the object returned is always by-value. O cliente deve tomar esse objeto por valor representado por EndpointAddress10 e usá-lo para criar seu próprio objeto de sessão por referência.The client must take that by-value object, represented by EndpointAddress10 and use it to create its own sessionful by-reference object. As chamadas de método do cliente no objeto de sessão são executadas no servidor. Em outras palavras, esse objeto por referência no WCF é um serviço WCF normal que está configurado para ser de sessão.The client method calls on the sessionful object execute on the server.In other words, this by-reference object in WCF is a normal WCF service that is configured to be sessionful.

No WCF, uma sessão é uma maneira de correlacionar várias mensagens enviadas entre dois pontos de extremidade.In WCF, a session is a way of correlating multiple messages sent between two endpoints. Isso significa que, depois que um cliente obtiver uma conexão para esse serviço, uma sessão será estabelecida entre o cliente e o servidor.This means that once a client obtains a connection to this service, a session will be established between the client and the server. O cliente usará uma única instância exclusiva do objeto do lado do servidor para todas as interações dele nessa única sessão.The client will use a single unique instance of the server-side object for all its interactions within this single session. Contratos WCF de sessão são semelhantes aos padrões de solicitação/resposta de rede voltados para conexão.Sessionful WCF contracts are similar to connection-oriented network request/response patterns.

Esse cenário é representado pelo método DCOM a seguir.This scenario is represented by the following DCOM method.

public interface IRemoteService  
{  
    IRemoteObject GetObjectByReference();  
}  

Etapa 1: definir a interface do serviço WCF de sessão e implementaçãoStep 1: Define the Sessionful WCF service interface and implementation

Primeiro, defina uma interface de serviço WCF que contém o objeto de sessão.First, define a WCF service interface that contains the sessionful object.

Nesse código, o objeto de sessão é marcado com o atributo ServiceContract, que o identifica como uma interface de serviço WCF normal.In this code, the sessionful object is marked with the ServiceContract attribute, which identifies it as a regular WCF service interface. Além disso, a propriedade SessionMode é definida para indicar que ele será um serviço de sessão.In addition, the SessionMode property is set to indicate it will be a sessionful service.

[ServiceContract(SessionMode = SessionMode.Allowed)]  
public interface ISessionBoundObject  
{  
    [OperationContract]  
    string GetCurrentValue();  
  
    [OperationContract]  
    void SetCurrentValue(string value);  
}  

O código a seguir mostra a implementação do serviço.The following code shows the service implementation.

O serviço é marcado com o atributo [ServiceBehavior] e a propriedade InstanceContextMode dele é definida como InstanceContextMode.PerSessions para indicar que uma instância exclusiva desse tipo deve ser criada para cada sessão.The service is marked with the [ServiceBehavior] attribute, and its InstanceContextMode property set to InstanceContextMode.PerSessions to indicate that a unique instance of this type should be created for each session.

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]  
    public class MySessionBoundObject : ISessionBoundObject  
    {  
        private string _value;  
  
        public string GetCurrentValue()  
        {  
            return _value;  
        }  
  
        public void SetCurrentValue(string val)  
        {  
            _value = val;  
        }  
  
    }  

Etapa 2: definir o serviço de fábrica do WCF para o objeto de sessãoStep 2: Define the WCF factory service for the sessionful object

O serviço que cria o objeto de sessão deve ser definido e implementado.The service that creates the sessionful object must be defined and implemented. O código a seguir mostra como fazer isso.The following code shows how to do this. Esse código cria outro serviço WCF que retorna um objeto EndpointAddress10.This code creates another WCF service that returns an EndpointAddress10 object. Essa é uma forma serializável de um ponto de extremidade que pode ser usada para criar o objeto de sessão.This is a serializable form of an endpoint the can use to create the session-full object.

[ServiceContract]  
    public interface ISessionBoundFactory  
    {  
        [OperationContract]  
        EndpointAddress10 GetInstanceAddress();  
    }  

A seguir está a implementação deste serviço.The following is the implementation of this service. Essa implementação mantém uma fábrica de canais única para criar objetos de sessão.This implementation maintains a singleton channel factory to create sessionful objects. Quando GetInstanceAddress é chamado, ele cria um canal e cria um objeto EndpointAddress10 que aponta para o endereço remoto associado a esse canal.When GetInstanceAddress is called, it creates a channel and creates an EndpointAddress10 object that points to the remote address associated with this channel. EndpointAddress10 é um tipo de dados que pode ser retornado ao cliente por valor.EndpointAddress10 is a data type that can be returned to the client by-value.

public class SessionBoundFactory : ISessionBoundFactory  
    {  
        public static ChannelFactory<ISessionBoundObject> _factory =   
            new ChannelFactory<ISessionBoundObject>("sessionbound");  
  
        public SessionBoundFactory()  
        {  
        }  
  
        public EndpointAddress10 GetInstanceAddress()  
        {  
            IClientChannel channel = (IClientChannel)_factory.CreateChannel();  
            return EndpointAddress10.FromEndpointAddress(channel.RemoteAddress);  
        }  
    }  

Etapa 3: configurar e iniciar os serviços WCFStep 3: Configure and start the WCF services

Para hospedar esses serviços, você precisará fazer as adições a seguir ao arquivo de configuração do servidor (web.config).To host these services, you will need to make the following additions to the server’s configuration file (web.config).

  1. Adicione uma seção <client> que descreve o ponto de extremidade para o objeto de sessão.Add a <client> section that describes the endpoint for the sessionful object. Nesse cenário, o servidor também atua como um cliente e deve ser configurado para permitir isso.In this scenario, the server also acts as a client and must be configured to enable this.

  2. Na seção <services>, declare pontos de extremidade de serviço para a o objeto de fábrica e de sessão.In the <services> section, declare service endpoints for the factory and sessionful object. Isso permite que o cliente se comunique com os pontos de extremidade de serviço, adquira o EndpointAddress10 e crie o canal de sessão.This enables the client to communicate with the service endpoints, acquire the EndpointAddress10 and create the sessionful channel.

Este é um exemplo de arquivo de configuração com estas configurações:The following is an example configuration file with these settings:

<configuration>  
  <system.serviceModel>  
    <client>  
      <endpoint name="sessionbound"  
                address="net.tcp://localhost:8081/SessionBoundObject"  
                binding="netTcpBinding"  
                contract="Shared.ISessionBoundObject"/>  
    </client>  
  
    <services>  
      <service name="Server.MySessionBoundObject">  
        <endpoint address="net.tcp://localhost:8081/SessionBoundObject"  
                  binding="netTcpBinding"   
                  contract="Shared.ISessionBoundObject" />  
      </service>  
      <service name="Server.SessionBoundFactory">  
        <endpoint address="net.tcp://localhost:8081/SessionBoundFactory"  
                  binding="netTcpBinding"   
                  contract="Shared.ISessionBoundFactory" />  
      </service>  
    </services>  
  </system.serviceModel>  
</configuration>  

Adicione as linhas a seguir a um aplicativo de console, para hospedar automaticamente o serviço e iniciar o aplicativo.Add the following lines to a console application, to self-host the service, and start the app.

ServiceHost factoryHost = new ServiceHost(typeof(SessionBoundFactory));  
factoryHost.Open();  
  
ServiceHost sessionBoundServiceHost = new ServiceHost(  
typeof(MySessionBoundObject));  
sessionBoundServiceHost.Open();  

Etapa 4: configurar o cliente e chamar o serviçoStep 4: Configure the client and call the service

Configure o cliente para se comunicar com os serviços WCF, criando as seguintes entradas no arquivo de configuração de aplicativo do projeto (app.config).Configure the client to communicate with the WCF services by making the following entries in the project’s application configuration file (app.config).

<configuration>  
  <system.serviceModel>  
    <client>  
      <endpoint name="sessionbound"   
                address="net.tcp://localhost:8081/SessionBoundObject"   
                binding="netTcpBinding"   
                contract="Shared.ISessionBoundObject"/>  
      <endpoint name="factory"   
                address="net.tcp://localhost:8081/SessionBoundFactory"   
                binding="netTcpBinding"   
                contract="Shared.ISessionBoundFactory"/>  
    </client>    
  </system.serviceModel>  
</configuration>  

Para chamar o serviço, adicione o código ao cliente para fazer o seguinte:To call the service, add the code to the client to do the following:

  1. Crie um canal para o serviço ISessionBoundFactory.Create a channel to the ISessionBoundFactory service.

  2. Use o canal para invocar o serviço ISessionBoundFactory e obter um objeto EndpointAddress10.Use the channel to invoke the ISessionBoundFactory service an obtain an EndpointAddress10 object.

  3. Use o EndpointAddress10 para criar um canal para obter um objeto de sessão.Use the EndpointAddress10 to create a channel to obtain a sessionful object.

  4. Chame os métodos SetCurrentValue e GetCurrentValue para demonstrar que ela permanece a mesma instância do objeto que é usada em várias chamadas.Call the SetCurrentValue and GetCurrentValue methods to demonstrate it remains the same object instance is used across multiple calls.

ChannelFactory<ISessionBoundFactory> factory =  
        new ChannelFactory<ISessionBoundFactory>("factory");  
  
ISessionBoundFactory sessionBoundFactory = factory.CreateChannel();  
  
EndpointAddress10 address = sessionBoundFactory.GetInstanceAddress();  
  
ChannelFactory<ISessionBoundObject> sessionBoundObjectFactory =  
    new ChannelFactory<ISessionBoundObject>(  
        new NetTcpBinding(),  
        address.ToEndpointAddress());  
  
ISessionBoundObject sessionBoundObject =  
        sessionBoundObjectFactory.CreateChannel();  
  
sessionBoundObject.SetCurrentValue("Hello");  
if (sessionBoundObject.GetCurrentValue() == "Hello")  
{  
    Console.WriteLine("Session-full instance management works as expected");  
}  

Consulte tambémSee also