Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

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

@@ -0,0 +1,383 @@
+//----------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Channels
+{
+    using System.Collections.Generic;
+    using System.ServiceModel.Dispatcher;
+    using System.ServiceModel.Description;
+    using System.Globalization;
+    using System.Text;
+
+    struct ChannelRequirements
+    {
+        public bool usesInput;
+        public bool usesReply;
+        public bool usesOutput;
+        public bool usesRequest;
+        public SessionMode sessionMode;
+
+        public static void ComputeContractRequirements(ContractDescription contractDescription,
+            out ChannelRequirements requirements)
+        {
+            requirements = new ChannelRequirements();
+
+            requirements.usesInput = false;
+            requirements.usesReply = false;
+            requirements.usesOutput = false;
+            requirements.usesRequest = false;
+            requirements.sessionMode = contractDescription.SessionMode;
+
+            for (int i = 0; i < contractDescription.Operations.Count; i++)
+            {
+                OperationDescription operation = contractDescription.Operations[i];
+                bool oneWay = (operation.IsOneWay);
+                if (!operation.IsServerInitiated())
+                {
+                    if (oneWay)
+                    {
+                        requirements.usesInput = true;
+                    }
+                    else
+                    {
+                        requirements.usesReply = true;
+                    }
+                }
+                else
+                {
+                    if (oneWay)
+                    {
+                        requirements.usesOutput = true;
+                    }
+                    else
+                    {
+                        requirements.usesRequest = true;
+                    }
+                }
+            }
+        }
+
+        public static Type[] ComputeRequiredChannels(ref ChannelRequirements requirements)
+        {
+            if (requirements.usesOutput || requirements.usesRequest)
+            {
+                switch (requirements.sessionMode)
+                {
+                    case SessionMode.Allowed:
+                        return new Type[] {
+                            typeof(IDuplexChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.Required:
+                        return new Type[] {
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.NotAllowed:
+                        return new Type[] {
+                            typeof(IDuplexChannel),
+                        };
+                }
+            }
+            else if (requirements.usesInput && requirements.usesReply)
+            {
+                switch (requirements.sessionMode)
+                {
+                    case SessionMode.Allowed:
+                        return new Type[] {
+                            typeof(IRequestChannel),
+                            typeof(IRequestSessionChannel),
+                            typeof(IDuplexChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.Required:
+                        return new Type[] {
+                            typeof(IRequestSessionChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.NotAllowed:
+                        return new Type[] {
+                            typeof(IRequestChannel),
+                            typeof(IDuplexChannel),
+                        };
+                }
+            }
+            else if (requirements.usesInput)
+            {
+                switch (requirements.sessionMode)
+                {
+                    case SessionMode.Allowed:
+                        return new Type[] {
+                            typeof(IOutputChannel),
+                            typeof(IOutputSessionChannel),
+                            typeof(IRequestChannel),
+                            typeof(IRequestSessionChannel),
+                            typeof(IDuplexChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.Required:
+                        return new Type[] {
+                            typeof(IOutputSessionChannel),
+                            typeof(IRequestSessionChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.NotAllowed:
+                        return new Type[] {
+                            typeof(IOutputChannel),
+                            typeof(IRequestChannel),
+                            typeof(IDuplexChannel),
+                        };
+                }
+            }
+            else if (requirements.usesReply)
+            {
+                switch (requirements.sessionMode)
+                {
+                    case SessionMode.Allowed:
+                        return new Type[] {
+                            typeof(IRequestChannel),
+                            typeof(IRequestSessionChannel),
+                            typeof(IDuplexChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.Required:
+                        return new Type[] {
+                            typeof(IRequestSessionChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.NotAllowed:
+                        return new Type[] {
+                            typeof(IRequestChannel),
+                            typeof(IDuplexChannel),
+                        };
+                }
+            }
+            else
+            {
+                switch (requirements.sessionMode)
+                {
+                    case SessionMode.Allowed:
+                        return new Type[] {
+                            typeof(IOutputSessionChannel),
+                            typeof(IOutputChannel),
+                            typeof(IRequestSessionChannel),
+                            typeof(IRequestChannel),
+                            typeof(IDuplexChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.Required:
+                        return new Type[] {
+                            typeof(IOutputSessionChannel),
+                            typeof(IRequestSessionChannel),
+                            typeof(IDuplexSessionChannel),
+                        };
+
+                    case SessionMode.NotAllowed:
+                        return new Type[] {
+                            typeof(IOutputChannel),
+                            typeof(IRequestChannel),
+                            typeof(IDuplexChannel),
+                        };
+                }
+            }
+            return null;
+        }
+
+        public static bool IsSessionful(Type channelType)
+        {
+            return (channelType == typeof(IDuplexSessionChannel) ||
+                    channelType == typeof(IOutputSessionChannel) ||
+                    channelType == typeof(IInputSessionChannel) ||
+                    channelType == typeof(IReplySessionChannel) ||
+                    channelType == typeof(IRequestSessionChannel));
+        }
+
+        public static bool IsOneWay(Type channelType)
+        {
+            return (channelType == typeof(IOutputChannel) ||
+                    channelType == typeof(IInputChannel) ||
+                    channelType == typeof(IInputSessionChannel) ||
+                    channelType == typeof(IOutputSessionChannel));
+        }
+
+        public static bool IsRequestReply(Type channelType)
+        {
+            return (channelType == typeof(IRequestChannel) ||
+                    channelType == typeof(IReplyChannel) ||
+                    channelType == typeof(IReplySessionChannel) ||
+                    channelType == typeof(IRequestSessionChannel));
+        }
+
+        public static bool IsDuplex(Type channelType)
+        {
+            return (channelType == typeof(IDuplexChannel) ||
+                    channelType == typeof(IDuplexSessionChannel));
+        }
+
+        public static Exception CantCreateListenerException(IEnumerable<Type> supportedChannels, IEnumerable<Type> requiredChannels, string bindingName)
+        {
+            string contractChannelTypesString = "";
+            string bindingChannelTypesString = "";
+
+            Exception exception = ChannelRequirements.BindingContractMismatchException(supportedChannels, requiredChannels, bindingName,
+                ref contractChannelTypesString, ref bindingChannelTypesString);
+
+            if (exception == null)
+            {
+                // none of the obvious speculations about the failure holds, so we fall back to the generic error message
+                exception = new InvalidOperationException(SR.GetString(SR.EndpointListenerRequirementsCannotBeMetBy3,
+                        bindingName, contractChannelTypesString, bindingChannelTypesString));
+            }
+
+            return exception;
+        }
+
+        public static Exception CantCreateChannelException(IEnumerable<Type> supportedChannels, IEnumerable<Type> requiredChannels, string bindingName)
+        {
+            string contractChannelTypesString = "";
+            string bindingChannelTypesString = "";
+
+            Exception exception = ChannelRequirements.BindingContractMismatchException(supportedChannels, requiredChannels, bindingName,
+                ref contractChannelTypesString, ref bindingChannelTypesString);
+
+            if (exception == null)
+            {
+                // none of the obvious speculations about the failure holds, so we fall back to the generic error message
+                exception = new InvalidOperationException(SR.GetString(SR.CouldnTCreateChannelForType2, bindingName, contractChannelTypesString));
+            }
+
+            return exception;
+        }
+
+        public static Exception BindingContractMismatchException(IEnumerable<Type> supportedChannels, IEnumerable<Type> requiredChannels,
+            string bindingName, ref string contractChannelTypesString, ref string bindingChannelTypesString)
+        {
+            StringBuilder contractChannelTypes = new StringBuilder();
+            bool contractRequiresOneWay = true;
+            bool contractRequiresRequestReply = true;
+            bool contractRequiresDuplex = true;
+            bool contractRequiresTwoWay = true;  // request-reply or duplex
+            bool contractRequiresSession = true;
+            bool contractRequiresDatagram = true;
+            foreach (Type channelType in requiredChannels)
+            {
+                if (contractChannelTypes.Length > 0)
+                {
+                    contractChannelTypes.Append(CultureInfo.CurrentCulture.TextInfo.ListSeparator);
+                    contractChannelTypes.Append(" ");
+                }
+                string typeString = channelType.ToString();
+                contractChannelTypes.Append(typeString.Substring(typeString.LastIndexOf('.') + 1));
+
+                if (!ChannelRequirements.IsOneWay(channelType))
+                {
+                    contractRequiresOneWay = false;
+                }
+                if (!ChannelRequirements.IsRequestReply(channelType))
+                {
+                    contractRequiresRequestReply = false;
+                }
+                if (!ChannelRequirements.IsDuplex(channelType))
+                {
+                    contractRequiresDuplex = false;
+                }
+                if (!(ChannelRequirements.IsRequestReply(channelType) || ChannelRequirements.IsDuplex(channelType)))
+                {
+                    contractRequiresTwoWay = false;
+                }
+                if (!ChannelRequirements.IsSessionful(channelType))
+                {
+                    contractRequiresSession = false;
+                }
+                else
+                {
+                    contractRequiresDatagram = false;
+                }
+            }
+
+            StringBuilder bindingChannelTypes = new StringBuilder();
+            bool bindingSupportsOneWay = false;
+            bool bindingSupportsRequestReply = false;
+            bool bindingSupportsDuplex = false;
+            bool bindingSupportsSession = false;
+            bool bindingSupportsDatagram = false;
+            bool bindingSupportsAtLeastOneChannelType = false;
+            foreach (Type channelType in supportedChannels)
+            {
+                bindingSupportsAtLeastOneChannelType = true;
+                if (bindingChannelTypes.Length > 0)
+                {
+                    bindingChannelTypes.Append(CultureInfo.CurrentCulture.TextInfo.ListSeparator);
+                    bindingChannelTypes.Append(" ");
+                }
+                string typeString = channelType.ToString();
+                bindingChannelTypes.Append(typeString.Substring(typeString.LastIndexOf('.') + 1));
+
+                if (ChannelRequirements.IsOneWay(channelType))
+                {
+                    bindingSupportsOneWay = true;
+                }
+                if (ChannelRequirements.IsRequestReply(channelType))
+                {
+                    bindingSupportsRequestReply = true;
+                }
+                if (ChannelRequirements.IsDuplex(channelType))
+                {
+                    bindingSupportsDuplex = true;
+                }
+                if (ChannelRequirements.IsSessionful(channelType))
+                {
+                    bindingSupportsSession = true;
+                }
+                else
+                {
+                    bindingSupportsDatagram = true;
+                }
+            }
+            bool bindingSupportsTwoWay = bindingSupportsRequestReply || bindingSupportsDuplex;
+
+            if (!bindingSupportsAtLeastOneChannelType)
+            {
+                return new InvalidOperationException(SR.GetString(SR.BindingDoesnTSupportAnyChannelTypes1, bindingName));
+            }
+            if (contractRequiresSession && !bindingSupportsSession)
+            {
+                return new InvalidOperationException(SR.GetString(SR.BindingDoesnTSupportSessionButContractRequires1, bindingName));
+            }
+            if (contractRequiresDatagram && !bindingSupportsDatagram)
+            {
+                return new InvalidOperationException(SR.GetString(SR.BindingDoesntSupportDatagramButContractRequires, bindingName));
+            }
+            if (contractRequiresDuplex && !bindingSupportsDuplex)
+            {
+                return new InvalidOperationException(SR.GetString(SR.BindingDoesnTSupportDuplexButContractRequires1, bindingName));
+            }
+            if (contractRequiresRequestReply && !bindingSupportsRequestReply)
+            {
+                return new InvalidOperationException(SR.GetString(SR.BindingDoesnTSupportRequestReplyButContract1, bindingName));
+            }
+            if (contractRequiresOneWay && !bindingSupportsOneWay)
+            {
+                return new InvalidOperationException(SR.GetString(SR.BindingDoesnTSupportOneWayButContractRequires1, bindingName));
+            }
+            if (contractRequiresTwoWay && !bindingSupportsTwoWay)
+            {
+                return new InvalidOperationException(SR.GetString(SR.BindingDoesnTSupportTwoWayButContractRequires1, bindingName));
+            }
+
+            contractChannelTypesString = contractChannelTypes.ToString();
+            bindingChannelTypesString = bindingChannelTypes.ToString();
+
+            return null;
+        }
+    }
+}