public virtual T Deserialize <T>(IRestResponse response)
{
if (string.IsNullOrEmpty(response.Content))
{
return(default(T));
}
var doc = XDocument.Parse(response.Content);
var root = doc.Root;
if (RootElement.HasValue() && doc.Root != null)
{
root = doc.Root.Element(RootElement.AsNamespaced(Namespace));
}
// autodetect xml namespace
if (!Namespace.HasValue())
{
RemoveNamespace(doc);
}
var x = Activator.CreateInstance <T>();
var objType = x.GetType();
if (objType.IsSubclassOfRawGeneric(typeof(List <>)))
{
x = (T)HandleListDerivative(x, root, objType.Name, objType);
}
else
{
Map(x, root);
}
return(x);
}
/// <summary>
/// Serialize the object as XML
/// </summary>
/// <param name="obj">Object to serialize</param>
/// <returns>XML as string</returns>
public string Serialize(object obj)
{
var doc = new XDocument();
var t = obj.GetType();
var name = t.Name;
var options = t.GetAttribute <SerializeAsAttribute>();
if (options != null)
{
name = options.TransformName(options.Name ?? name);
}
var root = new XElement(name.AsNamespaced(Namespace));
Map(root, obj);
if (RootElement.HasValue())
{
var wrapper = new XElement(RootElement.AsNamespaced(Namespace), root);
doc.Add(wrapper);
}
else
{
doc.Add(root);
}
return(doc.ToString());
}
public T Deserialize <T>(RestResponse response) where T : new()
{
if (response.Content == null)
{
return(default(T));
}
var doc = XDocument.Parse(response.Content);
var root = doc.Root;
if (RootElement.HasValue() && doc.Root != null)
{
root = doc.Root.Element(RootElement.AsNamespaced(Namespace));
}
// autodetect xml namespace
if (!Namespace.HasValue())
{
RemoveNamespace(doc);
}
var x = new T();
var objType = x.GetType();
if (objType.IsSubclassOfRawGeneric(typeof(List <>)))
{
x = (T)HandleListDerivative(x, root, objType.Name, objType);
}
else
{
Map(x, root);
}
return(x);
}
/// <summary>
///
/// </summary>
/// <param name="strDoc"></param>
/// <param name="type"></param>
/// <returns></returns>
public object Deserialize(string strDoc, Type type)
{
if (string.IsNullOrEmpty(strDoc))
{
throw new ArgumentNullException("strDoc");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
if (type.IsAbstract || type.IsInterface)
{
throw new ArgumentException(
string.Format(Mini_Resources.TypeAbstract,
type.FullName,
type.FullName));
}
var doc = XDocument.Parse(strDoc);
var root = doc.Root;
if (RootElement.HasValue() && doc.Root != null)
{
root = doc.Root.Element(RootElement.AsNamespaced(Namespace));
}
if (!Namespace.HasValue())
{
RemoveNamespace(doc);
}
return(Read(type, root));
}
public T Deserialize <T>(string content)
{
if (string.IsNullOrEmpty(content))
{
return(default(T));
}
var doc = XDocument.Parse(content);
var root = doc.Root;
if (!string.IsNullOrEmpty(RootElement) && doc.Root != null)
{
root = doc.Root.DescendantsAndSelf(RootElement.AsNamespaced(Namespace)).SingleOrDefault();
}
if (!string.IsNullOrEmpty(Namespace))
{
doc.RemoveNamespace();
}
var result = Activator.CreateInstance <T>();
var resultType = result.GetType();
if (resultType.IsSubclassOfRawGeneric(typeof(List <>)))
{
result = (T)HandleListDerivative(root, resultType);
}
return(result);
}
/// <summary>
/// Serialize the object as XML
/// </summary>
/// <param name="obj">Object to serialize</param>
/// <returns>XML as string</returns>
public string Serialize(object obj)
{
var doc = new XDocument();
var t = obj.GetType();
var name = t.Name;
var options = t.GetAttribute <SerializeAsAttribute>();
if (options != null)
{
name = options.TransformName(options.Name ?? name);
}
var root = new XElement(name.AsNamespaced(Namespace));
if (obj is IList)
{
var itemTypeName = "";
foreach (var item in (IList)obj)
{
var type = item.GetType();
var ignore = type.GetAttribute <XmlIgnoreAttribute>();
if (ignore != null)
{
continue;
}
var opts = type.GetAttribute <SerializeAsAttribute>();
if (opts != null)
{
itemTypeName = opts.TransformName(opts.Name ?? name);
}
if (itemTypeName == "")
{
itemTypeName = type.Name;
}
var instance = new XElement(itemTypeName);
Map(instance, item);
root.Add(instance);
}
}
else
{
Map(root, obj);
}
if (RootElement.HasValue())
{
var wrapper = new XElement(RootElement.AsNamespaced(Namespace), root);
doc.Add(wrapper);
}
else
{
doc.Add(root);
}
return(doc.ToString());
}
public string Serialize(object obj)
{
XDocument xDocument = new XDocument();
Type type = obj.GetType();
string text = type.Name;
SerializeAsAttribute attribute = type.GetAttribute <SerializeAsAttribute>();
if (attribute != null)
{
text = attribute.TransformName(attribute.Name ?? text);
}
XElement xElement = new XElement(text.AsNamespaced(Namespace));
if (obj is IList)
{
string text2 = "";
foreach (object item in (IList)obj)
{
Type type2 = item.GetType();
SerializeAsAttribute attribute2 = type2.GetAttribute <SerializeAsAttribute>();
if (attribute2 != null)
{
text2 = attribute2.TransformName(attribute2.Name ?? text);
}
if (text2 == "")
{
text2 = type2.Name;
}
XElement xElement2 = new XElement(text2.AsNamespaced(Namespace));
Map(xElement2, item);
xElement.Add(xElement2);
}
}
else
{
Map(xElement, obj);
}
if (RootElement.HasValue())
{
XElement content = new XElement(RootElement.AsNamespaced(Namespace), xElement);
xDocument.Add(content);
}
else
{
xDocument.Add(xElement);
}
return(xDocument.ToString());
}
public virtual T Deserialize <T>(IRestResponse response)
{
if (!string.IsNullOrEmpty(response.Content))
{
XDocument xDocument = XDocument.Parse(response.Content);
XElement root = xDocument.Root;
if (RootElement.HasValue() && xDocument.Root != null)
{
root = xDocument.Root.Element(RootElement.AsNamespaced(Namespace));
}
if (!Namespace.HasValue())
{
RemoveNamespace(xDocument);
}
T val = Activator.CreateInstance <T>();
Type type = val.GetType();
val = ((!type.IsSubclassOfRawGeneric(typeof(List <>))) ? ((T)Map(val, root)) : ((T)HandleListDerivative(val, root, type.Name, type)));
return(val);
}
return(default(T));
}
/// <summary>
///
/// </summary>
/// <param name="instance"></param>
/// <returns></returns>
public string Serialize(object instance)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
var writer = new XmlWriter {
Owner = this
};
var type = instance.GetType();
var doc = new XDocument();
XElement root = null;
if (Types.ByteArray == type)
{
root = writer.WriteByteArray(instance as byte[]);
}
else if (type.IsCollectionTypeExcludeStringAndDictionaryType())
{
root = writer.WriteList(instance as IEnumerable);
}
else //TODO:字典，泛型对象需要检查
{
var name = type.Name;
root = new XElement(name.AsNamespaced(Namespace));
writer.Write(root, instance);
}
if (RootElement.HasValue())
{
doc.Add(new XElement(RootElement.AsNamespaced(Namespace), root));
}
else
{
doc.Add(root);
}
return(doc.ToString());
}
public virtual T Deserialize <T>(IRestResponse response)
{
if (string.IsNullOrEmpty(response.Content))
{
return(default(T));
}
XDocument doc = XDocument.Parse(response.Content);
XElement root = doc.Root;
if (this.RootElement.HasValue() && doc.Root != null)
{
//root = doc.Root.DescendantsAndSelf(this.RootElement.AsNamespaced(this.Namespace)).SingleOrDefault();
root = doc.Root.Element(RootElement.AsNamespaced(Namespace));
}
// autodetect xml namespace
if (!this.Namespace.HasValue())
{
RemoveNamespace(doc);
}
T x = Activator.CreateInstance <T>();
Type objType = x.GetType();
if (objType.IsSubclassOfRawGeneric(typeof(List <>)))
{
x = (T)this.HandleListDerivative(root, objType.Name, objType);
}
else
{
x = (T)this.Map(x, root);
}
return(x);
}
