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; }
public AnnouncementEndpoint (DiscoveryVersion discoveryVersion) : this (discoveryVersion, null, null) { if (discoveryVersion == null) throw new ArgumentNullException ("discoveryVersion"); DiscoveryVersion = discoveryVersion; }
public AnnouncementEndpoint (DiscoveryVersion discoveryVersion, Binding binding, EndpointAddress address) : base (null, binding, address) { if (discoveryVersion == null) throw new ArgumentNullException ("discoveryVersion"); DiscoveryVersion = discoveryVersion; }
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); }
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; }
// (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); }
static ContractDescription GetDiscoveryContract(DiscoveryVersion discoveryVersion, ServiceDiscoveryMode discoveryMode) { if (discoveryVersion == null) { throw FxTrace.Exception.ArgumentNull("discoveryVersion"); } return discoveryVersion.Implementation.GetDiscoveryContract(discoveryMode); }
static ContractDescription GetAnnouncementContract(DiscoveryVersion discoveryVersion) { if (discoveryVersion == null) { throw FxTrace.Exception.ArgumentNull("discoveryVersion"); } return discoveryVersion.Implementation.GetAnnouncementContract(); }
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; }
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 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; }
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); }
public ProtocolSettings(DiscoveryVersion discoveryVersion) { Utility.IfNullThrowNullArgumentException(discoveryVersion, "discoveryVersion"); this.DiscoveryNamespace = discoveryVersion.Namespace; this.DiscoveryPrefix = ProtocolStrings.DiscoveryPrefix; if (discoveryVersion.Namespace == ProtocolStrings.DiscoveryNamespaceApril2005) { this.AddressingNamespace = ProtocolStrings.WsaNamespaceAugust2004; this.SchemeUri = ProtocolStrings.SchemeUriAugust2004; this.SupportsInclusivePrefixes = false; } else { this.AddressingNamespace = ProtocolStrings.WsaNamespace10; this.SchemeUri = ProtocolStrings.SchemeUri11; this.SupportsInclusivePrefixes = true; } }
internal static EndpointDiscoveryMetadata ReadXml (XmlReader reader, DiscoveryVersion version) { if (reader == null) throw new ArgumentNullException ("reader"); var ret = new EndpointDiscoveryMetadata (); reader.MoveToContent (); reader.ReadStartElement (); reader.MoveToContent (); // standard members reader.MoveToContent (); // it is possible due to InternalVisibleToAttribute... string addrNS = version.MessageVersion.Addressing.Namespace; ret.Address = EndpointAddress.ReadFrom (version.MessageVersion.Addressing, reader, "EndpointReference", addrNS); reader.MoveToContent (); if (reader.IsStartElement ("Types", version.Namespace)) ret.ContractTypeNames = new Collection<XmlQualifiedName> ((XmlQualifiedName []) reader.ReadElementContentAs (typeof (XmlQualifiedName []), null, "Types", version.Namespace)); reader.MoveToContent (); if (reader.IsStartElement ("Scopes", version.Namespace)) ret.Scopes = new Collection<Uri> ((Uri []) reader.ReadElementContentAs (typeof (Uri []), null, "Scopes", version.Namespace)); if (reader.IsStartElement ("XAddrs", version.Namespace)) ret.ListenUris = new Collection<Uri> ((Uri []) reader.ReadElementContentAs (typeof (Uri []), null, "XAddrs", version.Namespace)); if (reader.IsStartElement ("MetadataVersion", version.Namespace)) ret.Version = reader.ReadElementContentAsInt (); // non-standard members for (reader.MoveToContent (); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) ret.Extensions.Add (XElement.Load (reader)); reader.ReadEndElement (); return ret; }
public static XmlQualifiedName EnsureProbeSchema(DiscoveryVersion discoveryVersion, XmlSchemaSet schemaSet) { Fx.Assert(schemaSet != null, "The schemaSet must be non null."); Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null."); // do not find/add ProbeMatch related schema items SchemaTypes typesFound = SchemaTypes.ProbeMatchType | SchemaTypes.ResolveType; SchemaElements elementsFound = SchemaElements.XAddrs | SchemaElements.MetadataVersion; XmlSchema discoverySchema = null; ICollection discoverySchemas = schemaSet.Schemas(discoveryVersion.Namespace); if ((discoverySchemas == null) || (discoverySchemas.Count == 0)) { discoverySchema = CreateSchema(discoveryVersion); schemaSet.Add(discoverySchema); } else { foreach (XmlSchema schema in discoverySchemas) { discoverySchema = schema; if (schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.ProbeType)) { typesFound |= SchemaTypes.ProbeType; break; } LocateSchemaTypes(discoveryVersion, schema, ref typesFound); LocateSchemaElements(discoveryVersion, schema, ref elementsFound); } } if ((typesFound & SchemaTypes.ProbeType) != SchemaTypes.ProbeType) { AddSchemaTypes(discoveryVersion, typesFound, discoverySchema); AddElements(discoveryVersion, elementsFound, discoverySchema); schemaSet.Reprocess(discoverySchema); } return discoveryVersion.Implementation.QualifiedNames.ProbeType; }
void Intitialize(DiscoveryVersion discoveryVersion, SigningCertificateSettings signingStoreSettings) { Utility.IfNullThrowNullArgumentException(signingStoreSettings, "signingStoreSettings"); this.secureBindingElement = new CompactSignatureSecurityBindingElement( discoveryVersion, signingStoreSettings); Binding binding = base.Binding; CustomBinding customBinding = binding as CustomBinding; if (customBinding == null) { customBinding = new CustomBinding(binding); customBinding.Elements.Insert(0, secureBindingElement); base.Binding = customBinding; } else { customBinding.Elements.Insert(0, secureBindingElement); } }
internal static EndpointDiscoveryMetadata ReadXml (XmlReader reader, DiscoveryVersion version) { if (reader == null) throw new ArgumentNullException ("reader"); var ret = new EndpointDiscoveryMetadata (); reader.MoveToContent (); if (!reader.IsStartElement ("ProbeMatchType", version.Namespace) || reader.IsEmptyElement) throw new XmlException ("Non-empty ProbeMatchType element is expected"); reader.ReadStartElement ("ProbeType", version.Namespace); // standard members reader.MoveToContent (); ret.Address = EndpointAddress.ReadFrom (AddressingVersion.WSAddressing10, reader); reader.MoveToContent (); bool isEmpty = reader.IsEmptyElement; ret.ContractTypeNames = new Collection<XmlQualifiedName> ((XmlQualifiedName []) reader.ReadElementContentAs (typeof (XmlQualifiedName []), null, "Types", version.Namespace)); reader.MoveToContent (); if (reader.IsStartElement ("Scopes", version.Namespace)) ret.Scopes = new Collection<Uri> ((Uri []) reader.ReadElementContentAs (typeof (Uri []), null, "Scopes", version.Namespace)); if (reader.IsStartElement ("XAddrs", version.Namespace)) ret.ListenUris = new Collection<Uri> ((Uri []) reader.ReadElementContentAs (typeof (Uri []), null, "XAddrs", version.Namespace)); if (reader.IsStartElement ("MetadataVersion", version.Namespace)) ret.Version = reader.ReadElementContentAsInt (); // non-standard members for (reader.MoveToContent (); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) ret.Extensions.Add (XElement.Load (reader)); reader.ReadEndElement (); return ret; }
internal void WriteXml (XmlWriter writer, DiscoveryVersion version) { if (writer == null) throw new ArgumentNullException ("writer"); // standard members Address.WriteTo (AddressingVersion.WSAddressing10, writer); writer.WriteStartElement ("d", "Types", version.Namespace); int p = 0; foreach (var qname in ContractTypeNames) if (writer.LookupPrefix (qname.Namespace) == null) writer.WriteAttributeString ("xmlns", "p" + p++, "http://www.w3.org/2000/xmlns/", qname.Namespace); writer.WriteValue (ContractTypeNames); writer.WriteEndElement (); if (Scopes.Count > 0) { writer.WriteStartElement ("Scopes", version.Namespace); writer.WriteValue (Scopes); writer.WriteEndElement (); } if (ListenUris.Count > 0) { writer.WriteStartElement ("XAddrs", version.Namespace); writer.WriteValue (ListenUris); writer.WriteEndElement (); } writer.WriteStartElement ("MetadataVersion", version.Namespace); writer.WriteValue (Version); writer.WriteEndElement (); // non-standard members foreach (var ext in Extensions) ext.WriteTo (writer); }
static void LocateSchemaTypes(DiscoveryVersion discoveryVersion, XmlSchema schema, ref SchemaTypes typesFound) { if (((typesFound & SchemaTypes.QNameListType) != SchemaTypes.QNameListType) && (schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.QNameListType))) { typesFound |= SchemaTypes.QNameListType; } if (((typesFound & SchemaTypes.UriListType) != SchemaTypes.UriListType) && (schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.UriListType))) { typesFound |= SchemaTypes.UriListType; } if (((typesFound & SchemaTypes.ScopesType) != SchemaTypes.ScopesType) && (schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.ScopesType))) { typesFound |= SchemaTypes.ScopesType; } }
public AnnouncementEndpoint(DiscoveryVersion discoveryVersion) : this(discoveryVersion, null, null) { }
internal static XmlSchema BuildSchema (DiscoveryVersion version) { var schema = new XmlSchema () { TargetNamespace = version.Namespace }; var anyAttr = new XmlSchemaAnyAttribute () { Namespace = "##other", ProcessContents = XmlSchemaContentProcessing.Lax }; var probePart = new XmlSchemaSequence (); probePart.Items.Add (new XmlSchemaElement () { RefName = new XmlQualifiedName ("Types", version.Namespace), MinOccurs = 0 }); probePart.Items.Add (new XmlSchemaElement () { RefName = new XmlQualifiedName ("Scopes", version.Namespace), MinOccurs = 0 }); probePart.Items.Add (new XmlSchemaAny () { MinOccurs = 0, MaxOccursString = "unbounded", Namespace = "##other", ProcessContents = XmlSchemaContentProcessing.Lax }); var ct = new XmlSchemaComplexType () { Name = "ProbeType", Particle = probePart, AnyAttribute = anyAttr }; schema.Items.Add (ct); schema.Items.Add (new XmlSchemaSimpleType () { Name = "QNameListType", Content = new XmlSchemaSimpleTypeList () { ItemTypeName = new XmlQualifiedName ("QName", XmlSchema.Namespace) } }); var scr = new XmlSchemaSimpleContentRestriction () { BaseTypeName = new XmlQualifiedName ("UriListType", version.Namespace), AnyAttribute = anyAttr }; scr.Attributes.Add (new XmlSchemaAttribute () { Name = "matchBy", SchemaTypeName = new XmlQualifiedName ("anyURI", XmlSchema.Namespace) }); schema.Items.Add (new XmlSchemaComplexType () { Name = "ScopesType", ContentModel = new XmlSchemaSimpleContent () { Content = scr } }); schema.Items.Add (new XmlSchemaSimpleType () { Name = "UriListType", Content = new XmlSchemaSimpleTypeList () { ItemTypeName = new XmlQualifiedName ("anyURI", XmlSchema.Namespace) } }); schema.Items.Add (new XmlSchemaElement () { Name = "Types", SchemaTypeName = new XmlQualifiedName ("QNameListType", version.Namespace) }); schema.Items.Add (new XmlSchemaElement () { Name = "Scopes", SchemaTypeName = new XmlQualifiedName ("ScopesType", version.Namespace) }); return schema; }
internal static XmlSchema BuildSchema(DiscoveryVersion version) { var schema = new XmlSchema() { TargetNamespace = version.Namespace }; var anyAttr = new XmlSchemaAnyAttribute() { Namespace = "##other", ProcessContents = XmlSchemaContentProcessing.Lax }; var probePart = new XmlSchemaSequence(); probePart.Items.Add(new XmlSchemaElement() { RefName = new XmlQualifiedName("Types", version.Namespace), MinOccurs = 0 }); probePart.Items.Add(new XmlSchemaElement() { RefName = new XmlQualifiedName("Scopes", version.Namespace), MinOccurs = 0 }); probePart.Items.Add(new XmlSchemaAny() { MinOccurs = 0, MaxOccursString = "unbounded", Namespace = "##other", ProcessContents = XmlSchemaContentProcessing.Lax }); var ct = new XmlSchemaComplexType() { Name = "ProbeType", Particle = probePart, AnyAttribute = anyAttr }; schema.Items.Add(ct); schema.Items.Add(new XmlSchemaSimpleType() { Name = "QNameListType", Content = new XmlSchemaSimpleTypeList() { ItemTypeName = new XmlQualifiedName("QName", XmlSchema.Namespace) } }); var scr = new XmlSchemaSimpleContentRestriction() { BaseTypeName = new XmlQualifiedName("UriListType", version.Namespace), AnyAttribute = anyAttr }; scr.Attributes.Add(new XmlSchemaAttribute() { Name = "matchBy", SchemaTypeName = new XmlQualifiedName("anyURI", XmlSchema.Namespace) }); schema.Items.Add(new XmlSchemaComplexType() { Name = "ScopesType", ContentModel = new XmlSchemaSimpleContent() { Content = scr } }); schema.Items.Add(new XmlSchemaSimpleType() { Name = "UriListType", Content = new XmlSchemaSimpleTypeList() { ItemTypeName = new XmlQualifiedName("anyURI", XmlSchema.Namespace) } }); schema.Items.Add(new XmlSchemaElement() { Name = "Types", SchemaTypeName = new XmlQualifiedName("QNameListType", version.Namespace) }); schema.Items.Add(new XmlSchemaElement() { Name = "Scopes", SchemaTypeName = new XmlQualifiedName("ScopesType", version.Namespace) }); return(schema); }
// (2)->(6) public UdpAnnouncementEndpoint(DiscoveryVersion discoveryVersion) : this(discoveryVersion, DefaultMulticastAddress) { }
// (5)->(6) public UdpAnnouncementEndpoint (DiscoveryVersion discoveryVersion, string multicastAddress) : this (discoveryVersion, new Uri (multicastAddress)) { }
// (5)->(6) public UdpAnnouncementEndpoint(DiscoveryVersion discoveryVersion, string multicastAddress) : this(discoveryVersion, new Uri(multicastAddress)) { }
public DiscoveryEndpoint (DiscoveryVersion discoveryVersion, ServiceDiscoveryMode discoveryMode) : this (discoveryVersion, discoveryMode, null, null) { }
public static void WriteMetadataVersion(DiscoveryVersion discoveryVersion, int metadataVersion, XmlWriter writer) { writer.WriteStartElement(ProtocolStrings.SchemaNames.MetadataVersionElement, discoveryVersion.Namespace); writer.WriteValue(metadataVersion); writer.WriteEndElement(); }
internal void WriteXml (XmlWriter writer, DiscoveryVersion version) { if (writer == null) throw new ArgumentNullException ("writer"); // standard members writer.WriteStartElement ("d", "Types", version.Namespace); int p = 0; foreach (var qname in ContractTypeNames) if (writer.LookupPrefix (qname.Namespace) == null) writer.WriteAttributeString ("xmlns", "p" + p++, "http://www.w3.org/2000/xmlns/", qname.Namespace); writer.WriteValue (ContractTypeNames); writer.WriteEndElement (); writer.WriteStartElement ("Scopes", version.Namespace); if (ScopeMatchBy != null) { writer.WriteStartAttribute ("MatchBy"); writer.WriteValue (ScopeMatchBy); writer.WriteEndAttribute (); } writer.WriteValue (Scopes); writer.WriteEndElement (); // non-standard members if (MaxResults != default_max_results) { writer.WriteStartElement ("MaxResults", SerializationNS); writer.WriteValue (MaxResults); writer.WriteEndElement (); } writer.WriteStartElement ("Duration", SerializationNS); writer.WriteValue (Duration); writer.WriteEndElement (); foreach (var ext in Extensions) ext.WriteTo (writer); }
public DiscoveryEndpoint(DiscoveryVersion discoveryVersion, ServiceDiscoveryMode discoveryMode) : this(discoveryVersion, discoveryMode, null, null) { }
internal static FindCriteria ReadXml (XmlReader reader, DiscoveryVersion version) { if (reader == null) throw new ArgumentNullException ("reader"); var ret = new FindCriteria (); reader.MoveToContent (); if (!reader.IsStartElement ("Probe", version.Namespace) || reader.IsEmptyElement) throw new XmlException (String.Format ("Non-empty ProbeType element is expected. Got '{0}' {1} node in namespace '{2}' instead.", reader.LocalName, reader.NodeType, reader.NamespaceURI)); reader.ReadStartElement ("Probe", version.Namespace); // standard members reader.MoveToContent (); if (reader.IsStartElement ("Types", version.Namespace)) ret.ContractTypeNames = new Collection<XmlQualifiedName> ((XmlQualifiedName []) reader.ReadElementContentAs (typeof (XmlQualifiedName []), null, "Types", version.Namespace)); reader.MoveToContent (); if (reader.IsStartElement ("Types", version.Namespace)) { if (reader.MoveToAttribute ("MatchBy")) { ret.ScopeMatchBy = new Uri (reader.Value, UriKind.RelativeOrAbsolute); reader.MoveToElement (); } ret.Scopes = new Collection<Uri> ((Uri []) reader.ReadElementContentAs (typeof (Uri []), null, "Scopes", version.Namespace)); } // non-standard members for (reader.MoveToContent (); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) { if (reader.NamespaceURI == SerializationNS) { switch (reader.LocalName) { case "MaxResults": ret.MaxResults = reader.ReadElementContentAsInt (); break; case "Duration": ret.Duration = (TimeSpan) reader.ReadElementContentAs (typeof (TimeSpan), null); break; } } else ret.Extensions.Add (XElement.Load (reader)); } reader.ReadEndElement (); return ret; }
// (2)->(6) public UdpDiscoveryEndpoint(DiscoveryVersion discoveryVersion) : this(discoveryVersion, DefaultMulticastAddress) { }
internal void ReadFrom(DiscoveryVersion discoveryVersion, XmlReader reader) { ThrowIfOpen(); if (discoveryVersion == null) { throw FxTrace.Exception.ArgumentNull("discoveryVersion"); } if (reader == null) { throw FxTrace.Exception.ArgumentNull("reader"); } this.endpointAddress = new EndpointAddress(EndpointAddress.AnonymousUri); this.contractTypeNames = null; this.scopes = null; this.listenUris = null; this.metadataVersion = 0; this.extensions = null; this.isOpen = false; reader.MoveToContent(); if (reader.IsEmptyElement) { throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlEndpointNull)); } int startDepth = reader.Depth; reader.ReadStartElement(); this.endpointAddress = SerializationUtility.ReadEndpointAddress(discoveryVersion, reader); if (reader.IsStartElement(ProtocolStrings.SchemaNames.TypesElement, discoveryVersion.Namespace)) { this.contractTypeNames = new OpenableContractTypeNameCollection(false); SerializationUtility.ReadContractTypeNames(this.contractTypeNames, reader); } if (reader.IsStartElement(ProtocolStrings.SchemaNames.ScopesElement, discoveryVersion.Namespace)) { this.scopes = new OpenableScopeCollection(false); SerializationUtility.ReadScopes(this.scopes, reader); } if (reader.IsStartElement(ProtocolStrings.SchemaNames.XAddrsElement, discoveryVersion.Namespace)) { this.listenUris = new OpenableCollection <Uri>(false); SerializationUtility.ReadListenUris(listenUris, reader); } if (reader.IsStartElement(ProtocolStrings.SchemaNames.MetadataVersionElement, discoveryVersion.Namespace)) { this.metadataVersion = SerializationUtility.ReadMetadataVersion(reader); } while (true) { reader.MoveToContent(); if ((reader.NodeType == XmlNodeType.EndElement) && (reader.Depth == startDepth)) { break; } else if (reader.IsStartElement()) { this.Extensions.Add(XElement.ReadFrom(reader) as XElement); } else { reader.Read(); } } reader.ReadEndElement(); }
static void AddProbeMatchType(DiscoveryVersion discoveryVersion, XmlSchema schema) { // <xs:complexType name="ProbeMatchType"> XmlSchemaComplexType probeMatchType = new XmlSchemaComplexType(); probeMatchType.Name = ProtocolStrings.SchemaNames.ProbeMatchType; // <xs:sequence> XmlSchemaSequence probeMatcheSequence = new XmlSchemaSequence(); // <xs:element ref="wsa:EndpointReference" /> XmlSchemaElement eprElement = new XmlSchemaElement(); eprElement.RefName = discoveryVersion.Implementation.QualifiedNames.EprElement; // <xs:element minOccurs="0" ref="tns:Types" /> XmlSchemaElement typesElement = new XmlSchemaElement(); typesElement.RefName = discoveryVersion.Implementation.QualifiedNames.TypesElement; typesElement.MinOccurs = 0; // <xs:element minOccurs="0" ref="tns:Scopes" /> XmlSchemaElement scopesElement = new XmlSchemaElement(); scopesElement.RefName = discoveryVersion.Implementation.QualifiedNames.ScopesElement; scopesElement.MinOccurs = 0; // <xs:element minOccurs="0" ref="tns:XAddrs" /> XmlSchemaElement xAddrsElement = new XmlSchemaElement(); xAddrsElement.RefName = discoveryVersion.Implementation.QualifiedNames.XAddrsElement; xAddrsElement.MinOccurs = 0; // <xs:element ref="tns:MetadataVersion" /> -- allowing minOccurs=0 because the same type is used for Bye messages XmlSchemaElement metadataVersionElement = new XmlSchemaElement(); metadataVersionElement.RefName = discoveryVersion.Implementation.QualifiedNames.MetadataVersionElement; metadataVersionElement.MinOccurs = 0; // <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax" /> XmlSchemaAny any = new XmlSchemaAny(); any.Namespace = "##other"; any.ProcessContents = XmlSchemaContentProcessing.Lax; any.MinOccurs = 0; any.MaxOccurs = decimal.MaxValue; // </xs:sequence> probeMatcheSequence.Items.Add(eprElement); probeMatcheSequence.Items.Add(typesElement); probeMatcheSequence.Items.Add(scopesElement); probeMatcheSequence.Items.Add(xAddrsElement); probeMatcheSequence.Items.Add(metadataVersionElement); probeMatcheSequence.Items.Add(any); // <xs:anyAttribute namespace="##other" processContents="lax" /> XmlSchemaAnyAttribute anyAttribue = new XmlSchemaAnyAttribute(); anyAttribue.Namespace = "##other"; anyAttribue.ProcessContents = XmlSchemaContentProcessing.Lax; // </xs:complexType> probeMatchType.Particle = probeMatcheSequence; probeMatchType.AnyAttribute = anyAttribue; schema.Items.Add(probeMatchType); }
// (2)->(6) public UdpAnnouncementEndpoint (DiscoveryVersion discoveryVersion) : this (discoveryVersion, DefaultMulticastAddress) { }
public AnnouncementEndpoint(DiscoveryVersion discoveryVersion, Binding binding, EndpointAddress address) : base(GetContract(discoveryVersion), binding, address) { DiscoveryVersion = discoveryVersion; }
internal static FindCriteria ReadXml(XmlReader reader, DiscoveryVersion version) { if (reader == null) { throw new ArgumentNullException("reader"); } var ret = new FindCriteria(); reader.MoveToContent(); if (!reader.IsStartElement("Probe", version.Namespace) || reader.IsEmptyElement) { throw new XmlException(String.Format("Non-empty ProbeType element is expected. Got '{0}' {1} node in namespace '{2}' instead.", reader.LocalName, reader.NodeType, reader.NamespaceURI)); } reader.ReadStartElement("Probe", version.Namespace); // standard members reader.MoveToContent(); if (reader.IsStartElement("Types", version.Namespace)) { ret.ContractTypeNames = new Collection <XmlQualifiedName> ((XmlQualifiedName [])reader.ReadElementContentAs(typeof(XmlQualifiedName []), null, "Types", version.Namespace)); } reader.MoveToContent(); if (reader.IsStartElement("Types", version.Namespace)) { if (reader.MoveToAttribute("MatchBy")) { ret.ScopeMatchBy = new Uri(reader.Value, UriKind.RelativeOrAbsolute); reader.MoveToElement(); } } if (reader.IsStartElement("Scopes", version.Namespace)) { ret.Scopes = new Collection <Uri> ((Uri [])reader.ReadElementContentAs(typeof(Uri []), null, "Scopes", version.Namespace)); } // non-standard members for (reader.MoveToContent(); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NamespaceURI == SerializationNS) { switch (reader.LocalName) { case "MaxResults": ret.MaxResults = reader.ReadElementContentAsInt(); break; case "Duration": ret.Duration = (TimeSpan)reader.ReadElementContentAs(typeof(TimeSpan), null); break; } } else { ret.Extensions.Add(XElement.Load(reader)); } } reader.ReadEndElement(); return(ret); }