Integrazione di componenti transazionali di Enterprise ServicesIntegrating Enterprise Services Transactional Components

Windows Communication Foundation (WCF) fornisce un meccanismo automatico per l'integrazione con Enterprise Services (vedere l'integrazione con applicazioni COM+).Windows Communication Foundation (WCF) provides an automatic mechanism for integrating with Enterprise Services (see Integrating with COM+ Applications). Può tuttavia essere necessario disporre della flessibilità di sviluppare servizi che utilizzano internamente componenti transazionali ospitati all'interno di Enterprise Services.However, you may want the flexibility to develop services that internally use transactional components hosted within Enterprise Services. Poiché la funzionalità delle transazioni WCF si basa sul System.Transactions infrastruttura, il processo per l'integrazione di Enterprise Services con WCF è identico a quello per la specifica di interoperabilità tra System.Transactions e di Enterprise Services, come descritto Interoperabilità con applicazioni COM+ transazioni e di Enterprise Services.Because the WCF Transactions feature is built on the System.Transactions infrastructure, the process for integrating Enterprise Services with WCF is identical to that for specifying interoperability between System.Transactions and Enterprise Services, as outlined in Interoperability with Enterprise Services and COM+ Transactions.

Per fornire il livello desiderato di interoperabilità tra la transazione propagata in ingresso e la transazione in contesto COM+, l'implementazione del servizio deve creare un'istanza della classe TransactionScope e deve utilizzare il valore appropriato ricavato dall'enumerazione EnterpriseServicesInteropOption.To provide the desired level of interoperability between the incoming flowed transaction and the COM+ context transaction, the service implementation must create a TransactionScope instance and use the appropriate value from the EnterpriseServicesInteropOption enumeration.

Integrazione di Enterprise Services con un'operazione del servizioIntegrating Enterprise Services with a Service Operation

Nel codice seguente viene illustrata un'operazione, con propagazione transazionale Allowed, che crea una classe TransactionScope con l'opzione Full.The following code demonstrates an operation, with Allowed transaction flow, that creates a TransactionScope with the Full option. In questo scenario vengono applicate le condizioni seguenti:The following conditions apply in this scenario:

  • Se il client propaga una transazione, l'operazione, inclusa la chiamata al componente Enterprise Services, viene eseguita all'interno dell'ambito di tale transazione.If the client flows a transaction, the operation, including the call to the Enterprise Services component, is executed within the scope of that transaction. L'utilizzo di Full garantisce la sincronizzazione della transazione con il contesto System.EnterpriseServices, il che significa che la transazione di ambiente per System.Transactions e System.EnterpriseServices è la stessa.Using Full ensures that the transaction is synchronized with the System.EnterpriseServices context, which means that the ambient transaction for System.Transactions and the System.EnterpriseServices is the same.

  • Se il client non propaga una transazione, l'impostazione di TransactionScopeRequired su true crea un nuovo ambito di transazione per l'operazione.If the client does not flow a transaction, setting TransactionScopeRequired to true creates a new transaction scope for the operation. Analogamente, l'utilizzo di Full garantisce che la transazione dell'operazione sia la stessa transazione utilizzata all'interno del contesto del componente System.EnterpriseServices.Similarly, using Full ensures that the operation’s transaction is the same as the transaction used inside the System.EnterpriseServices component's context.

Eventuali chiamate aggiuntive al metodo avvengono anch'esse nell'ambito della stessa transazione dell'operazione.Any additional method calls also occur within the scope of the same operation’s transaction.

[ServiceContract()]  
public interface ICustomerServiceContract  
{  
   [OperationContract]  
   [TransactionFlow(TransactionFlowOption.Allowed)]  
   void UpdateCustomerNameOperation(int customerID, string newCustomerName);  
}  

[ServiceBehavior(TransactionIsolationLevel = System.Transactions.IsolationLevel.Serializable)]  
public class CustomerService : ICustomerServiceContract  
{  
   [OperationBehavior(TransactionScopeRequired = true, TransactionAutoComplete = true)]  
   public void UpdateCustomerNameOperation(int customerID, string newCustomerName)  
   {  
   // Create a transaction scope with full ES interop  
      using (TransactionScope ts = new TransactionScope(  
                     TransactionScopeOption.Required,  
                     new TransactionOptions(),  
                     EnterpriseServicesInteropOption.Full))  
      {  
         // Create an Enterprise Services component  
         // Call UpdateCustomer method on an Enterprise Services   
         // component   

         // Call UpdateOtherCustomerData method on an Enterprise   
         // Services component   
         ts.Complete();  
      }  

      // Do UpdateAdditionalData on an non-Enterprise Services  
      // component  
   }  
}  

Se non è necessaria alcuna sincronizzazione tra la transazione corrente di un'operazione e le chiamate ai componenti Enterprise Services transazionali, utilizzare l'opzione None quando si crea l'istanza di TransactionScope.If no synchronization is required between an operation’s current transaction and calls to transactional Enterprise Services components, then use the None option when instantiating the TransactionScope instance.

Integrazione di Enterprise Services con un clientIntegrating Enterprise Services with a Client

Nell'esempio seguente viene illustrato il codice client utilizzando un'istanza della classe TransactionScope con l'impostazione FullThe following code demonstrates client code using a TransactionScope instance with the Full setting. In questo scenario, le chiamate alle operazioni del servizio che supportano la propagazione transazionale avvengono nell'ambito della stessa transazione delle chiamate ai componenti Enterprise Services.In this scenario, calls to service operations that support transaction flow occur within the scope of the same transaction as the calls to Enterprise Services components.

static void Main()  
{  
    // Create a client  
    CalculatorClient client = new CalculatorClient();  

    // Create a transaction scope with full ES interop  
    using (TransactionScope ts = new TransactionScope(  
          TransactionScopeOption.Required,  
          new TransactionOptions(),  
          EnterpriseServicesInteropOption.Full))  
    {  
        // Call Add calculator service operation  

        // Create an Enterprise Services component  

        // Call UpdateCustomer method on an Enterprise Services   
        // component   

        ts.Complete();  
    }  

    // Closing the client gracefully closes the connection and   
    // cleans up resources  
    client.Close();  
}  

Vedere ancheSee Also

Integrazione con applicazioni COM+Integrating with COM+ Applications
Integrazione con applicazioni COMIntegrating with COM Applications