ActivationProxy.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / TransactionBridge / Microsoft / Transactions / Wsat / Messaging / ActivationProxy.cs / 1 / ActivationProxy.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

// Define the interfaces and infrastructure needed to send activation messages 

using System; 
using System.ServiceModel.Channels; 
using System.Diagnostics;
using System.IdentityModel.Claims; 
using System.IdentityModel.Policy;
using System.ServiceModel;
using System.Transactions;
using Microsoft.Transactions.Wsat.Protocol; 

namespace Microsoft.Transactions.Wsat.Messaging 
{ 
    abstract class ActivationProxy : RequestReplyProxy
    { 
        public ActivationProxy(CoordinationService coordination, EndpointAddress to)
            :
            base (coordination, to)
        { 
        }
 
        CreateCoordinationContextMessage CreateCreateCoordinationContextMessage(ref CreateCoordinationContext create) 
        {
            CreateCoordinationContextMessage message = new CreateCoordinationContextMessage(this.messageVersion, ref create); 
            if (create.IssuedToken != null)
            {
                CoordinationServiceSecurity.AddIssuedToken(message, create.IssuedToken);
            } 
            return message;
        } 
 
        public CreateCoordinationContextResponse SendCreateCoordinationContext (ref CreateCoordinationContext create)
        { 
            if (DebugTrace.Verbose)
            {
                DebugTrace.Trace(TraceLevel.Verbose, "Sending CreateCoordinationContext to {0}", this.to.Uri);
            } 

            Message message = CreateCreateCoordinationContextMessage(ref create); 
 
            Message reply = SendRequest(message, this.coordinationStrings.CreateCoordinationContextResponseAction);
            using (reply) 
            {
                if (DebugTrace.Verbose)
                {
                    DebugTrace.Trace(TraceLevel.Verbose, "Dispatching CreateCoordinationContextResponse reply"); 
                    if (DebugTrace.Pii)
                        DebugTrace.TracePii(TraceLevel.Verbose, 
                                            "Sender is {0}", 
                                            CoordinationServiceSecurity.GetSenderName(reply));
                } 

                return new CreateCoordinationContextResponse(reply, this.protocolVersion);
            }
        } 

        public IAsyncResult BeginSendCreateCoordinationContext (ref CreateCoordinationContext create, AsyncCallback callback, object state) 
        { 
            if (DebugTrace.Verbose)
            { 
                DebugTrace.Trace(TraceLevel.Verbose, "Sending CreateCoordinationContext to {0}", this.to.Uri);
            }

            Message message = CreateCreateCoordinationContextMessage(ref create); 
            return BeginSendRequest (message, callback, state);
        } 
 
        public CreateCoordinationContextResponse EndSendCreateCoordinationContext (IAsyncResult ar)
        { 
            try
            {
                Message reply = EndSendRequest(ar, this.coordinationStrings.CreateCoordinationContextResponseAction);
                using (reply) 
                {
                    if (DebugTrace.Verbose) 
                    { 
                        DebugTrace.Trace(TraceLevel.Verbose, "Dispatching CreateCoordinationContextResponse reply");
                        if (DebugTrace.Pii) 
                            DebugTrace.TracePii(TraceLevel.Verbose,
                                                "Sender is {0}",
                                                CoordinationServiceSecurity.GetSenderName(reply));
                    } 

                    return new CreateCoordinationContextResponse(reply, this.protocolVersion); 
                } 
            }
            catch (CommunicationException e) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatReceiveFailureException(e));
            }
        } 

        public static void SendCreateCoordinationContextResponse (RequestAsyncResult result, ref CreateCoordinationContextResponse response) 
        { 
            Message message = new CreateCoordinationContextResponseMessage(result.MessageVersion, ref response);
            if (response.IssuedToken != null) 
            {
                CoordinationServiceSecurity.AddIssuedToken(message, response.IssuedToken);
            }
 
            result.Finished (message);
        } 
 
        public static void SendFaultResponse (RequestAsyncResult result, Fault fault)
        { 
            Library.SendFaultResponse(result, fault);
        }
    }
 
    class InteropActivationProxy : ActivationProxy
    { 
        public InteropActivationProxy(CoordinationService coordination, EndpointAddress to) 
            :
            base (coordination, to) 
        {
        }

        protected override IChannelFactory SelectChannelFactory(out MessageVersion messageVersion) 
        {
            this.interoperating = true; 
 
            messageVersion = this.coordinationService.InteropActivationBinding.MessageVersion;
            return this.coordinationService.InteropActivationChannelFactory; 
        }
    }

    class WindowsActivationProxy : ActivationProxy 
    {
        public WindowsActivationProxy(CoordinationService coordination, EndpointAddress to) 
            : 
            base(coordination, to)
        { 
        }

        protected override IChannelFactory SelectChannelFactory(out MessageVersion messageVersion)
        { 
            this.interoperating = false;
 
            EndpointIdentity identity = this.to.Identity; 
            if (identity != null)
            { 
                string claimType = identity.IdentityClaim.ClaimType;
                if (claimType != ClaimTypes.Spn && claimType != ClaimTypes.Upn)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( 
                        new CreateChannelFailureException(SR.GetString(SR.InvalidTrustIdentityType, claimType)));
                } 
            } 

            string scheme = this.to.Uri.Scheme; 

            if (string.Compare(scheme,
                               Uri.UriSchemeNetPipe,
                               StringComparison.OrdinalIgnoreCase) == 0) 
            {
                messageVersion = this.coordinationService.NamedPipeActivationBinding.MessageVersion; 
                return this.coordinationService.NamedPipeActivationChannelFactory; 
            }
            else if (this.coordinationService.Config.RemoteClientsEnabled && 
                     string.Compare(scheme,
                                    Uri.UriSchemeHttps,
                                    StringComparison.OrdinalIgnoreCase) == 0)
            { 
                messageVersion = this.coordinationService.WindowsActivationBinding.MessageVersion;
                return this.coordinationService.WindowsActivationChannelFactory; 
            } 
            else
            { 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                    new CreateChannelFailureException(SR.GetString(SR.InvalidSchemeWithTrustIdentity, scheme)));
            }
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK