private void WriteMember(XmlWriter writer, Object obj, MemberInfo mi,
IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
if (Attribute.IsDefined(mi, typeof(XmlRpcIgnoreAttribute)))
return;
Object value = null;
if (mi is PropertyInfo)
value = ((PropertyInfo)mi).GetValue(obj, null);
else if (mi is FieldInfo)
value = ((FieldInfo)mi).GetValue(obj);
MissingMemberAction action = config.MissingMemberAction;
// TODO check member attribute
XmlRpcMemberAttribute ma = (XmlRpcMemberAttribute)Attribute.GetCustomAttribute(mi, typeof(XmlRpcMemberAttribute));
String memberName = (ma != null && !String.IsNullOrEmpty(ma.Name)) ? ma.Name : mi.Name;
if (value == null)
{
if (action == MissingMemberAction.Ignore)
return;
else if (action == MissingMemberAction.Error)
throw new XmlRpcException("Missing non-optional member: " + memberName);
}
writer.WriteStartElement(XmlRpcSpec.MEMBER_TAG);
writer.WriteElementString(XmlRpcSpec.MEMBER_NAME_TAG, memberName);
WriteValue(writer, value, config, typeSerializerFactory, nestedObjs);
writer.WriteEndElement();
}
/// <summary>
///
/// </summary>
/// <exception cref="System.Xml.XmlException"></exception>
public static Object ReadValue(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeFactory)
{
CheckTag(reader, XmlRpcSpec.VALUE_TAG);
Object value = null;
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.IsEmptyElement)
continue;
ITypeSerializer parser = typeFactory.GetSerializer(config, reader.NamespaceURI, reader.LocalName);
if (parser == null)
throw new XmlException("Unknown type: " + new XmlQualifiedName(reader.LocalName, reader.NamespaceURI));
else
value = parser.Read(reader, config, typeFactory);
}
else if (reader.NodeType == XmlNodeType.Text)
{
ITypeSerializer parser = typeFactory.GetSerializer(config, reader.NamespaceURI, String.Empty);
if (parser != null)
value = parser.Read(reader, config, typeFactory);
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.VALUE_TAG.Equals(reader.LocalName));
return value;
}
/// <summary>
/// Deserializes an XML-RPC request from a request stream.
/// </summary>
/// <param name="requestStream">the <see cref="System.IO.Stream"/> to read</param>
/// <param name="config">the context configuration</param>
/// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
/// <returns>a <see cref="LX.EasyWeb.XmlRpc.IXmlRpcRequest"/> read from the reader</returns>
/// <exception cref="System.Xml.XmlException">failed parsing the request XML</exception>
public IXmlRpcRequest ReadRequest(Stream requestStream, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
using (XmlReader reader = new XmlTextReader(requestStream))
{
return ReadRequest(reader, config, typeSerializerFactory);
}
}
/// <summary>
/// Initializes new instance of type serializer.
/// </summary>
/// <param name="factory">Type serializer factory this instance was created by</param>
/// <param name="targetType">Target type handled by the actual instance.</param>
protected TypeSerializer(ITypeSerializerFactory factory, Type targetType)
{
RuntimeAssert.ArgumentNotNull(factory, nameof(factory));
RuntimeAssert.ArgumentNotNull(targetType, nameof(targetType));
Factory = factory;
TargetType = targetType;
}
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
writer.WriteStartElement(XmlRpcSpec.EXTENSIONS_PREFIX, XmlRpcSpec.NIL_TAG, XmlRpcSpec.EXTENSIONS_URI);
writer.WriteEndElement();
writer.WriteEndElement();
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultTypeSerializer" /> class.
/// </summary>
/// <param name="settings"></param>
/// <param name="factory"></param>
/// <param name="inspector"></param>
/// <param name="refManager"></param>
public DefaultTypeSerializer(Settings settings,
ITypeSerializerFactory factory,
ITypeInspector inspector,
IReferenceManager refManager)
: base(settings, factory, inspector, refManager)
{
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
String result = reader.ReadElementContentAsString();
if (String.IsNullOrEmpty(result))
return null;
else
throw new XmlRpcException("Unexpected characters in nil element.");
}
/// <summary>
/// Serializes an object and writes it to the supplied XmlWriter.
/// </summary>
/// <typeparam name="T">The Type being Serialized</typeparam>
/// <param name="writer">The XmlWriter to write to.</param>
/// <param name="obj">The object to serialize.</param>
public virtual void SerializeObject <T>(XmlWriter writer, T obj)
{
var mgr = Kernel.Get <IReferenceManager>();
var inspector = Kernel.Get <ITypeInspector>();
var info = inspector.GetInfo(typeof(T));
writer.WriteStartDocument();
writer.WriteStartElement(info.EntityName);
if (!string.IsNullOrEmpty(info.Namespace))
{
writer.WriteAttributeString("xmlns", info.Namespace);
}
// ReSharper disable once AssignNullToNotNullAttribute
writer.WriteAttributeString("xmlns", "dts", null, Resources.DotserializeUri);
// ReSharper disable once AssignNullToNotNullAttribute
writer.WriteAttributeString("xmlns", "xsi", null, Resources.XsiUri);
if (!string.IsNullOrEmpty(Settings.Culture.Name))
{
writer.WriteAttributeString(Resources.CultureName, Resources.DotserializeUri, Settings.Culture.Name);
}
try
{
// Attempt to fetch a custom type serializer
ITypeSerializerFactory factory = Kernel.Get <ITypeSerializerFactory>();
var typeSerializer = factory.GetTypeSerializer <T>();
if (typeSerializer != null)
{
typeSerializer.Serialize(writer, obj);
}
else
// Since there was no bound custom type serializer we default to the GenericTypeSerializer
{
var defaultSerializer = factory.GetDefaultSerializer();
defaultSerializer.Serialize(writer, obj);
}
}
catch (StackOverflowException ex)
{
if (Settings.DisableReferentialIntegrity)
{
throw new SerializerException("Non-ending recursive loop encountered during serialization.\n" +
"This is likely due to a circular reference in the object graph, try enabling the referential integrity setting.",
ex);
}
throw;
}
writer.WriteEndDocument();
Kernel.Release(mgr);
BindITypeSerializationFactory();
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeSerializerBase{T}"/> class.
/// </summary>
/// <param name="settings">
/// </param>
/// <param name="factory">
/// </param>
/// <param name="inspector">
/// </param>
/// <param name="refManager">
/// </param>
protected TypeSerializerBase(Settings settings,
ITypeSerializerFactory factory,
ITypeInspector inspector,
IReferenceManager refManager)
{
Factory = factory;
Inspector = inspector;
Settings = settings;
RefManager = refManager;
}
/// <summary>
/// Deserializes an object from a XmlReader and returns it as Type T.
/// </summary>
/// <typeparam name="T">The Type being deserialized</typeparam>
/// <param name="reader">The XmlReader to read from.</param>
/// <returns>Object of Type T.</returns>
/// <exception caption="" cref="SerializerException">
/// Thrown if the root node cannot be found or if there is more than one
/// root node.
/// </exception>
/// <example>
/// <code title="Deserializing a user object" description="" groupname="DeserializeFromFile" lang="C#">
/// var serializer = new Serializer();
/// var user = serializer.DeserializeObject<User>(reader);</code>
/// <code title="Deserializing a user object" description="" groupname="DeserializeFromFile" lang="VB">
/// Dim serializer = New Serializer()
/// Dim user = serializer.DeserializeObject(Of User)(reader)</code>
/// </example>
public virtual T DeserializeObject <T>(XmlReader reader)
{
var mgr = Kernel.Get <IReferenceManager>();
T result;
IReferenceManager manager = Kernel.Get <IReferenceManager>();
if (!ReadUntilElement(reader))
{
throw new SerializerException("Could not find root node");
}
var type = TypeHelper.GetReferenceType(reader);
if (type != null)
{
if (!typeof(T).IsAssignableFrom(type))
{
throw new SerializerException(string.Format("Serialized object in file is not of Type {0}", typeof(T).Name));
}
}
var id = TypeHelper.GetReferenceId(reader);
if (id != 0)
{
manager.RegisterId(id);
}
// Attempt to fetch a custom type serializer
ITypeSerializerFactory factory = Kernel.Get <ITypeSerializerFactory>();
var typeSerializer = factory.GetTypeSerializer <T>();
if (typeSerializer != null)
{
result = typeSerializer.Deserialize(reader);
}
else
// Since there was no bound custom type serializer we default to the GenericTypeSerializer
{
var defaultSerializer = factory.GetDefaultSerializer();
result = defaultSerializer.Deserialize <T>(reader);
}
// Now that we have our object constructed we update any refences that should point to it in our object graph
if (id != 0)
{
manager.UpdateObject(id, result);
}
Kernel.Release(mgr);
BindITypeSerializationFactory();
return(result);
}
/// <summary>
/// Serializes an XML-RPC response to a <see cref="System.Xml.XmlWriter"/>.
/// </summary>
/// <param name="writer">the <see cref="System.Xml.XmlWriter"/> to write</param>
/// <param name="response">the <see cref="LX.EasyWeb.XmlRpc.IXmlRpcResponse"/> to serialize</param>
/// <param name="config">the context configuration</param>
/// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
/// <exception cref="System.Xml.XmlException">failed writing the response XML</exception>
public void WriteResponse(XmlWriter writer, IXmlRpcResponse response, IXmlRpcStreamRequestConfig config, ITypeSerializerFactory typeSerializerFactory)
{
writer.WriteStartDocument();
writer.WriteStartElement(XmlRpcSpec.METHOD_RESPONSE_TAG);
if (response.Fault == null)
RecursiveTypeSerializer.WriteParams(writer, config, typeSerializerFactory, response.Result);
else
WriteFaultResponse(writer, response.Fault, config, typeSerializerFactory);
writer.WriteEndElement();
writer.WriteEndDocument();
}
public static void WriteValue(XmlWriter writer, Object value, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
if (nestedObjs.Contains(value))
return;
nestedObjs.Add(value);
ITypeSerializer serializer = typeSerializerFactory.GetSerializer(config, value);
if (serializer == null)
throw new XmlRpcException("Unsupported type: " + value.GetType().Name);
if (serializer is RecursiveTypeSerializer)
((RecursiveTypeSerializer)serializer).DoWrite(writer, value, config, typeSerializerFactory, nestedObjs);
else
serializer.Write(writer, value, config, typeSerializerFactory);
nestedObjs.RemoveAt(nestedObjs.Count - 1);
}
public static void WriteParams(XmlWriter writer, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, params Object[] parameters)
{
writer.WriteStartElement(XmlRpcSpec.PARAMS_TAG);
ArrayList nestedObjs = new ArrayList();
foreach (var item in parameters)
{
writer.WriteStartElement(XmlRpcSpec.PARAM_TAG);
WriteValue(writer, item, config, typeSerializerFactory, nestedObjs);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
writer.WriteStartElement(XmlRpcSpec.ARRAY_TAG);
writer.WriteStartElement(XmlRpcSpec.DATA_TAG);
foreach (var value in (IEnumerable)obj)
{
WriteValue(writer, value, config, typeSerializerFactory, nestedObjs);
}
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndElement();
}
public static IList ReadParams(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
if (reader.EOF)
return null;
CheckTag(reader, XmlRpcSpec.PARAMS_TAG);
IList args = new ArrayList();
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
args.Add(ReadParam(reader, config, typeSerializerFactory));
}
} while (!reader.EOF && (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.PARAMS_TAG.Equals(reader.LocalName)));
return args;
}
public static IList ReadParams(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
if (reader.EOF)
{
return(null);
}
CheckTag(reader, XmlRpcSpec.PARAMS_TAG);
IList args = new ArrayList();
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
args.Add(ReadParam(reader, config, typeSerializerFactory));
}
} while (!reader.EOF && (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.PARAMS_TAG.Equals(reader.LocalName)));
return(args);
}
private void WriteMember(XmlWriter writer, Object obj, MemberInfo mi,
IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
if (Attribute.IsDefined(mi, typeof(XmlRpcIgnoreAttribute)))
{
return;
}
Object value = null;
if (mi is PropertyInfo)
{
value = ((PropertyInfo)mi).GetValue(obj, null);
}
else if (mi is FieldInfo)
{
value = ((FieldInfo)mi).GetValue(obj);
}
MissingMemberAction action = config.MissingMemberAction;
// TODO check member attribute
XmlRpcMemberAttribute ma = (XmlRpcMemberAttribute)Attribute.GetCustomAttribute(mi, typeof(XmlRpcMemberAttribute));
String memberName = (ma != null && !String.IsNullOrEmpty(ma.Name)) ? ma.Name : mi.Name;
if (value == null)
{
if (action == MissingMemberAction.Ignore)
{
return;
}
else if (action == MissingMemberAction.Error)
{
throw new XmlRpcException("Missing non-optional member: " + memberName);
}
}
writer.WriteStartElement(XmlRpcSpec.MEMBER_TAG);
writer.WriteElementString(XmlRpcSpec.MEMBER_NAME_TAG, memberName);
WriteValue(writer, value, config, typeSerializerFactory, nestedObjs);
writer.WriteEndElement();
}
/// <summary>
/// Deserializes an XML-RPC request from a <see cref="System.Xml.XmlReader"/>.
/// </summary>
/// <param name="reader">the <see cref="System.Xml.XmlReader"/> to read</param>
/// <param name="config">the context configuration</param>
/// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
/// <returns>a <see cref="LX.EasyWeb.XmlRpc.IXmlRpcRequest"/> read from the reader</returns>
/// <exception cref="System.Xml.XmlException">failed parsing the request XML</exception>
public IXmlRpcRequest ReadRequest(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
String methodName = null;
IList args = null;
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
if (!String.IsNullOrEmpty(reader.NamespaceURI) || !XmlRpcSpec.METHOD_CALL_TAG.Equals(reader.LocalName))
throw new XmlException("Expected root element methodCall, got " + new XmlQualifiedName(reader.LocalName, reader.NamespaceURI));
RecursiveTypeSerializer.ReadToElement(reader);
methodName = ReadMethodName(reader);
RecursiveTypeSerializer.ReadToElement(reader);
args = RecursiveTypeSerializer.ReadParams(reader, config, typeSerializerFactory);
}
} while (!reader.EOF && (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.METHOD_CALL_TAG.Equals(reader.LocalName)));
return new XmlRpcRequest(methodName, args == null ? null : ToArray(args));
}
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
writer.WriteStartElement(XmlRpcSpec.STRUCT_TAG);
Type type = obj.GetType();
foreach (PropertyInfo pi in type.GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
WriteMember(writer, obj, pi, config, typeSerializerFactory, nestedObjs);
}
foreach (FieldInfo fi in type.GetFields(BindingFlags.Instance | BindingFlags.Public))
{
WriteMember(writer, obj, fi, config, typeSerializerFactory, nestedObjs);
}
writer.WriteEndElement();
writer.WriteEndElement();
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
List<Object> list = new List<Object>();
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
CheckTag(reader, XmlRpcSpec.DATA_TAG);
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
list.Add(ReadValue(reader, config, typeSerializerFactory));
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.DATA_TAG.Equals(reader.LocalName));
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.ARRAY_TAG.Equals(reader.LocalName));
return list.ToArray();
}
/// <summary>
///
/// </summary>
/// <exception cref="System.Xml.XmlException"></exception>
public static Object ReadValue(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeFactory)
{
CheckTag(reader, XmlRpcSpec.VALUE_TAG);
Object value = null;
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.IsEmptyElement)
{
continue;
}
ITypeSerializer parser = typeFactory.GetSerializer(config, reader.NamespaceURI, reader.LocalName);
if (parser == null)
{
throw new XmlException("Unknown type: " + new XmlQualifiedName(reader.LocalName, reader.NamespaceURI));
}
else
{
value = parser.Read(reader, config, typeFactory);
}
}
else if (reader.NodeType == XmlNodeType.Text)
{
ITypeSerializer parser = typeFactory.GetSerializer(config, reader.NamespaceURI, String.Empty);
if (parser != null)
{
value = parser.Read(reader, config, typeFactory);
}
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.VALUE_TAG.Equals(reader.LocalName));
return(value);
}
/// <summary>
/// Deserializes an XML-RPC response from a <see cref="System.Xml.XmlReader"/>.
/// </summary>
/// <param name="reader">the <see cref="System.Xml.XmlReader"/> to read</param>
/// <param name="config">the context configuration</param>
/// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
/// <returns>a <see cref="LX.EasyWeb.XmlRpc.IXmlRpcResponse"/> read from the reader</returns>
/// <exception cref="System.Xml.XmlException">failed parsing the response XML</exception>
public IXmlRpcResponse ReadResponse(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
IXmlRpcResponse response = null;
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
if (!String.IsNullOrEmpty(reader.NamespaceURI) || !XmlRpcSpec.METHOD_RESPONSE_TAG.Equals(reader.LocalName))
throw new XmlException("Expected root element methodResponse, got " + new XmlQualifiedName(reader.LocalName, reader.NamespaceURI));
RecursiveTypeSerializer.ReadToElement(reader);
if (String.IsNullOrEmpty(reader.NamespaceURI) && XmlRpcSpec.FAULT_TAG.Equals(reader.LocalName))
response = ReadFaultResponse(reader, config, typeSerializerFactory);
else if (String.IsNullOrEmpty(reader.NamespaceURI) && XmlRpcSpec.PARAMS_TAG.Equals(reader.LocalName))
response = ReadParamReponse(reader, config, typeSerializerFactory);
}
} while (!reader.EOF && (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.METHOD_RESPONSE_TAG.Equals(reader.LocalName)));
if (response == null)
throw new XmlRpcException("Invalid XML-RPC response.");
return response;
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
IDictionary<String, Object> dic = new Dictionary<String, Object>();
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
CheckTag(reader, XmlRpcSpec.MEMBER_TAG);
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
CheckTag(reader, XmlRpcSpec.MEMBER_NAME_TAG);
String name = reader.ReadElementContentAsString();
if (name == null)
throw new XmlException("Name is expected for struct members.");
while (reader.NodeType != XmlNodeType.Element && reader.Read())
;
if (dic.ContainsKey(name))
throw new XmlException("Duplicate struct member name: " + name);
Object value = ReadValue(reader, config, typeSerializerFactory);
dic.Add(name, value);
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.MEMBER_TAG.Equals(reader.LocalName));
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.STRUCT_TAG.Equals(reader.LocalName));
return dic;
}
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
writer.WriteStartElement(XmlRpcSpec.STRUCT_TAG);
foreach (DictionaryEntry entry in (IDictionary)obj)
{
writer.WriteStartElement(XmlRpcSpec.MEMBER_TAG);
writer.WriteStartElement(XmlRpcSpec.MEMBER_NAME_TAG);
if (config.EnabledForExtensions && !(entry.Key is String))
WriteValue(writer, entry.Key, config, typeSerializerFactory, nestedObjs);
else
writer.WriteString(entry.Key.ToString());
writer.WriteEndElement();
WriteValue(writer, entry.Value, config, typeSerializerFactory, nestedObjs);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
}
void ITypeSerializer.Write(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
WriteRequest(writer, (IXmlRpcRequest)obj, config, typeSerializerFactory);
}
private static Object ReadParam(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
CheckTag(reader, XmlRpcSpec.PARAM_TAG);
Object param = null;
Int32 count = 0;
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element && count++ == 0)
{
param = ReadValue(reader, config, typeSerializerFactory);
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.PARAM_TAG.Equals(reader.LocalName));
if (count == 0)
{
throw new XmlException("No value element in the param element.");
}
else if (count > 1)
{
throw new XmlException("More than one value element in the param element.");
}
return(param);
}
public ExplicitSerializer(IServiceProvider serviceProvider, IDataReaderFactory dataReaderFactory, IDataWriterFactory dataWriterFactory, ITypeSerializerFactory typeSerializerFactory)
: base(serviceProvider, typeSerializerFactory)
{
DataReaderFactory = dataReaderFactory;
DataWriterFactory = dataWriterFactory;
}
private static IXmlRpcResponse ReadParamReponse(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
IList list = RecursiveTypeSerializer.ReadParams(reader, config, typeSerializerFactory);
XmlRpcResponse response = new XmlRpcResponse(list.Count > 0 ? list[0] : null);
return response;
}
protected abstract void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory);
public void Write(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
DoWrite(writer, obj, config, typeSerializerFactory);
}
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
writer.WriteStartElement(XmlRpcSpec.STRUCT_TAG);
foreach (DictionaryEntry entry in (IDictionary)obj)
{
writer.WriteStartElement(XmlRpcSpec.MEMBER_TAG);
writer.WriteStartElement(XmlRpcSpec.MEMBER_NAME_TAG);
if (config.EnabledForExtensions && !(entry.Key is String))
{
WriteValue(writer, entry.Key, config, typeSerializerFactory, nestedObjs);
}
else
{
writer.WriteString(entry.Key.ToString());
}
writer.WriteEndElement();
WriteValue(writer, entry.Value, config, typeSerializerFactory, nestedObjs);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
}
protected abstract void DoWrite(XmlWriter writer, Object value, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs);
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
WriteString(writer, GetTag(config), GetString(obj));
writer.WriteEndElement();
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
return DoRead(reader);
}
public static void WriteParams(XmlWriter writer, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, params Object[] parameters)
{
writer.WriteStartElement(XmlRpcSpec.PARAMS_TAG);
ArrayList nestedObjs = new ArrayList();
foreach (var item in parameters)
{
writer.WriteStartElement(XmlRpcSpec.PARAM_TAG);
WriteValue(writer, item, config, typeSerializerFactory, nestedObjs);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
protected abstract void DoWrite(XmlWriter writer, Object value, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs);
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
#if DEBUG
throw new NotSupportedException("Call DoWrite(writer, value, config, typeSerializerFactory, nestedObjs) instead");
#else
WriteValue(writer, obj, config, typeSerializerFactory, new ArrayList());
#endif
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
List <Object> list = new List <Object>();
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
CheckTag(reader, XmlRpcSpec.DATA_TAG);
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
list.Add(ReadValue(reader, config, typeSerializerFactory));
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.DATA_TAG.Equals(reader.LocalName));
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.ARRAY_TAG.Equals(reader.LocalName));
return(list.ToArray());
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
IDictionary <String, Object> dic = new Dictionary <String, Object>();
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
CheckTag(reader, XmlRpcSpec.MEMBER_TAG);
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
CheckTag(reader, XmlRpcSpec.MEMBER_NAME_TAG);
String name = reader.ReadElementContentAsString();
if (name == null)
{
throw new XmlException("Name is expected for struct members.");
}
while (reader.NodeType != XmlNodeType.Element && reader.Read())
{
;
}
if (dic.ContainsKey(name))
{
throw new XmlException("Duplicate struct member name: " + name);
}
Object value = ReadValue(reader, config, typeSerializerFactory);
dic.Add(name, value);
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.MEMBER_TAG.Equals(reader.LocalName));
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.STRUCT_TAG.Equals(reader.LocalName));
return(dic);
}
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
writer.WriteStartElement(XmlRpcSpec.ARRAY_TAG);
writer.WriteStartElement(XmlRpcSpec.DATA_TAG);
foreach (var value in (IEnumerable)obj)
{
WriteValue(writer, value, config, typeSerializerFactory, nestedObjs);
}
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndElement();
}
public Object Read(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
return(DoRead(reader, config, typeSerializerFactory));
}
/// <summary>
/// Initializes a new instance of the <see cref="CollectionTypeSerializer"/> class.
/// </summary>
/// <param name="settings"></param>
/// <param name="factory"></param>
/// <param name="inspector"></param>
/// <param name="refManager"></param>
protected CollectionTypeSerializer(Settings settings, ITypeSerializerFactory factory, ITypeInspector inspector, IReferenceManager refManager)
: base(settings, factory, inspector, refManager)
{
}
protected abstract Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory);
/// <summary>
/// Initializes new instance of default serializer with specified parameters.
/// </summary>
/// <param name="dataReaderFactory">Data reader factory.</param>
/// <param name="dataWriterFactory">Data writer factory.</param>
/// <param name="serviceProvider">Service provider. If not specified empty service provider is used.</param>
/// <param name="typeSerializerFactory">Type serializer factory. If not specified new cached type serializer factory is used.</param>
/// <returns>Serializer.</returns>
public static Serializer Create(IDataReaderFactory dataReaderFactory, IDataWriterFactory dataWriterFactory, IServiceProvider serviceProvider = null, ITypeSerializerFactory typeSerializerFactory = null)
{
return(new ExplicitSerializer(serviceProvider ?? EmptyServiceProvider.SharedInstance, dataReaderFactory, dataWriterFactory, typeSerializerFactory ?? new CachedTypeSerializerFactory()));
}
private static IXmlRpcResponse ReadFaultResponse(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
IDictionary dict = null;
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
dict = (IDictionary)RecursiveTypeSerializer.ReadValue(reader, config, typeSerializerFactory);
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.FAULT_TAG.Equals(reader.LocalName));
if (dict != null)
{
if (!dict.Contains(XmlRpcSpec.FAULT_CODE_TAG))
throw new XmlRpcException("Invalid XML-RPC response: missing fault code");
if (!dict.Contains(XmlRpcSpec.FAULT_STRING_TAG))
throw new XmlRpcException("Invalid XML-RPC response: missing fault string");
try
{
XmlRpcFault fault = new XmlRpcFault((Int32)dict[XmlRpcSpec.FAULT_CODE_TAG], (String)dict[XmlRpcSpec.FAULT_STRING_TAG]);
XmlRpcResponse response = new XmlRpcResponse(null);
response.Fault = fault;
return response;
}
catch (Exception ex)
{
throw new XmlRpcException("Invalid XML-RPC response: " + ex.Message);
}
}
throw new XmlRpcException("Invalid XML-RPC response.");
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
return(DoRead(reader));
}
/// <summary> /// Clones current instance replacing type serializer factory. /// </summary> /// <param name="typeSerializerFactory">Type serializer factory to replace.</param> /// <returns>Cloned instance of serializer.</returns> public abstract Serializer Clone(ITypeSerializerFactory typeSerializerFactory);
/// <summary>
/// Serializes an XML-RPC request to a request stream.
/// </summary>
/// <param name="requestStream">the <see cref="System.IO.Stream"/> to write</param>
/// <param name="request">the <see cref="LX.EasyWeb.XmlRpc.IXmlRpcRequest"/> to serialize</param>
/// <param name="config">the context configuration</param>
/// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
/// <exception cref="System.Xml.XmlException">failed writing the request XML</exception>
public void WriteRequest(Stream requestStream, IXmlRpcRequest request, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
using (XmlWriter writer = _xmlWriterFactory.GetXmlWriter(config, requestStream))
{
WriteRequest(writer, request, config, typeSerializerFactory);
}
}
public override Serializer Clone(ITypeSerializerFactory typeSerializerFactory) => new ExplicitSerializer(ServiceProvider, DataReaderFactory, DataWriterFactory, typeSerializerFactory);
private static Object ReadParam(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
CheckTag(reader, XmlRpcSpec.PARAM_TAG);
Object param = null;
Int32 count = 0;
do
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element && count++ == 0)
{
param = ReadValue(reader, config, typeSerializerFactory);
}
} while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.PARAM_TAG.Equals(reader.LocalName));
if (count == 0)
throw new XmlException("No value element in the param element.");
else if (count > 1)
throw new XmlException("More than one value element in the param element.");
return param;
}
/// <summary>
/// Initializes new instance of <see cref="T:NCoreUtils.Serialization.Serializer" /> with the specified
/// parameters.
/// </summary>
/// <param name="serviceProvider">Service provider.</param>
/// <param name="typeSerializerFactory">Type serializer factory.</param>
protected Serializer(IServiceProvider serviceProvider, ITypeSerializerFactory typeSerializerFactory)
{
ServiceProvider = serviceProvider;
TypeSerializerFactory = typeSerializerFactory;
}
/// <summary>
/// Serializes an XML-RPC response to a response stream.
/// </summary>
/// <param name="responseStream">the <see cref="System.IO.Stream"/> to write</param>
/// <param name="response">the <see cref="LX.EasyWeb.XmlRpc.IXmlRpcResponse"/> to serialize</param>
/// <param name="config">the context configuration</param>
/// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
/// <exception cref="System.Xml.XmlException">failed writing the response XML</exception>
public void WriteResponse(Stream responseStream, IXmlRpcResponse response, IXmlRpcStreamRequestConfig config, ITypeSerializerFactory typeSerializerFactory)
{
XmlWriter writer = _xmlWriterFactory.GetXmlWriter(config, responseStream);
WriteResponse(writer, response, config, typeSerializerFactory);
writer.Flush();
}
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
WriteString(writer, GetTag(config), GetString(obj));
writer.WriteEndElement();
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
throw new InvalidOperationException("Cannot deserialize objects directly, using StructSerializer instead.");
}
Object ITypeSerializer.Read(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
return ReadRequest(reader, config, typeSerializerFactory);
}
private static void WriteFaultResponse(XmlWriter writer, IXmlRpcFault fault, IXmlRpcStreamRequestConfig config, ITypeSerializerFactory typeSerializerFactory)
{
writer.WriteStartElement(XmlRpcSpec.FAULT_TAG);
ArrayList nestvedObjs = new ArrayList();
if (config != null && config.EnabledForExceptions)
{
Hashtable ht = new Hashtable(3);
XmlRpcFault xpf = fault as XmlRpcFault;
ht.Add(XmlRpcSpec.FAULT_CODE_TAG, fault.FaultCode);
ht.Add(XmlRpcSpec.FAULT_STRING_TAG, fault.FaultString);
ht.Add("faultCause", fault is XmlRpcFault ? ((XmlRpcFault)fault).Exception : null);
RecursiveTypeSerializer.WriteValue(writer, ht, config, typeSerializerFactory, nestvedObjs);
}
else
{
RecursiveTypeSerializer.WriteValue(writer, fault, config, typeSerializerFactory, nestvedObjs);
}
writer.WriteEndElement();
}
protected override void DoWrite(XmlWriter writer, Object obj, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
writer.WriteStartElement(XmlRpcSpec.VALUE_TAG);
writer.WriteStartElement(XmlRpcSpec.EXTENSIONS_PREFIX, XmlRpcSpec.NIL_TAG, XmlRpcSpec.EXTENSIONS_URI);
writer.WriteEndElement();
writer.WriteEndElement();
}
public static void WriteValue(XmlWriter writer, Object value, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory, IList nestedObjs)
{
if (nestedObjs.Contains(value))
{
return;
}
nestedObjs.Add(value);
ITypeSerializer serializer = typeSerializerFactory.GetSerializer(config, value);
if (serializer == null)
{
throw new XmlRpcException("Unsupported type: " + value.GetType().Name);
}
if (serializer is RecursiveTypeSerializer)
{
((RecursiveTypeSerializer)serializer).DoWrite(writer, value, config, typeSerializerFactory, nestedObjs);
}
else
{
serializer.Write(writer, value, config, typeSerializerFactory);
}
nestedObjs.RemoveAt(nestedObjs.Count - 1);
}
/// <summary>
/// Serializes an XML-RPC request to a <see cref="System.Xml.XmlWriter"/>.
/// </summary>
/// <param name="writer">the <see cref="System.Xml.XmlWriter"/> to write</param>
/// <param name="request">the <see cref="LX.EasyWeb.XmlRpc.IXmlRpcRequest"/> to serialize</param>
/// <param name="config">the context configuration</param>
/// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
/// <exception cref="System.Xml.XmlException">failed writing the request XML</exception>
public void WriteRequest(XmlWriter writer, IXmlRpcRequest request, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
writer.WriteStartDocument();
writer.WriteStartElement(XmlRpcSpec.METHOD_CALL_TAG);
writer.WriteElementString(XmlRpcSpec.METHOD_NAME_TAG, request.MethodName);
RecursiveTypeSerializer.WriteParams(writer, config, typeSerializerFactory, request.Parameters);
writer.WriteEndElement();
writer.WriteEndDocument();
}
protected override Object DoRead(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
{
String result = reader.ReadElementContentAsString();
if (String.IsNullOrEmpty(result))
{
return(null);
}
else
{
throw new XmlRpcException("Unexpected characters in nil element.");
}
}
