C# Discovery.DiscoveryVersion类代码示例

		public AnnouncementEndpoint (DiscoveryVersion discoveryVersion)
			: this (discoveryVersion, null, null)
		{
			if (discoveryVersion == null)
				throw new ArgumentNullException ("discoveryVersion");
			DiscoveryVersion = discoveryVersion;
		}

		internal static ResolveCriteria ReadXml (XmlReader reader, DiscoveryVersion version)
		{
			if (reader == null)
				throw new ArgumentNullException ("reader");

			var ret = new ResolveCriteria ();

			reader.MoveToContent ();
			if (!reader.IsStartElement ("ResolveType", version.Namespace) || reader.IsEmptyElement)
				throw new XmlException ("Non-empty ResolveType element is expected");
			reader.ReadStartElement ("ResolveType", version.Namespace);

			// standard members
			reader.MoveToContent ();
			ret.Address = EndpointAddress.ReadFrom (version.MessageVersion.Addressing, reader);

			// non-standard members
			for (reader.MoveToContent (); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) {
				if (reader.NamespaceURI == SerializationNS) {
					switch (reader.LocalName) {
					case "Duration":
						ret.Duration = (TimeSpan) reader.ReadElementContentAs (typeof (TimeSpan), null);
						break;
					}
				}
				else
					ret.Extensions.Add (XElement.Load (reader));
			}

			reader.ReadEndElement ();

			return ret;
		}

		static DiscoveryVersion ()
		{
			v11 = new DiscoveryVersion ("WSDiscovery11",
				Namespace11,
				"urn:docs-oasis-open-org:ws-dd:ns:discovery:2009:01",
				MessageVersion.Soap12WSAddressing10,
				typeof (Version11.IAnnouncementContract11),
				typeof (AnnouncementClient11),
				typeof (IDiscoveryProxyContract11),
				typeof (DiscoveryProxyClient11),
				typeof (IDiscoveryTargetContract11),
				typeof (DiscoveryTargetClient11));

			april2005 = new DiscoveryVersion ("WSDiscoveryApril2005",
				NamespaceApril2005,
				"urn:schemas-xmlsoap-org:ws:2005:04:discovery",
				MessageVersion.Soap12WSAddressingAugust2004,
				typeof (IAnnouncementContractApril2005),
				typeof (AnnouncementClientApril2005),
				typeof (IDiscoveryProxyContractApril2005),
				typeof (DiscoveryProxyClientApril2005),
				typeof (IDiscoveryTargetContractApril2005),
				typeof (DiscoveryTargetClientApril2005));

			cd1 = new DiscoveryVersion ("WSDiscoveryCD1",
				NamespaceCD1,
				"urn:docs-oasis-open-org:ws-dd:discovery:2008:09",
				MessageVersion.Soap12WSAddressingAugust2004,
				typeof (IAnnouncementContractCD1),
				typeof (AnnouncementClientCD1),
				typeof (IDiscoveryProxyContractCD1),
				typeof (DiscoveryProxyClientCD1),
				typeof (IDiscoveryTargetContractCD1),
				typeof (DiscoveryTargetClientCD1));
		}

		public DiscoveryEndpoint (DiscoveryVersion discoveryVersion, ServiceDiscoveryMode discoveryMode, Binding binding, EndpointAddress endpointAddress)
			: base (GetContract (discoveryVersion, discoveryMode), binding, endpointAddress)
		{
			DiscoveryVersion = discoveryVersion;
			DiscoveryMode = discoveryMode;

			IsSystemEndpoint = true;
		}

		// (6), everything falls to here
		public UdpAnnouncementEndpoint (DiscoveryVersion discoveryVersion, Uri multicastAddress)
			: base (discoveryVersion, CreateBinding (), new EndpointAddress (discoveryVersion.AdhocAddress))
		{
			ListenUri = multicastAddress;
			TransportSettings = new UdpTransportSettings ();
			MulticastAddress = multicastAddress;
			MaxAnnouncementDelay = TimeSpan.FromMilliseconds (500);
		}

		// (6), everything falls to here.
		public UdpDiscoveryEndpoint (DiscoveryVersion discoveryVersion, Uri multicastAddress)
			: base (discoveryVersion, ServiceDiscoveryMode.Adhoc, CreateBinding (), new EndpointAddress (discoveryVersion.AdhocAddress))
		{
			ListenUri = multicastAddress;
			TransportSettings = new UdpTransportSettings ();
			MulticastAddress = multicastAddress;
			MaxResponseDelay = TimeSpan.FromMilliseconds (500);
		}

		public DiscoveryEndpoint (DiscoveryVersion discoveryVersion, ServiceDiscoveryMode discoveryMode, Binding binding, EndpointAddress endpointAddress)
			: base (null, binding, endpointAddress)
		{
			if (discoveryVersion == null)
				throw new ArgumentNullException ("discoveryVersion");
			DiscoveryVersion = discoveryVersion;
			DiscoveryMode = discoveryMode;
		}

        static ContractDescription GetAnnouncementContract(DiscoveryVersion discoveryVersion)
        {
            if (discoveryVersion == null)
            {
                throw FxTrace.Exception.ArgumentNull("discoveryVersion");
            }

            return discoveryVersion.Implementation.GetAnnouncementContract();
        }

        static ContractDescription GetDiscoveryContract(DiscoveryVersion discoveryVersion, ServiceDiscoveryMode discoveryMode)
        {
            if (discoveryVersion == null)
            {
                throw FxTrace.Exception.ArgumentNull("discoveryVersion");
            }

            return discoveryVersion.Implementation.GetDiscoveryContract(discoveryMode);
        }

        public static XmlQualifiedName EnsureProbeMatchSchema(DiscoveryVersion discoveryVersion, XmlSchemaSet schemaSet)
        {
            Fx.Assert(schemaSet != null, "The schemaSet must be non null.");
            Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null.");

            // ensure that EPR is added to the schema.
            if (discoveryVersion == DiscoveryVersion.WSDiscoveryApril2005 || discoveryVersion == DiscoveryVersion.WSDiscoveryCD1)
            {
                EndpointAddressAugust2004.GetSchema(schemaSet);
            }
            else if (discoveryVersion == DiscoveryVersion.WSDiscovery11)
            {
                EndpointAddress10.GetSchema(schemaSet);
            }
            else
            {
                Fx.Assert("The discoveryVersion is not supported.");
            }

            // do not add/find Probe related schema items
            SchemaTypes typesFound = SchemaTypes.ProbeType | SchemaTypes.ResolveType;
            SchemaElements elementsFound = SchemaElements.None;         

            XmlSchema discoverySchema = null;
            ICollection discoverySchemas = schemaSet.Schemas(discoveryVersion.Namespace);
            if ((discoverySchemas == null) || (discoverySchemas.Count == 0))
            {
                discoverySchema = CreateSchema(discoveryVersion);
                AddImport(discoverySchema, discoveryVersion.Implementation.WsaNamespace);
                schemaSet.Add(discoverySchema);
            }
            else
            {                
                foreach (XmlSchema schema in discoverySchemas)
                {
                    discoverySchema = schema;
                    if (schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.ProbeMatchType))
                    {
                        typesFound |= SchemaTypes.ProbeMatchType;
                        break;
                    }

                    LocateSchemaTypes(discoveryVersion, schema, ref typesFound);
                    LocateSchemaElements(discoveryVersion, schema, ref elementsFound);
                }
            }

            if ((typesFound & SchemaTypes.ProbeMatchType) != SchemaTypes.ProbeMatchType)
            {
                AddSchemaTypes(discoveryVersion, typesFound, discoverySchema);
                AddElements(discoveryVersion, elementsFound, discoverySchema);
                schemaSet.Reprocess(discoverySchema);
            }

            return discoveryVersion.Implementation.QualifiedNames.ProbeMatchType;
        }

        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;
        }

		static ContractDescription GetContract (DiscoveryVersion discoveryVersion, ServiceDiscoveryMode mode)
		{
			if (discoveryVersion == null)
				throw new ArgumentNullException ("discoveryVersion");
			// Provide different contract type for Adhoc mode and Managed mode, respectively.
			if (mode == ServiceDiscoveryMode.Managed)
				return ContractDescription.GetContract (discoveryVersion.DiscoveryProxyContractType);
			else
				return ContractDescription.GetContract (discoveryVersion.DiscoveryTargetContractType);
		}

        public DiscoveryEndpoint(DiscoveryVersion discoveryVersion, ServiceDiscoveryMode discoveryMode, Binding binding, EndpointAddress endpointAddress)
            : base(GetDiscoveryContract(discoveryVersion, discoveryMode))
        {
            base.IsSystemEndpoint = true;
                           
            this.discoveryOperationContextExtension = new DiscoveryOperationContextExtension(TimeSpan.Zero, discoveryMode, discoveryVersion);

            base.Behaviors.Add(new DiscoveryOperationContextExtensionInitializer(this.discoveryOperationContextExtension));
            base.Behaviors.Add(new DiscoveryEndpointValidator());

            base.Address = endpointAddress;
            base.Binding = binding;
        }

        public UdpAnnouncementEndpoint(DiscoveryVersion discoveryVersion, Uri multicastAddress)
            : base(discoveryVersion)
        {
            if (multicastAddress == null)
            {
                throw FxTrace.Exception.ArgumentNull("multicastAddress");
            }
            if (discoveryVersion == null)
            {
                throw FxTrace.Exception.ArgumentNull("discoveryVersion");
            }

            Initialize(multicastAddress);
        }

        public UdpDiscoveryEndpoint(DiscoveryVersion discoveryVersion, Uri multicastAddress)
            : base(discoveryVersion, ServiceDiscoveryMode.Adhoc)
        {
            if (multicastAddress == null)
            {
                throw FxTrace.Exception.ArgumentNull("multicastAddress");
            }
            if (discoveryVersion == null)
            {
                throw FxTrace.Exception.ArgumentNull("discoveryVersion");
            }

            // Send replies async to maintain performance
            base.Behaviors.Add(new DispatcherSynchronizationBehavior { AsynchronousSendEnabled = true });

            Initialize(multicastAddress);
        }