protected override void PopulateElementValue(
XElement element, Type declareType, object obj, XConvertSettings settings)
{
element.Value = obj != null
? XConvertUtil.TypeNameOf((Type)obj, settings.AssemblyNameStyle)
: null;
}
protected override void PopulateElementChildren(
XElement element, Type declareType, object obj, XConvertSettings settings)
{
if (obj == null)
{
return;
}
var collectionProxy = CreateCollectionProxy(obj);
var itemDeclareType = collectionProxy.ItemType;
foreach (var item in collectionProxy)
{
var itemActualType = item != null?item.GetType() : null;
var usingItemType = itemActualType ?? itemDeclareType;
var itemElement = XConvert.ToElement(ItemName, item, settings);
if (itemDeclareType != usingItemType)
{
itemElement.Add(XConvertUtil.CreateTypeAttribute(usingItemType, settings.AssemblyNameStyle));
}
element.Add(itemElement);
}
}
/// <summary>
/// Assume specified xml element represents an object, convert the xml element to the object instance.
/// </summary>
/// <param name="element">The xml element that contains the contents of the object.</param>
/// <param name="settings">
/// Convert settings used during the convert. <see cref="XConvertSettings.Default" /> is used if the value is
/// <see langword="null" />.
/// </param>
/// <returns>Object that converted from <paramref name="element" />.</returns>
public object ToObject(XElement element, XConvertSettings settings)
{
Ensure.Argument.NotNull(element, "element");
var objType = XConvertUtil.ParseType(element);
Ensure.Argument.NotNull(objType, "element", "Object type not found.");
return(ToObject(objType, element, settings));
}
public static void PopulateObject(object obj, XElement element, XConvertSettings settings = null)
{
Ensure.Argument.NotNull(obj, "obj");
Ensure.Argument.NotNull(element, "element");
settings = settings ?? XConvertSettings.Default;
var converter = settings.FindConverter(obj.GetType());
converter.PopulateObject(obj, element, settings);
}
/// <summary>
/// Convert xml element to its representing object.
/// </summary>
/// <param name="objType">Type of the result object.</param>
/// <param name="element">The xml elemnt to convert.</param>
/// <param name="settings">
/// Convert settings used during the convertion. <see cref="XConvertSettings.Default" /> will be used if the value is
/// <see langword="null" />.
/// </param>
/// <returns>Object that converted from <paramref name="element" />.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="objType" /> or <paramref name="element" /> is <see langword="null" />.
/// </exception>
public static object ToObject(Type objType, XElement element, XConvertSettings settings = null)
{
Ensure.Argument.NotNull(objType, "objType");
Ensure.Argument.NotNull(element, "element");
settings = settings ?? XConvertSettings.Default;
var converter = settings.FindConverter(objType);
return(converter.ToObject(objType, element, settings));
}
/// <summary>
/// Convert an object to xml element.
/// </summary>
/// <param name="name">Name of the element.</param>
/// <param name="obj">The object to convert.</param>
/// <param name="settings">
/// Convert settings used during the convertion. <see cref="XConvertSettings.Default" /> will be used if the value is
/// <see langword="null" />.
/// </param>
/// <returns>An instance of <see cref="XElement" /> that represents <paramref name="obj" />.</returns>
/// <exception cref="ArgumentNullException"><paramref name="obj" /> is <see langword="null" />.</exception>
public static XElement ToElement(string name, object obj, XConvertSettings settings = null)
{
Ensure.Argument.NotNull(obj, "obj");
settings = settings ?? XConvertSettings.Default;
var type = obj.GetType();
var converter = settings.FindConverter(type);
return(converter.ToElement(name, type, obj, settings));
}
protected override void PopulateObjectImpl(object obj, XElement element, XConvertSettings settings)
{
var collectionProxy = CreateCollectionProxy(obj);
foreach (var itemElement in element.Elements(ItemName))
{
var itemType = XConvertUtil.ParseType(itemElement) ?? collectionProxy.ItemType;
var item = XConvert.ToObject(itemType, itemElement, settings);
collectionProxy.Add(item);
}
}
protected override void PopulateElementChildren(
XElement element, Type declareType, object obj, XConvertSettings settings)
{
if (obj == null)
{
return;
}
var actualType = obj.GetType();
Ensure.Argument.Is(actualType, "obj", declareType);
foreach (var members in EnumMembers(obj))
{
var memberCount = members.Count();
foreach (var member in members)
{
Type declareMemberType = null;
Type actualMemberType = null;
object value = null;
var field = member as FieldInfo;
if (field != null)
{
declareMemberType = field.FieldType;
value = field.GetValue(obj);
if (value != null)
{
actualMemberType = value.GetType();
}
}
var property = member as PropertyInfo;
if (property != null && property.CanRead)
{
declareMemberType = property.PropertyType;
value = property.GetValue(obj, null);
if (value != null)
{
actualMemberType = value.GetType();
}
}
var memberType = actualMemberType ?? declareMemberType;
var converter = settings.FindConverter(memberType);
var name = memberCount > 1 ? GetHierachicalMemberName(actualType, member) : member.Name;
var memberElement = converter.ToElement(name, declareMemberType, value, settings);
element.Add(memberElement);
}
}
}
/// <summary>
/// Populate the contents of specified xml element to an object.
/// </summary>
/// <param name="obj">The object to populate.</param>
/// <param name="element">The xml element that contains the contents of the object to populate.</param>
/// <param name="settings">
/// Convert settings used during the convert. <see cref="XConvertSettings.Default" /> is used if the value is
/// <see langword="null" />.
/// </param>
public void PopulateObject(object obj, XElement element, XConvertSettings settings)
{
Ensure.Argument.NotNull(obj, "obj");
ToObjectArgumentsCheck(obj.GetType(), element);
settings = settings ?? XConvertSettings.Default;
var objType = obj.GetType();
ExecuteCallback <OnConvertingToObjectAttribute>(objType, obj);
PopulateObjectImpl(obj, element, settings);
ExecuteCallback <OnConvertedToObjectAttribute>(objType, obj);
}
/// <summary>
/// Populate contents of specified <see cref="XElement" /> instance from specified object.
/// </summary>
/// <param name="element">The <see cref="XElement" /> instance to populate.</param>
/// <param name="declareType">Declaring type of the specified object.</param>
/// <param name="obj">The object that contains the contents to populate from.</param>
/// <param name="settings">
/// Convert settings used when populating. <see cref="XConvertSettings.Default" /> will be used if the value is
/// <see langword="null" />.
/// </param>
public void PopulateElement(XElement element, Type declareType, object obj, XConvertSettings settings)
{
Ensure.Argument.NotNull(element, "element");
ToElementArgumentsCheck(declareType, obj);
settings = settings ?? XConvertSettings.Default;
PopulateElementAttributes(element, declareType, obj, settings);
PopulateElementValue(element, declareType, obj, settings);
PopulateElementChildren(element, declareType, obj, settings);
ExecuteCallback <OnConvertedToElementAttribute>(declareType, obj);
}
protected virtual void PopulateElementAttributes(
XElement element, Type declareType, object obj, XConvertSettings settings)
{
var actualType = obj != null?obj.GetType() : declareType;
var typeAttribute = CreateTypeAttribute(declareType, actualType,
settings.TypeAttributeHandling, settings.AssemblyNameStyle);
if (typeAttribute != null)
{
element.Add(typeAttribute);
}
}
public static XDocument ToDocument(string name, object obj, XConvertSettings settings = null)
{
Ensure.Argument.NotNullOrEmpty(name, "name");
Ensure.Argument.NotNull(obj, "obj");
var document = new XDocument();
var element = ToElement(name, obj, settings);
document.Add(element);
return(document);
}
public static XDocument ToDocument(
IEnumerable <KeyValuePair <string, object> > objects, XConvertSettings settings = null)
{
Ensure.Argument.NotNullOrEmpty(objects, "objects");
var document = new XDocument();
foreach (var kvp in objects)
{
document.Add(ToElement(kvp.Key, kvp.Value, settings));
}
return(document);
}
/// <summary>
/// Convert specified object to <see cref="XElement" />.
/// </summary>
/// <param name="name">Name of the converted <see cref="XElement" />.</param>
/// <param name="declareType">Declare type of the converting object.</param>
/// <param name="obj">Object to convert.</param>
/// <param name="settings">
/// Convert settings used during the convertion. <see cref="XConvertSettings.Default" /> will be used if the value is
/// <see langword="null" />.
/// </param>
/// <returns>A <see cref="XElement" /> instance converted from <paramref name="obj" />.</returns>
public XElement ToElement(string name, Type declareType, object obj, XConvertSettings settings)
{
Ensure.Argument.NotNullOrEmpty(name, "name");
ToElementArgumentsCheck(declareType, obj);
settings = settings ?? XConvertSettings.Default;
ExecuteCallback <OnConvertingToElementAttribute>(declareType, obj);
var element = new XElement(name);
PopulateElement(element, declareType, obj, settings);
return(element);
}
/// <summary>
/// Create object of specified type, then populate contents of specified xml element to the created object.
/// </summary>
/// <param name="objType">The type of object to create.</param>
/// <param name="element">The xml element that contains the contents to populate.</param>
/// <param name="settings">
/// Convert settings used during the convert. <see cref="XConvertSettings.Default" /> is used if the value is
/// <see langword="null" />.
/// </param>
/// <returns>Object of type <paramref name="objType" /> that holds contents of <paramref name="element" />.</returns>
public object ToObject(Type objType, XElement element, XConvertSettings settings)
{
ToObjectArgumentsCheck(objType, element);
settings = settings ?? XConvertSettings.Default;
var obj = CreateObject(objType, element, settings);
ExecuteCallback <OnConvertingToObjectAttribute>(objType, obj);
if (obj != null)
{
PopulateObjectImpl(obj, element, settings);
}
ExecuteCallback <OnConvertedToObjectAttribute>(objType, obj);
return(obj);
}
protected override void PopulateObjectImpl(object obj, XElement element, XConvertSettings settings)
{
var objType = obj.GetType();
var membersDict = GetMembers(obj);
foreach (var memberElement in element.Elements())
{
string name;
MemberInfo member;
GetMemberInfo(objType, membersDict, memberElement, out name, out member);
if (member == null)
{
switch (MissingMemberHandling)
{
case MissingMemberHandling.Ignore:
continue;
case MissingMemberHandling.ThrowException:
throw new MissingMemberException(objType.FullName, name);
default:
continue;
}
}
var declareMemberType = GetDeclareMemberType(member);
var actualMemberType = XConvertUtil.ParseType(memberElement);
if (actualMemberType != null)
{
if (actualMemberType != declareMemberType && !actualMemberType.IsSubclassOf(declareMemberType))
{
throw new XmlException(string.Format(
"Object(of type {0}) member type({1}) from xml does not match with its declare type({2}) of the object.",
objType, actualMemberType, declareMemberType));
}
}
var usingMemberType = actualMemberType ?? declareMemberType;
var converter = settings.FindConverter(usingMemberType);
var value = converter.ToObject(usingMemberType, memberElement, settings);
SetMemberValue(member, obj, value);
}
}
protected override object CreateObject(Type objType, XElement element, XConvertSettings settings)
{
return(ParseValue(element.Value));
}
protected virtual void PopulateElementValue(
XElement element, Type declareType, object obj, XConvertSettings settings)
{
element.Value = obj != null?obj.ToString() : null;
}
protected override void PopulateElementAttributes(
XElement element, Type declareType, object obj, XConvertSettings settings)
{
element.Add(XConvertUtil.CreateTypeAttribute(declareType, settings.AssemblyNameStyle));
}
protected virtual void PopulateObjectImpl(object obj, XElement element, XConvertSettings settings)
{
}
protected virtual object CreateObject(Type objType, XElement element, XConvertSettings settings)
{
return(element.IsEmpty && !element.Elements().Any() ? null : Activator.CreateInstance(objType, true));
}
protected override object CreateObject(Type objType, XElement element, XConvertSettings settings)
{
return(element.IsEmpty ? null : element.Value);
}
protected override void PopulateElementValue(
XElement element, Type declareType, object obj, XConvertSettings settings)
{
}
public T ToObject <T>(XElement element, XConvertSettings settings)
{
return((T)ToObject(typeof(T), element, settings));
}
protected virtual void PopulateElementChildren(
XElement element, Type declareType, object obj, XConvertSettings settings)
{
}
public static object[] ToObjects(XDocument document, XConvertSettings settings = null)
{
Ensure.Argument.NotNull(document, "document");
return(document.Elements().Select(e => ToObject(e, settings)).ToArray());
}