Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.ServiceModel/System/ServiceModel/Channels/Binding.cs

@@ -0,0 +1,355 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//-----------------------------------------------------------------------------
+
+namespace System.ServiceModel.Channels
+{
+    using System;
+    using System.ComponentModel;
+    using System.Runtime;
+    using System.ServiceModel;
+    using System.ServiceModel.Description;
+
+    public abstract class Binding : IDefaultCommunicationTimeouts
+    {
+        TimeSpan closeTimeout = ServiceDefaults.CloseTimeout;
+        string name;
+        string namespaceIdentifier;
+        TimeSpan openTimeout = ServiceDefaults.OpenTimeout;
+        TimeSpan receiveTimeout = ServiceDefaults.ReceiveTimeout;
+        TimeSpan sendTimeout = ServiceDefaults.SendTimeout;
+        internal const string DefaultNamespace = NamingHelper.DefaultNamespace;
+
+        protected Binding()
+        {
+            this.name = null;
+            this.namespaceIdentifier = DefaultNamespace;
+        }
+
+        protected Binding(string name, string ns)
+        {
+            if (string.IsNullOrEmpty(name))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("name", SR.GetString(SR.SFXBindingNameCannotBeNullOrEmpty));
+            }
+            if (ns == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("ns");
+            }
+
+            if (ns.Length > 0)
+            {
+                NamingHelper.CheckUriParameter(ns, "ns");
+            }
+
+            this.name = name;
+            this.namespaceIdentifier = ns;
+        }
+
+
+        [DefaultValue(typeof(TimeSpan), ServiceDefaults.CloseTimeoutString)]
+        public TimeSpan CloseTimeout
+        {
+            get { return this.closeTimeout; }
+            set
+            {
+                if (value < TimeSpan.Zero)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, SR.GetString(SR.SFxTimeoutOutOfRange0)));
+                }
+                if (TimeoutHelper.IsTooLarge(value))
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
+                }
+
+                this.closeTimeout = value;
+            }
+        }
+
+        public string Name
+        {
+            get
+            {
+                if (this.name == null)
+                    this.name = this.GetType().Name;
+
+                return this.name;
+            }
+            set
+            {
+                if (string.IsNullOrEmpty(value))
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("value", SR.GetString(SR.SFXBindingNameCannotBeNullOrEmpty));
+
+                this.name = value;
+            }
+        }
+
+        public string Namespace
+        {
+            get { return this.namespaceIdentifier; }
+            set
+            {
+                if (value == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
+                }
+
+                if (value.Length > 0)
+                {
+                    NamingHelper.CheckUriProperty(value, "Namespace");
+                }
+                this.namespaceIdentifier = value;
+            }
+        }
+
+        [DefaultValue(typeof(TimeSpan), ServiceDefaults.OpenTimeoutString)]
+        public TimeSpan OpenTimeout
+        {
+            get { return this.openTimeout; }
+            set
+            {
+                if (value < TimeSpan.Zero)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, SR.GetString(SR.SFxTimeoutOutOfRange0)));
+                }
+                if (TimeoutHelper.IsTooLarge(value))
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
+                }
+
+                this.openTimeout = value;
+            }
+        }
+
+        [DefaultValue(typeof(TimeSpan), ServiceDefaults.ReceiveTimeoutString)]
+        public TimeSpan ReceiveTimeout
+        {
+            get { return this.receiveTimeout; }
+            set
+            {
+                if (value < TimeSpan.Zero)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, SR.GetString(SR.SFxTimeoutOutOfRange0)));
+                }
+                if (TimeoutHelper.IsTooLarge(value))
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
+                }
+
+                this.receiveTimeout = value;
+            }
+        }
+
+        public abstract string Scheme { get; }
+
+        public MessageVersion MessageVersion
+        {
+            get
+            {
+                return this.GetProperty<MessageVersion>(new BindingParameterCollection());
+            }
+        }
+
+        [DefaultValue(typeof(TimeSpan), ServiceDefaults.SendTimeoutString)]
+        public TimeSpan SendTimeout
+        {
+            get { return this.sendTimeout; }
+            set
+            {
+                if (value < TimeSpan.Zero)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, SR.GetString(SR.SFxTimeoutOutOfRange0)));
+                }
+                if (TimeoutHelper.IsTooLarge(value))
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
+                }
+
+                this.sendTimeout = value;
+            }
+        }
+
+        public IChannelFactory<TChannel> BuildChannelFactory<TChannel>(params object[] parameters)
+        {
+            return this.BuildChannelFactory<TChannel>(new BindingParameterCollection(parameters));
+        }
+
+        public virtual IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingParameterCollection parameters)
+        {
+            EnsureInvariants();
+            BindingContext context = new BindingContext(new CustomBinding(this), parameters);
+            IChannelFactory<TChannel> channelFactory = context.BuildInnerChannelFactory<TChannel>();
+            context.ValidateBindingElementsConsumed();
+            this.ValidateSecurityCapabilities(channelFactory.GetProperty<ISecurityCapabilities>(), parameters);
+
+            return channelFactory;
+        }
+
+        void ValidateSecurityCapabilities(ISecurityCapabilities runtimeSecurityCapabilities, BindingParameterCollection parameters)
+        {
+            ISecurityCapabilities bindingSecurityCapabilities = this.GetProperty<ISecurityCapabilities>(parameters);
+
+            if (!SecurityCapabilities.IsEqual(bindingSecurityCapabilities, runtimeSecurityCapabilities))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
+                    new InvalidOperationException(SR.GetString(SR.SecurityCapabilitiesMismatched, this)));
+            }
+        }
+
+        public virtual IChannelListener<TChannel> BuildChannelListener<TChannel>(params object[] parameters)
+            where TChannel : class, IChannel
+        {
+            return this.BuildChannelListener<TChannel>(new BindingParameterCollection(parameters));
+        }
+
+        public virtual IChannelListener<TChannel> BuildChannelListener<TChannel>(Uri listenUriBaseAddress, params object[] parameters)
+            where TChannel : class, IChannel
+        {
+            return this.BuildChannelListener<TChannel>(listenUriBaseAddress, new BindingParameterCollection(parameters));
+        }
+
+        public virtual IChannelListener<TChannel> BuildChannelListener<TChannel>(Uri listenUriBaseAddress, string listenUriRelativeAddress, params object[] parameters)
+            where TChannel : class, IChannel
+        {
+            return this.BuildChannelListener<TChannel>(listenUriBaseAddress, listenUriRelativeAddress, new BindingParameterCollection(parameters));
+        }
+
+        public virtual IChannelListener<TChannel> BuildChannelListener<TChannel>(Uri listenUriBaseAddress, string listenUriRelativeAddress, ListenUriMode listenUriMode, params object[] parameters)
+            where TChannel : class, IChannel
+        {
+            return this.BuildChannelListener<TChannel>(listenUriBaseAddress, listenUriRelativeAddress, listenUriMode, new BindingParameterCollection(parameters));
+        }
+
+        public virtual IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingParameterCollection parameters)
+            where TChannel : class, IChannel
+        {
+            UriBuilder listenUriBuilder = new UriBuilder(this.Scheme, DnsCache.MachineName);
+            return this.BuildChannelListener<TChannel>(listenUriBuilder.Uri, String.Empty, ListenUriMode.Unique, parameters);
+        }
+
+        public virtual IChannelListener<TChannel> BuildChannelListener<TChannel>(Uri listenUriBaseAddress, BindingParameterCollection parameters)
+            where TChannel : class, IChannel
+        {
+            return this.BuildChannelListener<TChannel>(listenUriBaseAddress, String.Empty, ListenUriMode.Explicit, parameters);
+        }
+
+        public virtual IChannelListener<TChannel> BuildChannelListener<TChannel>(Uri listenUriBaseAddress, string listenUriRelativeAddress, BindingParameterCollection parameters)
+            where TChannel : class, IChannel
+        {
+            return this.BuildChannelListener<TChannel>(listenUriBaseAddress, listenUriRelativeAddress, ListenUriMode.Explicit, parameters);
+        }
+
+        public virtual IChannelListener<TChannel> BuildChannelListener<TChannel>(Uri listenUriBaseAddress, string listenUriRelativeAddress, ListenUriMode listenUriMode, BindingParameterCollection parameters)
+            where TChannel : class, IChannel
+        {
+            EnsureInvariants();
+            BindingContext context = new BindingContext(new CustomBinding(this), parameters, listenUriBaseAddress, listenUriRelativeAddress, listenUriMode);
+            IChannelListener<TChannel> channelListener = context.BuildInnerChannelListener<TChannel>();
+            context.ValidateBindingElementsConsumed();
+            this.ValidateSecurityCapabilities(channelListener.GetProperty<ISecurityCapabilities>(), parameters);
+
+            return channelListener;
+        }
+
+        public bool CanBuildChannelFactory<TChannel>(params object[] parameters)
+        {
+            return this.CanBuildChannelFactory<TChannel>(new BindingParameterCollection(parameters));
+        }
+
+        public virtual bool CanBuildChannelFactory<TChannel>(BindingParameterCollection parameters)
+        {
+            BindingContext context = new BindingContext(new CustomBinding(this), parameters);
+            return context.CanBuildInnerChannelFactory<TChannel>();
+        }
+
+        public bool CanBuildChannelListener<TChannel>(params object[] parameters) where TChannel : class, IChannel
+        {
+            return this.CanBuildChannelListener<TChannel>(new BindingParameterCollection(parameters));
+        }
+
+        public virtual bool CanBuildChannelListener<TChannel>(BindingParameterCollection parameters) where TChannel : class, IChannel
+        {
+            BindingContext context = new BindingContext(new CustomBinding(this), parameters);
+            return context.CanBuildInnerChannelListener<TChannel>();
+        }
+
+        // the elements should NOT reference internal elements used by the Binding
+        public abstract BindingElementCollection CreateBindingElements();
+
+        public T GetProperty<T>(BindingParameterCollection parameters)
+            where T : class
+        {
+            BindingContext context = new BindingContext(new CustomBinding(this), parameters);
+            return context.GetInnerProperty<T>();
+        }
+
+        void EnsureInvariants()
+        {
+            EnsureInvariants(null);
+        }
+
+        internal void EnsureInvariants(string contractName)
+        {
+            BindingElementCollection elements = this.CreateBindingElements();
+            TransportBindingElement transport = null;
+            int index;
+            for (index = 0; index < elements.Count; index++)
+            {
+                transport = elements[index] as TransportBindingElement;
+                if (transport != null)
+                    break;
+            }
+
+            if (transport == null)
+            {
+                if (contractName == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                        SR.GetString(SR.CustomBindingRequiresTransport, this.Name)));
+                }
+                else
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                        SR.GetString(SR.SFxCustomBindingNeedsTransport1, contractName)));
+                }
+            }
+            if (index != elements.Count - 1)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                    SR.GetString(SR.TransportBindingElementMustBeLast, this.Name, transport.GetType().Name)));
+            }
+            if (string.IsNullOrEmpty(transport.Scheme))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                    SR.GetString(SR.InvalidBindingScheme, transport.GetType().Name)));
+            }
+
+            if (this.MessageVersion == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                    SR.GetString(SR.MessageVersionMissingFromBinding, this.Name)));
+            }
+        }
+
+        internal void CopyTimeouts(IDefaultCommunicationTimeouts source)
+        {
+            this.CloseTimeout = source.CloseTimeout;
+            this.OpenTimeout = source.OpenTimeout;
+            this.ReceiveTimeout = source.ReceiveTimeout;
+            this.SendTimeout = source.SendTimeout;
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public bool ShouldSerializeName()
+        {
+            return (this.Name != this.GetType().Name);
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public bool ShouldSerializeNamespace()
+        {
+            return (this.Namespace != DefaultNamespace);
+        }
+    }
+}
+