static MessagePayload CreateSubscriptionRequest(EndpointAddress subscriberAddress, EndpointAddress publisherAddress)
 {
     return new MessagePayload()
         .SetFromEndpointAddress(subscriberAddress)
         .SetToEndpointAddress(publisherAddress)
         .AsSubscriptionRequest();
 }

 public ClientWebSocketTransportDuplexSessionChannel(HttpChannelFactory<IDuplexSessionChannel> channelFactory, ClientWebSocketFactory connectionFactory, EndpointAddress remoteAddresss, Uri via, ConnectionBufferPool bufferPool)
     : base(channelFactory, remoteAddresss, via, bufferPool)
 {
     Contract.Assert(channelFactory != null, "connection factory must be set");
     _channelFactory = channelFactory;
     _connectionFactory = connectionFactory;
 }

		public IssuedSecurityTokenParameters (string tokenType,
			EndpointAddress issuerAddress, Binding issuerBinding)
		{
			token_type = tokenType;
			issuer_address = issuerAddress;
			binding = issuerBinding;
		}

 public static MessageQueue CreateQueue(EndpointAddress address, bool isTransactional = true)
 {
     var name = address.GetQueueName();
     var queue = MessageQueue.Create(name, isTransactional);
     SetQueuePermissions(queue);
     return queue;
 }

		public DuplexClientRuntimeChannel (ServiceEndpoint endpoint,
			ChannelFactory factory, EndpointAddress remoteAddress, Uri via)
			: base (endpoint, factory, remoteAddress, via)
		{
			var ed = new EndpointDispatcher (remoteAddress, endpoint.Contract.Name, endpoint.Contract.Namespace);
			ed.InitializeServiceEndpoint (true, null, endpoint);
			Runtime.CallbackDispatchRuntime = ed.DispatchRuntime;
		}

        public DirectChannelConfiguration(EndpointAddress address, MessagingConfiguration messagingConfiguration)
        {
            Contract.Requires(messagingConfiguration != null);
            Contract.Requires(address != null);

            this.messagingConfiguration = messagingConfiguration;
            this.address = address;
        }

 static void AdjustAddress(ref EndpointAddress reference, Uri via)
 {
     // if we don't have an identity and we have differing Uris, we should use the Via
     if (reference.Identity == null && reference.Uri != via)
     {
         reference = new EndpointAddress(via);
     }
 }

 public CallbackContextMessageProperty(EndpointAddress callbackAddress)
 {
     if (callbackAddress == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackAddress");
     }
     this.callbackAddress = callbackAddress;
 }

 public SenderAuthenticationSessionAttacher(
     AuthenticationSessionCache cache, 
     AuthenticatedServerRegistry registry,
     EndpointAddress address) : base(cache, registry)
 {
     Contract.Requires(address != null);
     this.address = address;
 }

        public ServiceEndpoint(ContractDescription contract, Binding binding, EndpointAddress address)
        {
            if (contract == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract");

            _contract = contract;
            _binding = binding;
            _address = address;
        }

        public void Send(EndpointAddress destination, ChannelMessage channelMessage)
        {
            var queueName = destination.QueueName;
            if (!namespaceManager.QueueExists(queueName)) throw new Exception(string.Format("Destination {0} does not exist.", destination));

            var sendingClient = QueueClient.Create(queueName);
            var message = CreateBrokeredMessage(channelMessage);
            sendingClient.Send(message);
        }

 public WebSocketTransportDuplexSessionChannel(HttpChannelFactory<IDuplexSessionChannel> channelFactory, EndpointAddress remoteAddresss, Uri via)
     : base(channelFactory, channelFactory, EndpointAddress.AnonymousAddress, channelFactory.MessageVersion.Addressing.AnonymousUri, remoteAddresss, via)
 {
     Fx.Assert(channelFactory.WebSocketSettings != null, "channelFactory.WebSocketTransportSettings should not be null.");
     _webSocketSettings = channelFactory.WebSocketSettings;
     _transferMode = channelFactory.TransferMode;
     _maxBufferSize = channelFactory.MaxBufferSize;
     _transportFactorySettings = channelFactory;
 }

        public CreateEndpointSettings(IEndpointAddress address)
            : this()
        {
            Guard.Against.Null(address, "The address cannot be null");

            Address = new EndpointAddress(address.Uri);

            SetDefaultErrorAddress();
        }

 MessageTransmitTraceRecord(Message message, string addressElementName, EndpointAddress address)
     :
     this(message, addressElementName)
 {
     if (address != null)
     {
         this.address = address.Uri;
     }
 }

        void FreeUpSlot(Guid messageId, EndpointAddress address, PersistenceUseType useType)
        {
            if (useType != cache.UseType || address != cache.Address) return;

            MessagePayload message;
            sentMessages.TryRemove(messageId, out message);

            SendMessages();
        }

 internal void EnsureOutgoingIdentity(EndpointAddress serviceReference, ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies)
 {
     if (authorizationPolicies == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("authorizationPolicies");
     }
     AuthorizationContext ac = AuthorizationContext.CreateDefaultAuthorizationContext(authorizationPolicies);
     EnsureIdentity(serviceReference, ac, SR.IdentityCheckFailedForOutgoingMessage);
 }

 public PublisherConfiguration(EndpointAddress address, MessagingConfiguration messagingConfiguration)
     : base(messagingConfiguration)
 {
     schema = new PublisherChannelSchema
     {
         FromAddress = address,  
         MessageFilterStrategy = new PassThroughMessageFilterStategy()
     };
 }

        public AnnouncementEndpoint(DiscoveryVersion discoveryVersion, Binding binding, EndpointAddress address)
            : base(GetAnnouncementContract(discoveryVersion))
        {
            // Send replies async to maintain performance
            this.EndpointBehaviors.Add(new DispatcherSynchronizationBehavior { AsynchronousSendEnabled = true });

            this.discoveryVersion = discoveryVersion;
            base.Address = address;
            base.Binding = binding;
        }

        public ResolveCriteria(EndpointAddress address)
        {
            if (address == null)
            {
                throw FxTrace.Exception.ArgumentNull("address");
            }

            this.endpointAddress = address;
            this.duration = ResolveCriteria.defaultDuration;
        }

        public MessageAddresser(
            EndpointAddress fromAddress, 
            EndpointAddress toAddress)
        {
            Contract.Requires(fromAddress != null);
            Contract.Requires(toAddress != null);

            this.fromAddress = fromAddress;
            this.toAddress = toAddress;
        }