Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

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

@@ -0,0 +1,342 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Channels
+{
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Runtime.Serialization;
+    using System.ServiceModel;
+    using System.ServiceModel.Description;
+    using System.ServiceModel.Security;
+    using System.Xml;
+
+    public sealed class OneWayBindingElement : BindingElement,
+        IPolicyExportExtension
+    {
+        ChannelPoolSettings channelPoolSettings;
+        bool packetRoutable;
+        int maxAcceptedChannels;
+
+        public OneWayBindingElement()
+        {
+            this.channelPoolSettings = new ChannelPoolSettings();
+            this.packetRoutable = OneWayDefaults.PacketRoutable;
+            this.maxAcceptedChannels = OneWayDefaults.MaxAcceptedChannels;
+        }
+
+        OneWayBindingElement(OneWayBindingElement elementToBeCloned)
+            : base(elementToBeCloned)
+        {
+            this.channelPoolSettings = elementToBeCloned.ChannelPoolSettings.Clone();
+            this.packetRoutable = elementToBeCloned.PacketRoutable;
+            this.maxAcceptedChannels = elementToBeCloned.maxAcceptedChannels;
+        }
+
+        public ChannelPoolSettings ChannelPoolSettings
+        {
+            get
+            {
+                return this.channelPoolSettings;
+            }
+
+            set
+            {
+                if (value == null)
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
+                this.channelPoolSettings = value;
+            }
+        }
+
+        // server
+        [DefaultValue(OneWayDefaults.MaxAcceptedChannels)]
+        public int MaxAcceptedChannels
+        {
+            get
+            {
+                return this.maxAcceptedChannels;
+            }
+            set
+            {
+                if (value <= 0)
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
+                        SR.GetString(SR.ValueMustBePositive)));
+
+                this.maxAcceptedChannels = value;
+            }
+        }
+
+        [DefaultValue(OneWayDefaults.PacketRoutable)]
+        public bool PacketRoutable
+        {
+            get
+            {
+                return this.packetRoutable;
+            }
+
+            set
+            {
+                this.packetRoutable = value;
+            }
+        }
+
+        public override BindingElement Clone()
+        {
+            return new OneWayBindingElement(this);
+        }
+
+        public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
+        {
+            if (context == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
+            }
+
+            if (typeof(TChannel) != typeof(IOutputChannel))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("TChannel",
+                    SR.GetString(SR.ChannelTypeNotSupported, typeof(TChannel)));
+            }
+
+            // Prefer IDuplexChannel
+            if (context.CanBuildInnerChannelFactory<IDuplexChannel>())
+            {
+                return (IChannelFactory<TChannel>)(object)new DuplexOneWayChannelFactory(this, context);
+            }
+
+            // Prefer IDuplexSessionChannel
+            if (context.CanBuildInnerChannelFactory<IDuplexSessionChannel>())
+            {
+                return (IChannelFactory<TChannel>)(object)new DuplexSessionOneWayChannelFactory(this, context);
+            }
+
+            // Followed by IRequestChannel
+            if (context.CanBuildInnerChannelFactory<IRequestChannel>())
+            {
+                return (IChannelFactory<TChannel>)(object)new RequestOneWayChannelFactory(this, context);
+            }
+
+            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
+#pragma warning suppress 56506 // context.Binding will never be null.
+new InvalidOperationException(SR.GetString(SR.OneWayInternalTypeNotSupported, context.Binding.Name)));
+        }
+
+        public override IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingContext context)
+        {
+            if (context == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
+            }
+
+            if (typeof(TChannel) != typeof(IInputChannel))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("TChannel",
+                    SR.GetString(SR.ChannelTypeNotSupported, typeof(TChannel)));
+            }
+
+            // Prefer IDuplexChannel
+            if (context.CanBuildInnerChannelListener<IDuplexChannel>())
+            {
+                return (IChannelListener<TChannel>)(object)new DuplexOneWayChannelListener(this, context);
+            }
+
+            // Prefer IDuplexSessionChannel
+            if (context.CanBuildInnerChannelListener<IDuplexSessionChannel>())
+            {
+                return (IChannelListener<TChannel>)(object)new DuplexSessionOneWayChannelListener(this, context);
+            }
+
+            // Followed by IRequestChannel
+            if (context.CanBuildInnerChannelListener<IReplyChannel>())
+            {
+                return (IChannelListener<TChannel>)(object)new ReplyOneWayChannelListener(this, context);
+            }
+
+            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
+#pragma warning suppress 56506 // context.Binding will never be null.
+new InvalidOperationException(SR.GetString(SR.OneWayInternalTypeNotSupported, context.Binding.Name)));
+        }
+
+        public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
+        {
+            if (context == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
+            }
+
+            if (typeof(TChannel) != typeof(IOutputChannel))
+            {
+                return false;
+            }
+
+            // we can convert IDuplexChannel
+            if (context.CanBuildInnerChannelFactory<IDuplexChannel>())
+            {
+                return true;
+            }
+
+            // we can convert IDuplexSessionChannel
+            if (context.CanBuildInnerChannelFactory<IDuplexSessionChannel>())
+            {
+                return true;
+            }
+
+            // and also IRequestChannel
+            if (context.CanBuildInnerChannelFactory<IRequestChannel>())
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public override bool CanBuildChannelListener<TChannel>(BindingContext context)
+        {
+            if (context == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
+            }
+
+            if (typeof(TChannel) != typeof(IInputChannel))
+            {
+                return false;
+            }
+
+            // we can convert IDuplexChannel
+            if (context.CanBuildInnerChannelListener<IDuplexChannel>())
+            {
+                return true;
+            }
+
+            // we can convert IDuplexSessionChannel
+            if (context.CanBuildInnerChannelListener<IDuplexSessionChannel>())
+            {
+                return true;
+            }
+
+            // and also IRequestChannel
+            if (context.CanBuildInnerChannelListener<IReplyChannel>())
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        static MessagePartSpecification oneWaySignedMessageParts;
+
+        static MessagePartSpecification OneWaySignedMessageParts
+        {
+            get
+            {
+                if (oneWaySignedMessageParts == null)
+                {
+                    MessagePartSpecification tempSignedMessageParts = new MessagePartSpecification(
+                        new XmlQualifiedName(DotNetOneWayStrings.HeaderName, DotNetOneWayStrings.Namespace)
+                        );
+                    tempSignedMessageParts.MakeReadOnly();
+                    oneWaySignedMessageParts = tempSignedMessageParts;
+                }
+
+                return oneWaySignedMessageParts;
+            }
+        }
+
+        public override T GetProperty<T>(BindingContext context)
+        {
+            if (context == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
+            }
+
+            // make sure our Datagram header is signed
+            if (typeof(T) == typeof(ChannelProtectionRequirements))
+            {
+                ChannelProtectionRequirements myRequirements = new ChannelProtectionRequirements();
+                if (PacketRoutable)
+                {
+                    myRequirements.IncomingSignatureParts.AddParts(OneWaySignedMessageParts);
+                    myRequirements.OutgoingSignatureParts.AddParts(OneWaySignedMessageParts);
+                }
+                ChannelProtectionRequirements innerRequirements = context.GetInnerProperty<ChannelProtectionRequirements>();
+                if (innerRequirements != null)
+                {
+                    myRequirements.Add(innerRequirements);
+                }
+                return (T)(object)myRequirements;
+            }
+            else
+            {
+                return context.GetInnerProperty<T>();
+            }
+        }
+
+        internal override bool IsMatch(BindingElement b)
+        {
+            if (b == null)
+            {
+                return false;
+            }
+
+            OneWayBindingElement oneWayBindingElement = b as OneWayBindingElement;
+            if (oneWayBindingElement == null)
+            {
+                return false;
+            }
+
+            if (!this.channelPoolSettings.IsMatch(oneWayBindingElement.ChannelPoolSettings))
+            {
+                return false;
+            }
+
+            if (this.packetRoutable != oneWayBindingElement.PacketRoutable)
+            {
+                return false;
+            }
+
+            if (this.maxAcceptedChannels != oneWayBindingElement.MaxAcceptedChannels)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
+        {
+            if (context == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
+            }
+
+            if (context.BindingElements != null)
+            {
+                OneWayBindingElement oneWay = context.BindingElements.Find<OneWayBindingElement>();
+
+                if (oneWay != null)
+                {
+                    // base assertion
+                    XmlDocument doc = new XmlDocument();
+                    XmlElement assertion = doc.CreateElement(OneWayPolicyConstants.Prefix,
+                        OneWayPolicyConstants.OneWay, OneWayPolicyConstants.Namespace);
+
+                    if (oneWay.PacketRoutable)
+                    {
+                        // add nested packet routable assertion 
+                        XmlElement child = doc.CreateElement(OneWayPolicyConstants.Prefix, OneWayPolicyConstants.PacketRoutable, OneWayPolicyConstants.Namespace);
+                        assertion.AppendChild(child);
+                    }
+
+                    context.GetBindingAssertions().Add(assertion);
+                }
+            }
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public bool ShouldSerializeChannelPoolSettings()
+        {
+            return this.channelPoolSettings.InternalShouldSerialize();
+        }
+    }
+}