Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.ServiceModel/System/ServiceModel/Description/ContractDescription.cs

@@ -0,0 +1,256 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Description
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.ComponentModel;
+    using System.Diagnostics;
+    using System.Net.Security;
+    using System.ServiceModel.Security;
+
+    [DebuggerDisplay("Name={name}, Namespace={ns}, ContractType={contractType}")]
+    public class ContractDescription
+    {
+        Type callbackContractType;
+        string configurationName;
+        Type contractType;
+        XmlName name;
+        string ns;
+        OperationDescriptionCollection operations;
+        SessionMode sessionMode;
+        KeyedByTypeCollection<IContractBehavior> behaviors = new KeyedByTypeCollection<IContractBehavior>();
+        ProtectionLevel protectionLevel;
+        bool hasProtectionLevel;
+
+        public ContractDescription(string name)
+            : this(name, null)
+        {
+        }
+
+        public ContractDescription(string name, string ns)
+        {
+            // the property setter validates given value
+            this.Name = name;
+            if (!string.IsNullOrEmpty(ns))
+                NamingHelper.CheckUriParameter(ns, "ns");
+
+            this.operations = new OperationDescriptionCollection();
+            this.ns = ns ?? NamingHelper.DefaultNamespace; // ns can be ""
+        }
+
+        internal string CodeName
+        {
+            get { return this.name.DecodedName; }
+        }
+
+        [DefaultValue(null)]
+        public string ConfigurationName
+        {
+            get { return this.configurationName; }
+            set { this.configurationName = value; }
+        }
+
+        public Type ContractType
+        {
+            get { return this.contractType; }
+            set { this.contractType = value; }
+        }
+
+        public Type CallbackContractType
+        {
+            get { return this.callbackContractType; }
+            set { this.callbackContractType = value; }
+        }
+
+        public string Name
+        {
+            get { return this.name.EncodedName; }
+            set
+            {
+                if (value == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
+                }
+
+                if (value.Length == 0)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
+                        new ArgumentOutOfRangeException("value", SR.GetString(SR.SFxContractDescriptionNameCannotBeEmpty)));
+                }
+                this.name = new XmlName(value, true /*isEncoded*/);
+            }
+        }
+
+        public string Namespace
+        {
+            get { return this.ns; }
+            set
+            {
+                if (!string.IsNullOrEmpty(value))
+                    NamingHelper.CheckUriProperty(value, "Namespace");
+                this.ns = value;
+            }
+        }
+
+        public OperationDescriptionCollection Operations
+        {
+            get { return this.operations; }
+        }
+
+        public ProtectionLevel ProtectionLevel
+        {
+            get { return this.protectionLevel; }
+            set
+            {
+                if (!ProtectionLevelHelper.IsDefined(value))
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
+                this.protectionLevel = value;
+                this.hasProtectionLevel = true;
+            }
+        }
+
+        public bool ShouldSerializeProtectionLevel()
+        {
+            return this.HasProtectionLevel;
+        }
+
+        public bool HasProtectionLevel
+        {
+            get { return this.hasProtectionLevel; }
+        }
+
+        [DefaultValue(SessionMode.Allowed)]
+        public SessionMode SessionMode
+        {
+            get { return this.sessionMode; }
+            set
+            {
+                if (!SessionModeHelper.IsDefined(value))
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
+                }
+
+                this.sessionMode = value;
+            }
+        }
+
+        public KeyedCollection<Type, IContractBehavior> ContractBehaviors 
+        {
+            get { return this.Behaviors; }
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)] 
+        public KeyedByTypeCollection<IContractBehavior> Behaviors
+        {
+            get { return this.behaviors; }
+        }
+
+        public static ContractDescription GetContract(Type contractType)
+        {
+            if (contractType == null)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contractType");
+
+            TypeLoader typeLoader = new TypeLoader();
+            return typeLoader.LoadContractDescription(contractType);
+        }
+
+        public static ContractDescription GetContract(Type contractType, Type serviceType)
+        {
+            if (contractType == null)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contractType");
+
+            if (serviceType == null)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceType");
+
+            TypeLoader typeLoader = new TypeLoader();
+            ContractDescription description = typeLoader.LoadContractDescription(contractType, serviceType);
+            return description;
+        }
+
+        public static ContractDescription GetContract(Type contractType, object serviceImplementation)
+        {
+            if (contractType == null)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contractType");
+
+            if (serviceImplementation == null)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceImplementation");
+
+            TypeLoader typeLoader = new TypeLoader();
+            Type serviceType = serviceImplementation.GetType();
+            ContractDescription description = typeLoader.LoadContractDescription(contractType, serviceType, serviceImplementation);
+            return description;
+        }
+
+        public Collection<ContractDescription> GetInheritedContracts()
+        {
+            Collection<ContractDescription> result = new Collection<ContractDescription>();
+            for (int i = 0; i < Operations.Count; i++)
+            {
+                OperationDescription od = Operations[i];
+                if (od.DeclaringContract != this)
+                {
+                    ContractDescription inheritedContract = od.DeclaringContract;
+                    if (!result.Contains(inheritedContract))
+                    {
+                        result.Add(inheritedContract);
+                    }
+                }
+            }
+            return result;
+        }
+
+        internal void EnsureInvariants()
+        {
+            if (string.IsNullOrEmpty(this.Name))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                    SR.GetString(SR.AChannelServiceEndpointSContractSNameIsNull0)));
+            }
+            if (this.Namespace == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                    SR.GetString(SR.AChannelServiceEndpointSContractSNamespace0)));
+            }
+            if (this.Operations.Count == 0)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                    SR.GetString(SR.SFxContractHasZeroOperations, this.Name)));
+            }
+            bool thereIsAtLeastOneInitiatingOperation = false;
+            for (int i = 0; i < this.Operations.Count; i++)
+            {
+                OperationDescription operationDescription = this.Operations[i];
+                operationDescription.EnsureInvariants();
+                if (operationDescription.IsInitiating)
+                    thereIsAtLeastOneInitiatingOperation = true;
+                if ((!operationDescription.IsInitiating || operationDescription.IsTerminating)
+                    && (this.SessionMode != SessionMode.Required))
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                        SR.GetString(SR.ContractIsNotSelfConsistentItHasOneOrMore2, this.Name)));
+                }
+            }
+            if (!thereIsAtLeastOneInitiatingOperation)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
+                    SR.GetString(SR.SFxContractHasZeroInitiatingOperations, this.Name)));
+            }
+        }
+
+        internal bool IsDuplex()
+        {
+            for (int i = 0; i < this.operations.Count; ++i)
+            {
+                if (this.operations[i].IsServerInitiated())
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}