public object DeserializeFromXml(Type type, string xml)
{
using (var sr = new StringReader(xml))
using (var xmlReader = XmlReader.Create(sr))
using (var xmlDict = XmlDictionaryReader.CreateDictionaryReader(xmlReader))
{
var serializer = new DataContractSerializer(type);
return(serializer.ReadObject(xmlDict, false, _resolver));
}
}
public XmlDictionaryReader GetReaderAtContent()
{
XmlReader r = extension.GetReader();
if (!(r is XmlDictionaryReader))
{
r = XmlDictionaryReader.CreateDictionaryReader(r);
}
return((XmlDictionaryReader)r);
}
public void ReadFrom4Error2()
{
string xml = @"<a:ReplyTo xmlns:a='http://www.w3.org/2005/08/addressing'><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo>";
XmlReader src = XmlReader.Create(new StringReader(xml));
XmlDictionaryReader reader =
XmlDictionaryReader.CreateDictionaryReader(src);
// null localName and ns
EndpointAddress.ReadFrom(AddressingVersion.WSAddressing10, reader, (XmlDictionaryString)null, null);
}
public void ReadFrom2Error()
{
string xml = @"<a:ReplyTo xmlns:a='http://www.w3.org/2005/08/addressing'><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo>";
XmlReader src = XmlReader.Create(new StringReader(xml));
XmlDictionaryReader reader =
XmlDictionaryReader.CreateDictionaryReader(src);
//Reading address with e10 address!
EndpointAddress.ReadFrom(AddressingVersion.WSAddressingAugust2004, reader);
}
public static XmlTokenStream CreateXmlTokenStream(string xml)
{
var xmlTokenStreamReader = new XmlTokenStreamReader(XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(xml))));
while (xmlTokenStreamReader.Read())
{
;
}
return(xmlTokenStreamReader.TokenStream);
}
protected override SecurityToken ReadTokenCore(XmlReader reader, SecurityTokenResolver tokenResolver)
{
XmlDictionaryReader dictionaryReader = XmlDictionaryReader.CreateDictionaryReader(reader);
if (this.secureConversation.IsAtDerivedKeyToken(dictionaryReader))
{
string id;
string derivationAlgorithm;
string label;
int length;
byte[] nonce;
int offset;
int generation;
SecurityKeyIdentifierClause tokenToDeriveIdentifier;
SecurityToken tokenToDerive;
this.secureConversation.ReadDerivedKeyTokenParameters(dictionaryReader, tokenResolver, out id, out derivationAlgorithm, out label,
out length, out nonce, out offset, out generation, out tokenToDeriveIdentifier, out tokenToDerive);
DerivedKeySecurityToken cachedToken = GetCachedToken(id, generation, offset, length, label, nonce, tokenToDerive, tokenToDeriveIdentifier, derivationAlgorithm);
if (cachedToken != null)
{
return(cachedToken);
}
lock (this.thisLock)
{
cachedToken = GetCachedToken(id, generation, offset, length, label, nonce, tokenToDerive, tokenToDeriveIdentifier, derivationAlgorithm);
if (cachedToken != null)
{
return(cachedToken);
}
SecurityToken result = this.secureConversation.CreateDerivedKeyToken(id, derivationAlgorithm, label, length, nonce, offset, generation, tokenToDeriveIdentifier, tokenToDerive);
DerivedKeySecurityToken newToken = result as DerivedKeySecurityToken;
if (newToken != null)
{
int pos = this.indexToCache;
if (this.indexToCache == int.MaxValue)
{
this.indexToCache = 0;
}
else
{
this.indexToCache = (++this.indexToCache) % this.cachedTokens.Length;
}
this.cachedTokens[pos] = new DerivedKeySecurityTokenCache(newToken);
}
return(result);
}
}
else
{
return(this.innerTokenSerializer.ReadToken(reader, tokenResolver));
}
}
public static T DeserializeDataContractXml <T>(string contents, Type[] types = null)
{
T result;
using (var reader = XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(contents))))
{
var serializer = new DataContractSerializer(typeof(T));
result = (T)serializer.ReadObject(reader);
}
return(result);
}
SecurityToken ReadXmlToken(string tokenXml)
{
using (StringReader strReader = new StringReader(tokenXml))
{
using (XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(strReader)))
{
reader.MoveToContent();
return(_handlers.ReadToken(reader));
}
}
}
protected override void OnWriteHeaderAttributes(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
#if NETStandard13
throw ExceptionHelper.PlatformNotSupported();
#else
base.WriteHeaderAttributes(writer, messageVersion);
XmlDictionaryReader nodeReader = XmlDictionaryReader.CreateDictionaryReader(new XmlNodeReader(headerValue));
nodeReader.MoveToContent();
writer.WriteAttributes(nodeReader, false);
#endif
}
public void ReadFrom3()
{
string xml = @"<a:ReplyTo xmlns:a='http://schemas.xmlsoap.org/ws/2004/08/addressing'><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo>";
XmlReader src = XmlReader.Create(new StringReader(xml));
XmlDictionaryReader reader =
XmlDictionaryReader.CreateDictionaryReader(src);
EndpointAddress a = EndpointAddress.ReadFrom(AddressingVersion.WSAddressingAugust2004, reader);
Assert.AreEqual("http://www.w3.org/2005/08/addressing/anonymous", a.Uri.AbsoluteUri, "#1");
Assert.IsFalse(a.IsAnonymous, "#2");
}
private Message CreateMessageFromXml(string newXml, MessageVersion messageVersion)
{
var textReader = new StringReader(newXml);
var xmlReader = XmlReader.Create(textReader, new XmlReaderSettings()
{
IgnoreWhitespace = false
});
var dictReader = XmlDictionaryReader.CreateDictionaryReader(xmlReader);
return(Message.CreateMessage(dictReader, int.MaxValue, messageVersion));
}
public void IsSafeWithDtdProcessing()
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Parse;
XmlReader reader = XmlReader.Create(new MemoryStream(Encoding.ASCII.GetBytes(Util.XmlWithPayload)), settings, Util.ResourceFolderPath);
XmlDictionaryReader target = XmlDictionaryReader.CreateDictionaryReader(reader);
string stringifiedTarget = ToString(target);
Assert.That(stringifiedTarget, Does.Not.Contain(Util.Payload));
}
public XmlDictionaryReader GetReaderAtExtensions()
{
if (extension == null)
{
return(null);
}
var r = XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(extension)));
r.MoveToContent();
return(r);
}
public XmlDictionaryReader GetReaderAtMetadata()
{
if (metadata == null)
{
return(null);
}
var r = XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(metadata)));
r.MoveToContent();
return(r);
}
public void ReadFrom2()
{
string xml = @"<a:ReplyTo xmlns:a='http://www.w3.org/2005/08/addressing'><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo>";
XmlReader src = XmlReader.Create(new StringReader(xml));
XmlDictionaryReader reader =
XmlDictionaryReader.CreateDictionaryReader(src);
EndpointAddress a = EndpointAddress.ReadFrom(AddressingVersion.WSAddressing10, reader);
Assert.IsNotNull(a, "#1");
Assert.AreEqual("http://schemas.microsoft.com/2005/12/ServiceModel/Addressing/Anonymous", a.Uri.AbsoluteUri, "#2");
Assert.IsTrue(a.IsAnonymous, "#3");
}
public void ReadFromE10Error2()
{
//Missing <Address> element
string xml = @"<a:ReplyTo xmlns:a='http://www.w3.org/2005/08/addressing'>http://www.w3.org/2005/08/addressing/anonymous</a:ReplyTo>";
XmlReader src = XmlReader.Create(new StringReader(xml));
XmlDictionaryReader reader =
XmlDictionaryReader.CreateDictionaryReader(src);
EndpointAddress10 e10 = EndpointAddress10.FromEndpointAddress(new EndpointAddress(("http://test")));
((IXmlSerializable)e10).ReadXml(reader);
}
private static T DeserializeDataContractXml <T>(Stream stream)
{
T instance;
using (var reader = XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(stream)))
{
var deserializer = new DataContractSerializer(typeof(T));
instance = (T)deserializer.ReadObject(reader);
}
return(instance);
}
public void ReadFromE10Error()
{
//Address is from August2004 namespace, but reading it with EndpointAddress10
string xml = @"<a:ReplyTo xmlns:a='http://schemas.xmlsoap.org/ws/2004/08/addressing'><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo>";
XmlReader src = XmlReader.Create(new StringReader(xml));
XmlDictionaryReader reader =
XmlDictionaryReader.CreateDictionaryReader(src);
EndpointAddress10 e10 = EndpointAddress10.FromEndpointAddress(new EndpointAddress(("http://test")));
((IXmlSerializable)e10).ReadXml(reader);
}
public virtual XmlDictionaryReader GetAddressHeaderReader()
{
var sw = new StringWriter();
var s = new XmlWriterSettings()
{
OmitXmlDeclaration = true
};
var xw = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sw, s));
WriteAddressHeader(xw);
xw.Close();
return(XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(sw.ToString()))));
}
protected virtual XmlDictionaryReader OnGetReaderAtDetailContents()
{
MemoryStream ms = new MemoryStream();
using (XmlDictionaryWriter dw =
XmlDictionaryWriter.CreateDictionaryWriter(
XmlWriter.Create(ms))) {
OnWriteDetailContents(dw);
}
ms.Seek(0, SeekOrigin.Begin);
return(XmlDictionaryReader.CreateDictionaryReader(
XmlReader.Create(ms)));
}
public static object Read_from_xml(Type T, string filename)
{
object obj = Activator.CreateInstance(T);
var path = filename;
XmlTextReader xr = new XmlTextReader(path);
XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(xr);
DataContractSerializer ser = new DataContractSerializer(T);
obj = ser.ReadObject(reader);
reader.Close();
xr.Close();
return(obj);
}
public SerializableProject Load(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException();
}
using (var xmlReader = XmlReader.Create(stream))
using (var reader = XmlDictionaryReader.CreateDictionaryReader(xmlReader))
{
var serializer = new DataContractSerializer(typeof(SerializableProject));
return((SerializableProject)serializer.ReadObject(reader));
}
}
public override Message ReadMessage(ArraySegment <byte> buffer,
BufferManager bufferManager, string contentType)
{
return(Message.CreateMessage(
XmlDictionaryReader.CreateDictionaryReader(
XmlReader.Create(new StreamReader(
new MemoryStream(
buffer.Array, buffer.Offset,
buffer.Count), encoding))),
// FIXME: supply max header size
int.MaxValue,
version));
}
internal override byte[] ReadContentAsBase64()
{
if (base.isEndOfEmptyElement)
{
return(new byte[0]);
}
if (base.dictionaryReader == null)
{
XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(base.reader);
return(ByteArrayHelperWithString.Instance.ReadArray(reader, "item", string.Empty, reader.Quotas.MaxArrayLength));
}
return(ByteArrayHelperWithString.Instance.ReadArray(base.dictionaryReader, "item", string.Empty, base.dictionaryReader.Quotas.MaxArrayLength));
}
public override void LoadCustomConfiguration(System.Xml.XmlNodeList nodelist)
{
foreach (XmlNode node in nodelist)
{
XmlDictionaryReader rdr = XmlDictionaryReader.CreateDictionaryReader(new XmlTextReader(new StringReader(node.OuterXml)));
rdr.MoveToContent();
string symmetricKey = rdr.GetAttribute("symmetricKey");
string audience = rdr.GetAttribute("audience");
this.AddAudienceKeyPair(audience, symmetricKey);
}
}
public static Skeleton Read_from_xml(string filename)
{
Skeleton sk = new Skeleton();
var path = filename;
XmlTextReader xr = new XmlTextReader(path);
XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(xr);
DataContractSerializer ser = new DataContractSerializer(typeof(Skeleton));
sk = (Skeleton)ser.ReadObject(reader);
reader.Close();
xr.Close();
return(sk);
}
public override Message ReadMessage(Stream stream,
int maxSizeOfHeaders, string contentType)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
return(Message.CreateMessage(
XmlDictionaryReader.CreateDictionaryReader(
XmlReader.Create(new StreamReader(stream, encoding))),
maxSizeOfHeaders,
version));
}
public void ReadFromAugust2004Error()
{
//Reading address from EndpointAddress10 namespace with EndpointAddressAugust2004
string xml = @"<a:ReplyTo xmlns:a='http://www.w3.org/2005/08/addressing'><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo>";
XmlReader src = XmlReader.Create(new StringReader(xml));
XmlDictionaryReader reader =
XmlDictionaryReader.CreateDictionaryReader(src);
EndpointAddressAugust2004 e2k4 = EndpointAddressAugust2004.FromEndpointAddress(new EndpointAddress("http://test"));
((IXmlSerializable)e2k4).ReadXml(reader);
}
public void ReadFromAugust2004Error2()
{
//Missing <Address> element
string xml = @"<a:ReplyTo xmlns:a='http://schemas.xmlsoap.org/ws/2004/08/addressing'>http://www.w3.org/2005/08/addressing/anonymous</a:ReplyTo>";
XmlReader src = XmlReader.Create(new StringReader(xml));
XmlDictionaryReader reader =
XmlDictionaryReader.CreateDictionaryReader(src);
EndpointAddressAugust2004 e2k4 = EndpointAddressAugust2004.FromEndpointAddress(new EndpointAddress("http://test"));
((IXmlSerializable)e2k4).ReadXml(reader);
}
public static XmlReader CreateXmlReader(ReaderWriterType rwType, byte[] buffer, Encoding encoding, XmlDictionaryReaderQuotas quotas, IXmlDictionary dictionary, OnXmlDictionaryReaderClose onClose)
{
XmlReader result = null;
switch (rwType)
{
case ReaderWriterType.Binary:
result = XmlDictionaryReader.CreateBinaryReader(buffer, 0, buffer.Length, dictionary, quotas, null, onClose);
break;
case ReaderWriterType.Text:
result = XmlDictionaryReader.CreateTextReader(buffer, 0, buffer.Length, encoding, quotas, onClose);
break;
case ReaderWriterType.WebData:
if (quotas != XmlDictionaryReaderQuotas.Max)
{
throw new InvalidOperationException("Cannot enforce quotas on the Webdata readers!");
}
if (onClose != null)
{
throw new InvalidOperationException("Webdata readers do not support the OnClose callback!");
}
XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.Default, encoding);
result = XmlReader.Create(new MemoryStream(buffer), new XmlReaderSettings(), context);
break;
case ReaderWriterType.WrappedWebData:
if (quotas != XmlDictionaryReaderQuotas.Max)
{
throw new InvalidOperationException("There is no overload to create the webdata readers with quotas!");
}
if (onClose != null)
{
throw new InvalidOperationException("Webdata readers do not support the OnClose callback!");
}
XmlParserContext context2 = new XmlParserContext(null, null, null, XmlSpace.Default, encoding);
result = XmlReader.Create(new MemoryStream(buffer), new XmlReaderSettings(), context2);
result = XmlDictionaryReader.CreateDictionaryReader(result);
break;
default:
throw new ArgumentOutOfRangeException(nameof(rwType));
}
return(result);
}
