Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

479 lines
18 KiB
C#

//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------
namespace System.ServiceModel.Discovery
{
using System;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Runtime;
using System.Text;
using System.Xml;
using SR2 = System.ServiceModel.Discovery.SR;
static class SerializationUtility
{
static char[] whiteSpaceChars = new char[] { ' ', '\t', '\n', '\r' };
public static XmlQualifiedName ParseQName(string prefixedQName, XmlReader reader)
{
Fx.Assert(prefixedQName != null, "The prefixedQName must be non null.");
Fx.Assert(reader != null, "The reader must be non null.");
int index = prefixedQName.IndexOf(':');
string ns;
string localname;
if (index != -1)
{
string prefix = prefixedQName.Substring(0, index);
ns = reader.LookupNamespace(prefix);
if (ns == null)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlQNamePrefixNotDefined(prefix, prefixedQName)));
}
localname = prefixedQName.Substring(index + 1);
if (localname == string.Empty)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlQNameLocalnameNotDefined(prefixedQName)));
}
}
else
{
ns = string.Empty;
localname = prefixedQName;
}
localname = XmlConvert.DecodeName(localname);
return new XmlQualifiedName(localname, ns);
}
public static void ParseQNameList(string listOfQNamesAsString, Collection<XmlQualifiedName> qNameCollection, XmlReader reader)
{
Fx.Assert(listOfQNamesAsString != null, "The listOfQNamesAsString must be non null.");
Fx.Assert(qNameCollection != null, "The qNameCollection must be non null.");
Fx.Assert(reader != null, "The reader must be non null.");
string[] prefixedQNames = listOfQNamesAsString.Split(whiteSpaceChars, StringSplitOptions.RemoveEmptyEntries);
if (prefixedQNames.Length > 0)
{
for (int i = 0; i < prefixedQNames.Length; i++)
{
qNameCollection.Add(ParseQName(prefixedQNames[i], reader));
}
}
}
public static void ParseUriList(string listOfUrisAsString, Collection<Uri> uriCollection, UriKind uriKind)
{
Fx.Assert(listOfUrisAsString != null, "The listOfUrisAsString must be non null.");
Fx.Assert(uriCollection != null, "The uriCollection must be non null.");
string[] uriStrings = listOfUrisAsString.Split(whiteSpaceChars, StringSplitOptions.RemoveEmptyEntries);
if (uriStrings.Length > 0)
{
for (int i = 0; i < uriStrings.Length; i++)
{
try
{
uriCollection.Add(new Uri(uriStrings[i], uriKind));
}
catch (FormatException fe)
{
if (uriKind == UriKind.Absolute)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlAbsoluteUriFormatError(uriStrings[i]), fe));
}
else
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlUriFormatError(uriStrings[i]), fe));
}
}
}
}
}
public static long ReadUInt(string uintString, string notFoundExceptionString, string exceptionString)
{
long result;
if (uintString == null)
{
throw FxTrace.Exception.AsError(new XmlException(notFoundExceptionString));
}
try
{
result = XmlConvert.ToUInt32(uintString);
}
catch (FormatException fe)
{
throw FxTrace.Exception.AsError(new XmlException(exceptionString, fe));
}
catch (OverflowException oe)
{
throw FxTrace.Exception.AsError(new XmlException(exceptionString, oe));
}
return result;
}
static void PrepareQNameString(StringBuilder listOfQNamesString, ref bool emptyNsDeclared, ref int prefixCount, XmlWriter writer, XmlQualifiedName qname)
{
string prefix;
string encodedLocalName = XmlConvert.EncodeLocalName(qname.Name.Trim());
if (qname.Namespace.Length == 0)
{
if (!emptyNsDeclared)
{
writer.WriteAttributeString("xmlns", string.Empty, null, string.Empty);
emptyNsDeclared = true;
}
prefix = null;
}
else
{
prefix = writer.LookupPrefix(qname.Namespace);
if (prefix == null)
{
prefix = "dp" + prefixCount++;
writer.WriteAttributeString("xmlns", prefix, null, qname.Namespace);
}
}
if (!string.IsNullOrEmpty(prefix))
{
listOfQNamesString.AppendFormat(CultureInfo.InvariantCulture, "{0}:{1}", prefix, encodedLocalName);
}
else
{
listOfQNamesString.AppendFormat(CultureInfo.InvariantCulture, "{0}", encodedLocalName);
}
}
public static void WriteQName(XmlWriter writer, XmlQualifiedName qname)
{
Fx.Assert(writer != null, "The writer must be non null.");
Fx.Assert(qname != null, "The qnames must be non null.");
StringBuilder qNameString = new StringBuilder();
int prefixCount = 0;
bool emptyNsDeclared = false;
PrepareQNameString(qNameString, ref emptyNsDeclared, ref prefixCount, writer, qname);
writer.WriteString(qNameString.ToString());
}
public static void WriteListOfQNames(XmlWriter writer, Collection<XmlQualifiedName> qnames)
{
Fx.Assert(writer != null, "The writer must be non null.");
Fx.Assert(qnames != null, "The qnames must be non null.");
int prefixCount = 0;
bool emptyNsDeclared = false;
StringBuilder listOfQNamesString = new StringBuilder();
foreach (XmlQualifiedName qname in qnames)
{
if (listOfQNamesString.Length != 0)
{
listOfQNamesString.Append(' ');
}
PrepareQNameString(listOfQNamesString, ref emptyNsDeclared, ref prefixCount, writer, qname);
}
writer.WriteString(listOfQNamesString.ToString());
}
public static void WriteListOfUris(XmlWriter writer, Collection<Uri> uris)
{
Fx.Assert(writer != null, "The writer must be non null.");
Fx.Assert(uris != null, "The uris must be non null.");
if (uris.Count > 0)
{
for (int i = 0; i < uris.Count - 1; i++)
{
writer.WriteString(uris[i].GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped));
writer.WriteWhitespace(" ");
}
writer.WriteString(uris[uris.Count - 1].GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped));
}
}
public static int ReadMaxResults(XmlReader reader)
{
int maxResults = int.MaxValue;
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.ReadStartElement();
maxResults = reader.ReadContentAsInt();
if (maxResults <= 0)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlMaxResultsLessThanZero(maxResults)));
}
reader.ReadEndElement();
}
return maxResults;
}
public static TimeSpan ReadDuration(XmlReader reader)
{
TimeSpan timeout = TimeSpan.MaxValue;
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.ReadStartElement();
string timeoutString = reader.ReadString();
timeout = SerializationUtility.ReadTimespan(timeoutString, SR2.DiscoveryXmlDurationDeserializationError(timeoutString));
if (timeout <= TimeSpan.Zero)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlDurationLessThanZero(timeout)));;
}
reader.ReadEndElement();
}
return timeout;
}
public static TimeSpan ReadTimespan(string timespanString, string exceptionString)
{
TimeSpan result;
try
{
result = XmlConvert.ToTimeSpan(timespanString);
}
catch (FormatException fe)
{
throw FxTrace.Exception.AsError(new XmlException(exceptionString, fe));
}
catch (OverflowException oe)
{
throw FxTrace.Exception.AsError(new XmlException(exceptionString, oe));
}
return result;
}
public static EndpointAddress ReadEndpointAddress(DiscoveryVersion discoveryVersion, XmlReader reader)
{
Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null");
Fx.Assert(reader != null, "The reader must be non null");
if (discoveryVersion == DiscoveryVersion.WSDiscoveryApril2005 || discoveryVersion == DiscoveryVersion.WSDiscoveryCD1)
{
EndpointAddressAugust2004 endpoint = discoveryVersion.Implementation.EprSerializer.ReadObject(reader) as EndpointAddressAugust2004;
if (endpoint == null)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlEndpointNull));
}
return endpoint.ToEndpointAddress();
}
else if (discoveryVersion == DiscoveryVersion.WSDiscovery11)
{
EndpointAddress10 endpoint = discoveryVersion.Implementation.EprSerializer.ReadObject(reader) as EndpointAddress10;
if (endpoint == null)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlEndpointNull));
}
return endpoint.ToEndpointAddress();
}
else
{
Fx.Assert("The discoveryVersion parameter cannot be null.");
return null;
}
}
public static void ReadContractTypeNames(Collection<XmlQualifiedName> contractTypeNames, XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.ReadStartElement();
string listOfQNamesAsStr = reader.ReadString();
if (!string.IsNullOrEmpty(listOfQNamesAsStr))
{
SerializationUtility.ParseQNameList(listOfQNamesAsStr, contractTypeNames, reader);
}
reader.ReadEndElement();
}
}
public static Uri ReadScopes(Collection<Uri> scopes, XmlReader reader)
{
Uri scopeMatchBy = null;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if ((reader.NamespaceURI.Length == 0) &&
(reader.Name.Equals(ProtocolStrings.SchemaNames.MatchByAttribute)))
{
string scopeMatchByStr = reader.Value;
try
{
scopeMatchBy = new Uri(scopeMatchByStr, UriKind.RelativeOrAbsolute);
}
catch (FormatException fe)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlUriFormatError(scopeMatchByStr), fe));
}
break;
}
}
reader.MoveToElement();
}
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.ReadStartElement();
string listOfUrisAsString = reader.ReadString();
if (!string.IsNullOrEmpty(listOfUrisAsString))
{
SerializationUtility.ParseUriList(listOfUrisAsString, scopes, UriKind.Absolute);
}
reader.ReadEndElement();
}
return scopeMatchBy;
}
public static void ReadListenUris(Collection<Uri> listenUris, XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.ReadStartElement();
string listOfUrisAsString = reader.ReadString();
if (!string.IsNullOrEmpty(listOfUrisAsString))
{
SerializationUtility.ParseUriList(listOfUrisAsString, listenUris, UriKind.RelativeOrAbsolute);
}
reader.ReadEndElement();
}
}
public static int ReadMetadataVersion(XmlReader reader)
{
reader.ReadStartElement();
int metadataVersion = reader.ReadContentAsInt();
if (metadataVersion < 0)
{
throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlMetadataVersionLessThanZero(metadataVersion)));
}
reader.ReadEndElement();
return metadataVersion;
}
public static void WriteEndPointAddress(DiscoveryVersion discoveryVersion, EndpointAddress endpointAddress, XmlWriter writer)
{
Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null");
Fx.Assert(writer != null, "The writer must be non null");
if (discoveryVersion == DiscoveryVersion.WSDiscoveryApril2005 || discoveryVersion == DiscoveryVersion.WSDiscoveryCD1)
{
EndpointAddressAugust2004 endpoint = EndpointAddressAugust2004.FromEndpointAddress(endpointAddress);
discoveryVersion.Implementation.EprSerializer.WriteObject(writer, endpoint);
}
else if (discoveryVersion == DiscoveryVersion.WSDiscovery11)
{
EndpointAddress10 endpoint = EndpointAddress10.FromEndpointAddress(endpointAddress);
discoveryVersion.Implementation.EprSerializer.WriteObject(writer, endpoint);
}
else
{
Fx.Assert("The discoveryVersion parameter cannot be null.");
}
}
public static void WriteContractTypeNames(DiscoveryVersion discoveryVersion, Collection<XmlQualifiedName> contractTypeNames, XmlWriter writer)
{
if ((contractTypeNames != null) && (contractTypeNames.Count > 0))
{
// using the prefix here allows us to redefine the empty namespace
// for serializing the QNames is required.
writer.WriteStartElement(
ProtocolStrings.SchemaNames.DefaultPrefix,
ProtocolStrings.SchemaNames.TypesElement,
discoveryVersion.Namespace);
SerializationUtility.WriteListOfQNames(writer, contractTypeNames);
writer.WriteEndElement();
}
}
public static void WriteScopes(DiscoveryVersion discoveryVersion, Collection<Uri> scopes, Uri scopeMatchBy, XmlWriter writer)
{
bool writeScopes = true;
if (scopes == null || scopes.Count == 0)
{
// If there are no scopes defined, we write the Scopes section only if matchBy contract is None.
writeScopes = (scopeMatchBy == FindCriteria.ScopeMatchByNone);
}
if (writeScopes)
{
writer.WriteStartElement(ProtocolStrings.SchemaNames.ScopesElement, discoveryVersion.Namespace);
if (scopeMatchBy != null)
{
Uri versionDependentScopeMatchBy = discoveryVersion.Implementation.ToVersionDependentScopeMatchBy(scopeMatchBy);
writer.WriteAttributeString(
ProtocolStrings.SchemaNames.MatchByAttribute,
string.Empty,
versionDependentScopeMatchBy.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped));
}
if (scopes != null)
{
SerializationUtility.WriteListOfUris(writer, scopes);
}
writer.WriteEndElement();
}
}
public static void WriteListenUris(DiscoveryVersion discoveryVersion, Collection<Uri> listenUris, XmlWriter writer)
{
if ((listenUris != null) && (listenUris.Count > 0))
{
writer.WriteStartElement(ProtocolStrings.SchemaNames.XAddrsElement, discoveryVersion.Namespace);
SerializationUtility.WriteListOfUris(writer, listenUris);
writer.WriteEndElement();
}
}
public static void WriteMetadataVersion(DiscoveryVersion discoveryVersion, int metadataVersion, XmlWriter writer)
{
writer.WriteStartElement(ProtocolStrings.SchemaNames.MetadataVersionElement, discoveryVersion.Namespace);
writer.WriteValue(metadataVersion);
writer.WriteEndElement();
}
}
}