internal static string GetXmlName(MemberInfo mi)
{
object[] vAttribs = mi.GetCustomAttributes(true);
string strXmlName = mi.Name;
XmlTypeAttribute xmlType = GetAttribute <XmlTypeAttribute>(vAttribs);
if (xmlType != null)
{
strXmlName = xmlType.TypeName;
}
XmlRootAttribute xmlRoot = GetAttribute <XmlRootAttribute>(vAttribs);
if (xmlRoot != null)
{
strXmlName = xmlRoot.ElementName;
}
XmlArrayAttribute xmlArray = GetAttribute <XmlArrayAttribute>(vAttribs);
if (xmlArray != null)
{
strXmlName = xmlArray.ElementName;
}
XmlElementAttribute xmlElement = GetAttribute <XmlElementAttribute>(vAttribs);
if (xmlElement != null)
{
strXmlName = xmlElement.ElementName;
}
return(strXmlName);
}
/// <summary>
/// 判断成员信息pInfo是否被标记为XML相关属性
/// </summary>
/// <param name="pInfo">成员信息</param>
/// <param name="attr">返回XML相关属性</param>
/// <returns></returns>
bool IsXmlAttribute(MemberInfo pInfo, out Attribute attr)
{
bool found = false;
attr = null;
var caList = pInfo.GetCustomAttributes(true);
foreach (var ca in caList)
{
if (ca is XmlElementAttribute)
{
attr = new XmlElementAttribute((ca as XmlElementAttribute).ElementName);
found = true;
break;
}
else if (ca is XmlArrayAttribute)
{
attr = new XmlArrayAttribute((ca as XmlArrayAttribute).ElementName);
found = true;
break;
}
else
{
// TODO: other type
}
}
return(found);
}
private static void WritePropToFile(string format, PropertyInfo prop, XmlArrayAttribute attribute, StreamWriter file)
{
file.WriteLine(format, prop.Name, attribute.ElementName.Replace("[]", ""), prop.PropertyType.Name());
if (prop.Name.EndsWith("DateAsString"))
{
file.WriteLine(format, prop.Name.Replace("DateAsString", ""), attribute.ElementName, typeof(DateTime).Name());
}
}
public void ElementNameDefault()
{
XmlArrayAttribute attr = new XmlArrayAttribute();
Assert.AreEqual(string.Empty, attr.ElementName, "#1");
attr.ElementName = null;
Assert.AreEqual(string.Empty, attr.ElementName, "#2");
}
private XName GetCollectionName(PropertyInfo propertyInfo)
{
XmlArrayAttribute attribute = propertyInfo.GetCustomAttribute <XmlArrayAttribute>();
if (attribute == null)
{
return(_ns + propertyInfo.Name);
}
return(_ns + attribute.ElementName);
}
public LiteralAttributes(MemberInfo memberInfo, XmlAttributes xmlAtts) :
this(memberInfo)
{
if (xmlAtts == null)
{
return;
}
Ignore = xmlAtts.XmlIgnore;
if (!Ignore)
{
XmlChoiceIdentifier = xmlAtts.XmlChoiceIdentifier;
XmlAttribute = xmlAtts.XmlAttribute;
XmlArray = xmlAtts.XmlArray;
XmlText = xmlAtts.XmlText;
XmlEnum = xmlAtts.XmlEnum;
DefaultValue = (xmlAtts.XmlDefaultValue == null) ?
null :
new DefaultValueAttribute(xmlAtts.XmlDefaultValue);
Xmlns = xmlAtts.Xmlns;
if (Xmlns)
{
object[] attrs = memberInfo.GetCustomAttributes(s_nsDeclType, false).ToArray();
XmlNamespaceDeclaration = (XmlNamespaceDeclarationsAttribute)(attrs.Length > 0 ? attrs[0] : null);
}
else
{
XmlNamespaceDeclaration = null;
}
// Use if statements here so that the XmlElements collection populated by reflection
// is eliminated only if the app developer has provided substitute XmlElementAttribute's.
// Ditto for the XmlArrayItems and XmlAnyElements.
if (xmlAtts.XmlElements.Count > 0)
{
XmlElements = xmlAtts.XmlElements;
}
if (xmlAtts.XmlArrayItems.Count > 0)
{
XmlArrayItems = xmlAtts.XmlArrayItems;
}
XmlAnyAttribute = xmlAtts.XmlAnyAttribute;
if (xmlAtts.XmlAnyElements.Count > 0)
{
XmlAnyElements = xmlAtts.XmlAnyElements;
}
}
}
public void XmlArrayDifferentNames()
{
XmlArrayAttribute array1 = new XmlArrayAttribute("myname");
XmlArrayAttribute array2 = new XmlArrayAttribute("myothername");
atts1.XmlArray = array1;
atts2.XmlArray = array2;
ov1.Add(typeof(SerializeMe), atts1);
ov2.Add(typeof(SerializeMe), atts2);
ThumbprintHelpers.DifferentThumbprint(ov1, ov2);
}
public void XmlArraySameName()
{
XmlArrayAttribute array1 = new XmlArrayAttribute("myname");
XmlArrayAttribute array2 = new XmlArrayAttribute("myname");
atts1.XmlArray = array1;
atts2.XmlArray = array2;
ov1.Add(typeof(SerializeMe), atts1);
ov2.Add(typeof(SerializeMe), atts2);
ThumbprintHelpers.SameThumbprint(ov1, ov2);
}
/// <summary>
/// Gets the serialized name for the member.
/// </summary>
/// <param name="member"></param>
/// <returns></returns>
public override IEnumerable <DataName> GetName(MemberInfo member)
{
if (member is Type)
{
XmlRootAttribute rootAttr = TypeCoercionUtility.GetAttribute <XmlRootAttribute>(member);
if (rootAttr != null && !String.IsNullOrEmpty(rootAttr.ElementName))
{
yield return(new DataName(rootAttr.ElementName, null, rootAttr.Namespace));
}
XmlTypeAttribute typeAttr = TypeCoercionUtility.GetAttribute <XmlTypeAttribute>(member);
if (typeAttr != null && !String.IsNullOrEmpty(typeAttr.TypeName))
{
yield return(new DataName(typeAttr.TypeName, null, typeAttr.Namespace));
}
yield break;
}
XmlElementAttribute elemAttr = TypeCoercionUtility.GetAttribute <XmlElementAttribute>(member);
if (elemAttr != null && !String.IsNullOrEmpty(elemAttr.ElementName))
{
yield return(new DataName(elemAttr.ElementName, null, elemAttr.Namespace));
}
XmlAttributeAttribute attrAttr = TypeCoercionUtility.GetAttribute <XmlAttributeAttribute>(member);
if (attrAttr != null && !String.IsNullOrEmpty(attrAttr.AttributeName))
{
yield return(new DataName(attrAttr.AttributeName, null, attrAttr.Namespace, true));
}
XmlArrayAttribute arrayAttr = TypeCoercionUtility.GetAttribute <XmlArrayAttribute>(member);
if (arrayAttr != null && !String.IsNullOrEmpty(arrayAttr.ElementName))
{
// TODO: figure out a way to surface XmlArrayItemAttribute name too
yield return(new DataName(arrayAttr.ElementName, null, arrayAttr.Namespace));
}
if (member is FieldInfo && ((FieldInfo)member).DeclaringType.IsEnum)
{
XmlEnumAttribute enumAttr = TypeCoercionUtility.GetAttribute <XmlEnumAttribute>(member);
if (enumAttr != null && !String.IsNullOrEmpty(enumAttr.Name))
{
yield return(new DataName(enumAttr.Name));
}
}
}
private static void AddXmlArrayPrint(XmlArrayAttribute att, StringBuilder printBuilder)
{
if (null != att)
{
printBuilder.Append(att.ElementName);
printBuilder.Append("/");
printBuilder.Append(att.Form);
printBuilder.Append("/");
printBuilder.Append(att.IsNullable);
printBuilder.Append("/");
printBuilder.Append(att.Namespace);
}
printBuilder.Append("%%");
}
protected virtual Serializer <TContext> CreateArraySerializer(PropertyInfo property,
XmlArrayAttribute arrayAttribute,
XmlArrayItemAttribute arrayItemAttribute)
{
return(CreateSerializer(
CreateArraySerializer(
property,
string.IsNullOrEmpty(arrayAttribute.Name) ? property.Name : arrayAttribute.Name,
arrayAttribute.Namespace,
arrayAttribute.Prefix,
arrayAttribute.OmitIfEmpty,
arrayItemAttribute),
arrayAttribute.OmitIfNull));
}
// Return an XmlSerializer used for overriding.
public XmlSerializer CreateOverrider()
{
// Creating XmlAttributeOverrides and XmlAttributes objects.
XmlAttributeOverrides xOver = new XmlAttributeOverrides();
XmlAttributes xAttrs = new XmlAttributes();
// Add an override for the XmlArray.
XmlArrayAttribute xArray = new XmlArrayAttribute("Staff");
xArray.Namespace = "http://www.cpandl.com";
xAttrs.XmlArray = xArray;
xOver.Add(typeof(Group), "Members", xAttrs);
// Create the XmlSerializer and return it.
return(new XmlSerializer(typeof(Group), xOver));
}
public void DocumentLiteralWithNamedOutArrayParameter()
{
WebServiceProxyFactory wspf = new WebServiceProxyFactory();
wspf.ServiceUri = new AssemblyResource("assembly://Spring.Services.Tests/Spring.Data.Spring.Web.Services/document-literal.wsdl");
wspf.ServiceInterface = typeof(IHelloWorld);
wspf.AfterPropertiesSet();
object proxy = wspf.GetObject();
Assert.IsNotNull(proxy);
Type proxyType = proxy.GetType();
Assert.IsTrue(proxy is IHelloWorld);
Assert.IsTrue(proxy is SoapHttpClientProtocol);
MethodInfo sayHelloArrayMethod = proxyType.GetMethod("SayHelloArray");
Assert.IsNotNull(sayHelloArrayMethod);
object[] sdmaAttrs = sayHelloArrayMethod.GetCustomAttributes(typeof(SoapDocumentMethodAttribute), false);
Assert.IsTrue(sdmaAttrs.Length > 0);
SoapDocumentMethodAttribute sdma = (SoapDocumentMethodAttribute)sdmaAttrs[0];
Assert.AreEqual("http://www.springframwework.net/SayHelloArray", sdma.Action);
Assert.AreEqual(SoapParameterStyle.Wrapped, sdma.ParameterStyle);
Assert.AreEqual(string.Empty, sdma.Binding);
Assert.AreEqual(false, sdma.OneWay);
Assert.AreEqual(string.Empty, sdma.RequestElementName);
Assert.AreEqual("http://www.springframwework.net", sdma.RequestNamespace);
Assert.AreEqual(string.Empty, sdma.ResponseElementName);
Assert.AreEqual("http://www.springframwework.net", sdma.ResponseNamespace);
Assert.AreEqual(SoapBindingUse.Literal, sdma.Use);
object[] xaAttrs = sayHelloArrayMethod.ReturnTypeCustomAttributes.GetCustomAttributes(typeof(XmlArrayAttribute), false);
Assert.IsTrue(xaAttrs.Length > 0);
XmlArrayAttribute xaa = (XmlArrayAttribute)xaAttrs[0];
Assert.AreEqual("out", xaa.ElementName);
// Try to instantiate the proxy type
ObjectUtils.InstantiateType(proxyType);
}
public void XmlArrayDifferentForm()
{
XmlArrayAttribute array1 = new XmlArrayAttribute("myname");
array1.Form = System.Xml.Schema.XmlSchemaForm.Qualified;
XmlArrayAttribute array2 = new XmlArrayAttribute("myname");
array2.Form = System.Xml.Schema.XmlSchemaForm.Unqualified;
atts1.XmlArray = array1;
atts2.XmlArray = array2;
ov1.Add(typeof(SerializeMe), atts1);
ov2.Add(typeof(SerializeMe), atts2);
ThumbprintHelpers.DifferentThumbprint(ov1, ov2);
}
public void XmlArrayDifferentNullable()
{
XmlArrayAttribute array1 = new XmlArrayAttribute("myname");
array1.IsNullable = true;
XmlArrayAttribute array2 = new XmlArrayAttribute("myname");
array2.IsNullable = false;
atts1.XmlArray = array1;
atts2.XmlArray = array2;
ov1.Add(typeof(SerializeMe), atts1);
ov2.Add(typeof(SerializeMe), atts2);
ThumbprintHelpers.DifferentThumbprint(ov1, ov2);
}
public void DefaultConstructor_ReturnsDefaultValues()
{
// Call
var assembly = new SerializableAssembly();
// Assert
Assert.IsNull(assembly.Id);
Assert.IsNull(assembly.Boundary);
Assert.IsNull(assembly.FeatureMembers);
object[] serializableAttributes = typeof(SerializableAssembly).GetCustomAttributes(typeof(SerializableAttribute), false);
Assert.AreEqual(1, serializableAttributes.Length);
var xmlRootAttribute = (XmlRootAttribute)typeof(SerializableAssembly).GetCustomAttributes(typeof(XmlRootAttribute), false).Single();
Assert.AreEqual("Assemblage", xmlRootAttribute.ElementName);
Assert.AreEqual("http://localhost/standaarden/assemblage", xmlRootAttribute.Namespace);
const string gmlNamespace = "http://www.opengis.net/gml/3.2";
SerializableAttributeTestHelper.AssertXmlAttributeAttribute <SerializableAssembly>(
nameof(SerializableAssembly.Id), "id", gmlNamespace);
SerializableAttributeTestHelper.AssertXmlElementAttribute <SerializableAssembly>(
nameof(SerializableAssembly.Boundary), "boundedBy", gmlNamespace);
XmlArrayAttribute xmlArrayAttribute = TypeUtils.GetPropertyAttributes <SerializableAssembly, XmlArrayAttribute>(nameof(SerializableAssembly.FeatureMembers)).Single();
Assert.AreEqual("featureMember", xmlArrayAttribute.ElementName);
IEnumerable <XmlArrayItemAttribute> xmlArrayItemAttributes = TypeUtils.GetPropertyAttributes <SerializableAssembly, XmlArrayItemAttribute>(nameof(SerializableAssembly.FeatureMembers));
Assert.AreEqual(8, xmlArrayItemAttributes.Count());
Assert.AreEqual(typeof(SerializableAssessmentSection), xmlArrayItemAttributes.ElementAt(0).Type);
Assert.AreEqual(typeof(SerializableAssessmentProcess), xmlArrayItemAttributes.ElementAt(1).Type);
Assert.AreEqual(typeof(SerializableTotalAssemblyResult), xmlArrayItemAttributes.ElementAt(2).Type);
Assert.AreEqual(typeof(SerializableFailureMechanism), xmlArrayItemAttributes.ElementAt(3).Type);
Assert.AreEqual(typeof(SerializableFailureMechanismSectionAssembly), xmlArrayItemAttributes.ElementAt(4).Type);
Assert.AreEqual(typeof(SerializableCombinedFailureMechanismSectionAssembly), xmlArrayItemAttributes.ElementAt(5).Type);
Assert.AreEqual(typeof(SerializableFailureMechanismSectionCollection), xmlArrayItemAttributes.ElementAt(6).Type);
Assert.AreEqual(typeof(SerializableFailureMechanismSection), xmlArrayItemAttributes.ElementAt(7).Type);
}
// this method is for loading vanilla valid xml. It has a <List> tag inside the root tag, so we have to wrap it around something.
public static List <T> LoadXmlEx <T>(string localpath, string root, string item, string modpath = null, string pattern = "*.xml")
{
var defs_type = typeof(DefsEx <T>);
// we only create a new serializer if we can't find one for the type DefsEx<T>.
var id = Path.Combine(localpath, defs_type.ToString());
if (!serializers.ContainsKey(id))
{
var type_attrs = new XmlAttributes();
var root_attr = new XmlRootAttribute(root);
type_attrs.XmlRoot = root_attr;
var member_attrs = new XmlAttributes();
var array_attr = new XmlArrayAttribute("List");
var item_attr = new XmlArrayItemAttribute(item);
member_attrs.XmlArray = array_attr;
member_attrs.XmlArrayItems.Add(item_attr);
var overrides = new XmlAttributeOverrides();
overrides.Add(defs_type, type_attrs);
overrides.Add(defs_type, "Defs", member_attrs);
var serializer = new XmlSerializer(defs_type, overrides);
serializers.Add(id, serializer);
}
return(LoadXmlFile <DefsEx <T> >(localpath, modpath, pattern).SelectMany(i => i.Defs).ToList());
}
public void NamespaceDefault()
{
XmlArrayAttribute attr = new XmlArrayAttribute();
Assert.IsNull(attr.Namespace);
}
private void writeObjectFolder(string filePath, object obj)
{
_ObjectStore.UnMarkSerialized(obj);
Type objectType = obj.GetType(), stringType = typeof(String);
string folderPath = Path.GetDirectoryName(filePath);
HashSet <string> nestedProperties = new HashSet <string>();
List <Tuple <string, object, bool> > queued = new List <Tuple <string, object, bool> >();
IList <PropertyInfo> fields = this.GetFieldsOrdered(objectType);
foreach (PropertyInfo propertyInfo in fields)
{
if (propertyInfo == null)
{
continue;
}
Type propertyType = propertyInfo.PropertyType;
XmlArrayAttribute xmlArrayAttribute = propertyInfo.GetCustomAttribute <XmlArrayAttribute>();
XmlArrayItemAttribute xmlArrayItemAttribute = propertyInfo.GetCustomAttribute <XmlArrayItemAttribute>();
if (xmlArrayAttribute != null && xmlArrayItemAttribute != null)
{
bool isLeaf = xmlArrayItemAttribute != null && string.Compare(xmlArrayItemAttribute.DataType, "_leaf_", true) == 0;
if (string.IsNullOrEmpty(xmlArrayItemAttribute.ElementName) && xmlArrayItemAttribute.NestingLevel > 0 && propertyType.IsGenericType && typeof(IEnumerable).IsAssignableFrom(propertyType.GetGenericTypeDefinition()))
{
Type genericType = propertyType.GetGenericArguments()[0];
PropertyInfo uniqueIdProperty = genericType.GetProperty("id", typeof(string));
PropertyInfo folderNameProperty = genericType.GetProperty("_folderName", typeof(string));
if (folderNameProperty == null)
{
folderNameProperty = uniqueIdProperty;
}
PropertyInfo nameProp = objectType.GetProperty("Name", typeof(string));
if (uniqueIdProperty != null)
{
IEnumerable enumerable = propertyInfo.GetValue(obj) as IEnumerable;
if (enumerable != null)
{
bool allSaved = true, nestingValid = true;;
int count = 0;
foreach (object nested in enumerable)
{
if (nested == null)
{
continue;
}
count++;
if (!_ObjectStore.isSerialized(nested))
{
allSaved = false;
}
object objId = uniqueIdProperty.GetValue(nested);
if (objId == null || string.IsNullOrEmpty(objId.ToString()))
{
nestingValid = false;
break;
}
}
if (nestingValid && !allSaved)
{
string nestedPath = Path.Combine(folderPath, removeInvalidFile(propertyInfo.Name));
Directory.CreateDirectory(nestedPath);
nestedProperties.Add(propertyInfo.Name);
if (xmlArrayItemAttribute.NestingLevel > 1)
{
string prefix = m_NominatedTypeFilePrefix.Count > 0 ? hasFilePrefix(genericType) : "";
IEnumerable <IGrouping <char, object> > groups = null;
if (string.IsNullOrEmpty(prefix))
{
groups = enumerable.Cast <object>().GroupBy(x => char.ToLower(uniqueIdProperty.GetValue(x).ToString()[0]));
}
else
{
int prefixLength = prefix.Length;
groups = enumerable.Cast <object>().GroupBy(x => char.ToLower(initialChar(uniqueIdProperty.GetValue(x).ToString(), prefix, prefixLength)));
}
foreach (IGrouping <char, object> group in groups)
{
string alphaPath = Path.Combine(nestedPath, group.Key.ToString());
Directory.CreateDirectory(alphaPath);
foreach (object nested in group)
{
_ObjectStore.MarkSerialized(nested);
string nestedObjectPath = isLeaf ? alphaPath : Path.Combine(alphaPath, removeInvalidFile(folderNameProperty.GetValue(nested).ToString()));
Directory.CreateDirectory(nestedObjectPath);
string fileName = removeInvalidFile((isLeaf ? uniqueIdProperty.GetValue(nested).ToString() : nested.GetType().Name) + ".xml");
queued.Add(new Tuple <string, object, bool>(Path.Combine(nestedObjectPath, fileName), nested, isLeaf));
}
}
continue;
}
foreach (object nested in enumerable)
{
if (nested == null)
{
continue;
}
_ObjectStore.MarkSerialized(nested);
string nestedObjectPath = isLeaf ? nestedPath : Path.Combine(nestedPath, removeInvalidFile(isLeaf ? uniqueIdProperty.GetValue(nested).ToString() : folderNameProperty.GetValue(nested).ToString()));
Directory.CreateDirectory(nestedObjectPath);
string fileName = removeInvalidFile((isLeaf ? uniqueIdProperty.GetValue(nested).ToString() : nested.GetType().Name) + ".xml");
queued.Add(new Tuple <string, object, bool>(Path.Combine(nestedObjectPath, fileName), nested, isLeaf));
}
}
}
}
}
}
else
{
object propertyObject = propertyInfo.GetValue(obj);
if (propertyObject == null)
{
nestedProperties.Add(propertyInfo.Name);
}
else
{
DataType dataType = DataType.Custom;
string fileExtension = ".txt", txt = "";
foreach (DataTypeAttribute dataTypeAttribute in propertyInfo.GetCustomAttributes <DataTypeAttribute>())
{
FileExtensionsAttribute fileExtensionsAttribute = dataTypeAttribute as FileExtensionsAttribute;
if (fileExtensionsAttribute != null && !string.IsNullOrEmpty(fileExtensionsAttribute.Extensions))
{
fileExtension = fileExtensionsAttribute.Extensions;
}
if (dataTypeAttribute.DataType != DataType.Custom)
{
dataType = dataTypeAttribute.DataType;
}
}
if (dataType == DataType.Html)
{
string html = propertyObject.ToString();
if (!string.IsNullOrEmpty(html))
{
nestedProperties.Add(propertyInfo.Name);
string htmlPath = Path.Combine(folderPath, propertyInfo.Name + ".html");
File.WriteAllText(htmlPath, html.TrimEnd() + Environment.NewLine, Encoding.UTF8);
continue;
}
}
else if (dataType == DataType.MultilineText)
{
byte[] byteArray = propertyObject as byte[];
if (byteArray != null)
{
nestedProperties.Add(propertyInfo.Name);
txt = Encoding.ASCII.GetString(byteArray);
}
else
{
txt = propertyObject.ToString();
}
if (!string.IsNullOrEmpty(txt))
{
nestedProperties.Add(propertyInfo.Name);
string txtPath = Path.Combine(folderPath, propertyInfo.Name + fileExtension);
File.WriteAllText(txtPath, txt.TrimEnd() + Environment.NewLine, Encoding.UTF8);
continue;
}
}
}
}
}
if (nestedProperties.Count < fields.Count)
{
_ObjectStore.UnMarkSerialized(obj);
using (FileStream fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
writeObject(fileStream, obj, nestedProperties);
}
}
foreach (Tuple <string, object, bool> o in queued)
{
if (o.Item3)
{
_ObjectStore.UnMarkSerialized(o.Item2);
using (FileStream fileStream = new FileStream(o.Item1, FileMode.Create, FileAccess.Write))
{
writeObject(fileStream, o.Item2, new HashSet <string>());
}
}
else
{
writeObjectFolder(o.Item1, o.Item2);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="list"></param>
/// <param name="inherit"></param>
/// <param name="inverse"></param>
/// <param name="platform">Specific version, or UNSET to use default (latest)</param>
private void BuildFieldList(Type type, IList <PropertyInfo> list, bool inherit, bool inverse)
{
if (inherit && type.BaseType != typeof(object) && type.BaseType != typeof(Serializer))
{
BuildFieldList(type.BaseType, list, inherit, inverse);
// zero-out any fields that are overridden as derived at subtype (e.g. IfcSIUnit.Dimensions)
for (int iField = 0; iField < list.Count; iField++)
{
PropertyInfo field = list[iField];
if (field != null)
{
PropertyInfo prop = type.GetProperty(field.Name.Substring(1), BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (prop != null)
{
list[iField] = null; // hide derived fields
}
}
}
}
PropertyInfo[] fields = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
PropertyInfo[] sorted = new PropertyInfo[fields.Length];
List <PropertyInfo> unorderedAttributes = new List <PropertyInfo>();
SortedList <int, PropertyInfo> orderedAttributes = new SortedList <int, PropertyInfo>();
foreach (PropertyInfo field in fields)
{
DataMemberAttribute dataMemberAttribute = field.GetCustomAttribute <DataMemberAttribute>();
if (_XmlAttributePriority)
{
XmlIgnoreAttribute xmlIgnoreAttribute = field.GetCustomAttribute <XmlIgnoreAttribute>();
if (xmlIgnoreAttribute != null)
{
continue;
}
XmlElementAttribute xmlElementAttribute = field.GetCustomAttribute <XmlElementAttribute>();
if (xmlElementAttribute != null)
{
if (xmlElementAttribute.Order > -1 && xmlElementAttribute.Order < fields.Length)
{
sorted[xmlElementAttribute.Order] = field;
continue;
}
if (dataMemberAttribute == null)
{
unorderedAttributes.Add(field);
continue;
}
}
XmlAttributeAttribute xmlAttributeAttribute = field.GetCustomAttribute <XmlAttributeAttribute>();
if (xmlAttributeAttribute != null)
{
if (dataMemberAttribute != null && dataMemberAttribute.Order >= 0)
{
orderedAttributes.Add(dataMemberAttribute.Order, field);
continue;
}
if (dataMemberAttribute == null)
{
unorderedAttributes.Add(field);
continue;
}
}
XmlArrayAttribute xmlArrayAttribute = field.GetCustomAttribute <XmlArrayAttribute>();
if (xmlArrayAttribute != null)
{
if (xmlArrayAttribute.Order > -1 && xmlArrayAttribute.Order < fields.Length)
{
sorted[xmlArrayAttribute.Order] = field;
continue;
}
if (dataMemberAttribute == null)
{
unorderedAttributes.Add(field);
continue;
}
}
}
if (dataMemberAttribute != null)
{
if (dataMemberAttribute.Order < fields.Length)
{
sorted[dataMemberAttribute.Order] = field;
}
else
{
unorderedAttributes.Add(field);
}
}
}
foreach (PropertyInfo sort in sorted)
{
if (sort != null)
{
list.Add(sort);
}
}
foreach (PropertyInfo propertyInfo in orderedAttributes.Values)
{
list.Add(propertyInfo);
}
foreach (PropertyInfo propertyInfo in unorderedAttributes)
{
list.Add(propertyInfo);
}
// now inverse -- need particular order???
if (inverse)
{
//fields = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
foreach (PropertyInfo field in fields)
{
if (field.IsDefined(typeof(InversePropertyAttribute), false))
{
list.Add(field);
}
}
}
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlAttributes(ICustomAttributeProvider provider)
{
object[] attrs = provider.GetCustomAttributes(false);
// most generic <any/> matches everything
XmlAnyElementAttribute wildcard = null;
for (int i = 0; i < attrs.Length; i++)
{
if (attrs[i] is XmlIgnoreAttribute || attrs[i] is ObsoleteAttribute || attrs[i].GetType() == IgnoreAttribute)
{
_xmlIgnore = true;
break;
}
else if (attrs[i] is XmlElementAttribute)
{
_xmlElements.Add((XmlElementAttribute)attrs[i]);
}
else if (attrs[i] is XmlArrayItemAttribute)
{
_xmlArrayItems.Add((XmlArrayItemAttribute)attrs[i]);
}
else if (attrs[i] is XmlAnyElementAttribute)
{
XmlAnyElementAttribute any = (XmlAnyElementAttribute)attrs[i];
if ((any.Name == null || any.Name.Length == 0) && any.NamespaceSpecified && any.Namespace == null)
{
// ignore duplicate wildcards
wildcard = any;
}
else
{
_xmlAnyElements.Add((XmlAnyElementAttribute)attrs[i]);
}
}
else if (attrs[i] is DefaultValueAttribute)
{
_xmlDefaultValue = ((DefaultValueAttribute)attrs[i]).Value;
}
else if (attrs[i] is XmlAttributeAttribute)
{
_xmlAttribute = (XmlAttributeAttribute)attrs[i];
}
else if (attrs[i] is XmlArrayAttribute)
{
_xmlArray = (XmlArrayAttribute)attrs[i];
}
else if (attrs[i] is XmlTextAttribute)
{
_xmlText = (XmlTextAttribute)attrs[i];
}
else if (attrs[i] is XmlEnumAttribute)
{
_xmlEnum = (XmlEnumAttribute)attrs[i];
}
else if (attrs[i] is XmlRootAttribute)
{
_xmlRoot = (XmlRootAttribute)attrs[i];
}
else if (attrs[i] is XmlTypeAttribute)
{
_xmlType = (XmlTypeAttribute)attrs[i];
}
else if (attrs[i] is XmlAnyAttributeAttribute)
{
_xmlAnyAttribute = (XmlAnyAttributeAttribute)attrs[i];
}
else if (attrs[i] is XmlChoiceIdentifierAttribute)
{
_xmlChoiceIdentifier = (XmlChoiceIdentifierAttribute)attrs[i];
}
else if (attrs[i] is XmlNamespaceDeclarationsAttribute)
{
_xmlns = true;
}
}
if (_xmlIgnore)
{
_xmlElements.Clear();
_xmlArrayItems.Clear();
_xmlAnyElements.Clear();
_xmlDefaultValue = null;
_xmlAttribute = null;
_xmlArray = null;
_xmlText = null;
_xmlEnum = null;
_xmlType = null;
_xmlAnyAttribute = null;
_xmlChoiceIdentifier = null;
_xmlns = false;
}
else
{
if (wildcard != null)
{
_xmlAnyElements.Add(wildcard);
}
}
}
internal static bool TryGetTag(MemberInfo member, out int tag, out string name, bool callerIsTagInference, out DataFormat format, out MemberSerializationOptions options)
{
name = member.Name;
format = DataFormat.Default;
tag = -1;
options = MemberSerializationOptions.None;
// check for delegates (don't even try!)
Type valueType;
switch (member.MemberType)
{
case MemberTypes.Property:
valueType = ((PropertyInfo)member).PropertyType;
break;
case MemberTypes.Field:
valueType = ((FieldInfo)member).FieldType;
break;
default: // not sure what this is!
return(false);
}
if (valueType.IsSubclassOf(typeof(Delegate)))
{
return(false);
}
// check for exclusion
if (AttributeUtils.GetAttribute <ProtoIgnoreAttribute>(member) != null ||
AttributeUtils.GetAttribute <ProtoPartialIgnoreAttribute>(member.ReflectedType,
delegate(ProtoPartialIgnoreAttribute ppia)
{ return(ppia.MemberName == member.Name); }) != null)
{
return(false);
}
// check against the property
ProtoMemberAttribute pm = AttributeUtils.GetAttribute <ProtoMemberAttribute>(member);
if (pm == null)
{ // check also against the type
pm = AttributeUtils.GetAttribute <ProtoPartialMemberAttribute>(member.ReflectedType,
delegate(ProtoPartialMemberAttribute ppma) { return(ppma.MemberName == member.Name); });
}
if (pm != null)
{
format = pm.DataFormat;
if (!string.IsNullOrEmpty(pm.Name))
{
name = pm.Name;
}
tag = pm.Tag;
options = pm.Options;
return(tag > 0);
}
ProtoContractAttribute pca = AttributeUtils.GetAttribute <ProtoContractAttribute>(member.DeclaringType);
if (pca != null && pca.ImplicitFields != ImplicitFields.None)
{
if (callerIsTagInference)
{
return(true); // short-circuit
}
List <MemberInfo> members = new List <MemberInfo>();
switch (pca.ImplicitFields)
{
case ImplicitFields.AllFields:
AddImplicitByDeclaringType(member.DeclaringType, members,
member.DeclaringType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
break;
case ImplicitFields.AllPublic:
AddImplicitByDeclaringType(member.DeclaringType, members,
member.DeclaringType.GetFields(BindingFlags.Instance | BindingFlags.Public));
AddImplicitByDeclaringType(member.DeclaringType, members,
member.DeclaringType.GetProperties(BindingFlags.Instance | BindingFlags.Public));
break;
default:
throw new NotSupportedException("Unknown ImplicitFields option: " + pca.ImplicitFields);
}
members.Sort(delegate(MemberInfo x, MemberInfo y)
{
return(string.CompareOrdinal(x.Name, y.Name));
});
int index = members.IndexOf(member);
if (index >= 0)
{
tag = index + pca.ImplicitFirstTag;
return(true);
}
return(false);
}
XmlElementAttribute xe = AttributeUtils.GetAttribute <XmlElementAttribute>(member);
if (xe != null)
{
if (!string.IsNullOrEmpty(xe.ElementName))
{
name = xe.ElementName;
}
tag = xe.Order;
return(tag > 0);
}
XmlArrayAttribute xa = AttributeUtils.GetAttribute <XmlArrayAttribute>(member);
if (xa != null)
{
if (!string.IsNullOrEmpty(xa.ElementName))
{
name = xa.ElementName;
}
tag = xa.Order;
return(tag > 0);
}
return(false);
}
private static void WriteElement(XmlElement node, object config)
{
IEnumerable <PropertyInformation <XmlAttributeAttribute> > attributes = GetProperties <XmlAttributeAttribute>(config);
foreach (PropertyInformation <XmlAttributeAttribute> pi in attributes)
{
object defaultAttr = pi.Property.GetCustomAttributes(typeof(System.ComponentModel.DefaultValueAttribute), true).SingleOrDefault();
object value = pi.Property.GetValue(config, null);
if (defaultAttr != null)
{
object defValue = ((System.ComponentModel.DefaultValueAttribute)defaultAttr).Value;
if (defValue == null && value == null)
{
node.RemoveAttribute(pi.Property.Name);
continue;
}
if (defValue != null && defValue.Equals(value))
{
node.RemoveAttribute(pi.Property.Name);
continue;
}
}
if (value == null)
{
XmlAttribute attr = node.Attributes[pi.Property.Name];
if (attr != null)
{
node.Attributes.Remove(attr);
}
}
else
{
string attrValue = String.Format(CultureInfo.InvariantCulture, "{0}", value);
if (value is bool)
{
attrValue = attrValue.ToLower();
}
node.SetAttribute(pi.Property.Name, attrValue);
}
}
IEnumerable <PropertyInformation <XmlArrayItemAttribute> > boundedCollections = GetProperties <XmlArrayItemAttribute>(config); //there are "unbounded" too. see below
foreach (var pi in boundedCollections)
{
string containerName = pi.Property.Name;
XmlArrayAttribute xmlArray = (XmlArrayAttribute)pi.Property.GetCustomAttributes(typeof(XmlArrayAttribute), true).SingleOrDefault();
if (xmlArray != null)
{
containerName = xmlArray.ElementName;
}
XmlNode container = node.SelectSingleNode(containerName);
if (container == null)
{
container = node.OwnerDocument.CreateElement(containerName);
node.AppendChild(container);
}
IEnumerable collection = pi.Property.GetValue(config, null) as IEnumerable;
WriteCollection(collection, pi.Attribute.ElementName, container);
}
IEnumerable <PropertyInformation <XmlElementAttribute> > selfCollection = GetProperties <XmlElementAttribute>(config);//config element contains collection of elements.
foreach (PropertyInformation <XmlElementAttribute> pi in selfCollection)
{
string elementName = pi.Property.Name;
if (!string.IsNullOrEmpty(pi.Attribute.ElementName))
{
elementName = pi.Attribute.ElementName;
}
object value = pi.Property.GetValue(config, null);
IEnumerable collection = value as IEnumerable;
if (value is string)
{
collection = null;
}
if (collection != null)
{
WriteCollection(collection, elementName, node);
}
else
{
XmlElement elementXml = (XmlElement)node.SelectSingleNode(elementName);
if (elementXml == null)
{
elementXml = node.OwnerDocument.CreateElement(elementName);
node.AppendChild(elementXml);
}
if (elementXml.Name == "Timeout" && value == null)
{
XmlNode parent = elementXml.ParentNode;
parent.RemoveChild(elementXml);
}
try
{
if (value == null)
{
elementXml.InnerText = string.Empty;
continue;
}
if (value is string || value is int || value is double || value is long)
{
elementXml.InnerText = value.ToString();
continue;
}
if (value is bool)
{
bool v = (bool)value;
elementXml.InnerText = v ? "true" : "false";
continue;
}
}
catch { }
WriteElement(elementXml, value);
}
}
}
/// <summary>
/// 以pNode为根节点，反序列化pXmlObj中XML属性为pAttr的成员
/// </summary>
/// <param name="pNode">源节点元素</param>
/// <param name="pXmlObj">反序列化对象</param>
/// <param name="pInfo">当前处理的pXmlObj的成员信息</param>
/// <param name="pAttr">XmlArray属性</param>
void ParseMemberXmlArray(XmlNode pNode, ref object pXmlObj, MemberInfo pInfo, XmlArrayAttribute pAttr)
{
if (null == pNode)
{
throw new ArgumentNullException("在{0}中，非法输入参数XmlNode", MethodBase.GetCurrentMethod().Name);
}
if (null == pXmlObj)
{
throw new ArgumentNullException("在{0}中，非法输入参数ref object", MethodBase.GetCurrentMethod().Name);
}
if (null == pInfo)
{
throw new ArgumentNullException("在{0}中，非法输入参数MemberInfo", MethodBase.GetCurrentMethod().Name);
}
if (null == pAttr)
{
throw new ArgumentNullException("在{0}中，非法输入参数XmlElementAttribute", MethodBase.GetCurrentMethod().Name);
}
if (!NodeNameMatch(pNode, pAttr.ElementName))
{
return;
} // 当前MemberInfo不是pNode期望的成员
switch (GetEnumerableCatagory(pInfo))
{
case TEnumerableCatagory.EArray:
{
ParseArrayMemberXmlArray(pNode, ref pXmlObj, pInfo, pAttr);
break;
}
case TEnumerableCatagory.EList:
{
ParseListMemberXmlArray(pNode, ref pXmlObj, pInfo);
break;
}
case TEnumerableCatagory.EUnknown:
{
MyLog.Instance.Warning("在{0}中，{1}可能是未知的可Enumerable反序列化的成员", MethodBase.GetCurrentMethod().Name, pInfo);
break;
}
default:
throw new NotSupportedException(string.Format("在{0}中，{1}不可被作为可Enumerable反序列化的成员", MethodBase.GetCurrentMethod().Name, pInfo));
}
}
/// <summary>
/// Sets the <see cref="XmlArrayAttribute"/> for the property.
/// </summary>
public OverrideMemberXml <T> Attr(XmlArrayAttribute attribute)
{
Attributes.XmlArray = attribute;
return(this);
}
/// <summary>
///
/// </summary>
/// <param name="pNode"></param>
/// <param name="pXmlObj"></param>
/// <param name="pInfo"></param>
/// <param name="pAttr"></param>
void ParseArrayMemberXmlArray(XmlNode pNode, ref object pXmlObj, MemberInfo pInfo, XmlArrayAttribute pAttr)
{
if (null == pNode)
{
throw new ArgumentNullException("在{0}中，非法输入参数XmlNode", MethodBase.GetCurrentMethod().Name);
}
if (null == pXmlObj)
{
throw new ArgumentNullException("在{0}中，非法输入参数ref object", MethodBase.GetCurrentMethod().Name);
}
if (null == pInfo)
{
throw new ArgumentNullException("在{0}中，非法输入参数MemberInfo", MethodBase.GetCurrentMethod().Name);
}
// get generic arguments of pInfo
Type memberType = null;
switch (pInfo.MemberType)
{
case MemberTypes.Field: { memberType = (pInfo as FieldInfo).FieldType; break; }
case MemberTypes.Property: { memberType = (pInfo as PropertyInfo).PropertyType; break; }
default: throw new NotSupportedException(string.Format("在{0}中，{1}不可被作为反序列化的成员（MemberType={2}）", MethodBase.GetCurrentMethod().Name, pInfo, pInfo.MemberType));
}
// create instance of List<T> by T[]
var typeFullName = memberType.FullName.Remove(memberType.FullName.IndexOf("[]"), 2);
var genericType = Assembly.GetAssembly(memberType)?.GetType(typeFullName, true);
if (null == genericType)
{
throw new NullReferenceException(string.Format("在{0}中，无法根据{1}获取Type", MethodBase.GetCurrentMethod().Name, typeFullName));
}
Type[] typeArgs = { genericType };
var makeme = typeof(List <>).MakeGenericType(typeArgs);
var arrayMemberObj = Activator.CreateInstance(makeme); // the new created instance
// get members of T
List <MemberInfo> miList = new List <MemberInfo>(1);
miList.AddRange(genericType.GetFields());
miList.AddRange(genericType.GetProperties());
// envaluated members of arrayMemberObj from pNode and its children
foreach (XmlNode child in pNode.ChildNodes)
{
var memberObj = genericType.Assembly.CreateInstance(genericType.FullName);
ParseNodes(child.ChildNodes, ref memberObj, miList);
MethodInfo methodInfo = arrayMemberObj.GetType().GetMethod("Add", BindingFlags.Instance | BindingFlags.Public);
methodInfo.Invoke(arrayMemberObj, new object[] { memberObj });
}
// convert List<T> to T[]
MethodInfo methodInfo_ToList = arrayMemberObj.GetType().GetMethod("ToArray", BindingFlags.Instance | BindingFlags.Public);
var array = methodInfo_ToList.Invoke(arrayMemberObj, new object[] { });
//(pInfo as PropertyInfo).SetValue(pXmlObj, array, null);
if (pInfo is FieldInfo)
{
(pInfo as FieldInfo).SetValue(pXmlObj, Convert.ChangeType(array, (pInfo as FieldInfo).FieldType));
} // 当前MemberInfo是成员变量
else if (pInfo is PropertyInfo)
{
(pInfo as PropertyInfo).SetValue(pXmlObj, Convert.ChangeType(array, (pInfo as PropertyInfo).PropertyType), null);
} // 当前MemberInfo是属性
else
{
throw new InvalidCastException(string.Format("{0}不是期望的MemberInfo, 不应被指定XmlElement属性", pInfo));
} // 当前MemberInfo是不支持的
}
void ProcessType()
{
attribute_deserializers = new Dictionary <string, ObjectDeserializer> ();
element_deserializers = new Dictionary <string, ObjectDeserializer> ();
foreach (var property in Properties)
{
XmlElementAttribute element_attribute = null;
XmlFlagAttribute flag_attribute = null;
XmlArrayAttribute array_attribute = null;
XmlArrayItemAttribute array_item_attribute = null;
XmlAttributeAttribute attribute_attribute = null;
foreach (var custom_attribute in property.GetCustomAttributes(false))
{
if (custom_attribute is DoNotDeserializeAttribute)
{
element_attribute = null;
flag_attribute = null;
array_attribute = null;
attribute_attribute = null;
value_property = null;
break;
}
var element = custom_attribute as XmlElementAttribute;
if (element != null)
{
element_attribute = element;
continue;
}
var flag = custom_attribute as XmlFlagAttribute;
if (flag != null)
{
flag_attribute = flag;
continue;
}
var array = custom_attribute as XmlArrayAttribute;
if (array != null)
{
array_attribute = array;
continue;
}
var array_item = custom_attribute as XmlArrayItemAttribute;
if (array_item != null)
{
array_item_attribute = array_item;
continue;
}
var attribute = custom_attribute as XmlAttributeAttribute;
if (attribute != null)
{
attribute_attribute = attribute;
continue;
}
if (custom_attribute is XmlValueAttribute)
{
// TODO check if this isn't null and throw
value_property = property;
continue;
}
}
if (element_attribute != null)
{
var deserializer =
CreateCustomDeserializer(property) ??
CreateElementDeserializer(property);
AddDeserializer(element_deserializers,
CreateName(property.Name, element_attribute.Name, element_attribute.Namespace),
deserializer);
continue;
}
if (flag_attribute != null)
{
AddDeserializer(element_deserializers,
CreateName(property.Name, flag_attribute.Name, flag_attribute.Namespace),
CreateFlagDeserializer(property));
continue;
}
if (array_attribute != null)
{
AddDeserializer(element_deserializers,
CreateName(property.Name, array_attribute.Name, array_attribute.Namespace),
CreateArrayElementDeserializer(property));
continue;
}
else if (array_item_attribute != null)
{
var name = array_item_attribute.Name;
var @namespace = array_item_attribute.Namespace;
if (string.IsNullOrEmpty(name))
{
var item_type = GetICollection(property.PropertyType).GetGenericArguments()[0];
var type_attribute = item_type.GetCustomAttributes(typeof(XmlTypeAttribute), false);
if (type_attribute.Length == 0)
{
name = item_type.Name;
}
else
{
var xml_type = (XmlTypeAttribute)type_attribute[0];
name = string.IsNullOrEmpty(xml_type.Name) ? item_type.Name : xml_type.Name;
@namespace = xml_type.Namespace;
}
}
AddDeserializer(element_deserializers,
CreateName(name, @namespace),
CreateArrayItemElementDeserializer(property));
}
if (attribute_attribute != null)
{
var deserializer =
CreateCustomDeserializer(property) ??
CreateAttributeDeserializer(property);
AddDeserializer(attribute_deserializers,
CreateName(property.Name, attribute_attribute.Name, attribute_attribute.Namespace),
deserializer);
continue;
}
}
}
private void SerializeElement <T>(T obj, List <Attribute> customAttributes, string xmlNodeName = null, XmlTagAttribute classTagAttribute = null)
{
if (customAttributes.Any(x => x.GetType() == typeof(XmlIgnoreAttribute)))
{
return;
}
Type objType = obj.GetType();
if (validTypes.Any(x => x == objType)) // If the type is one of the basics
{
XmlFormatAttribute formatAttribute = GetAttribute <XmlFormatAttribute>(customAttributes);
string objToString = string.Format("{0" + (formatAttribute == null ? "" : ":" + formatAttribute.Format) + "}", obj);
bool xmlEncode = GetAttribute <XmlCDataAttribute>(customAttributes) == null;
objToString = EscapeXMLValue(objToString, xmlEncode);
XmlElementAttribute elementAttribute = GetAttribute <XmlElementAttribute>(customAttributes);
XmlTagAttribute tagAttribute = GetAttribute <XmlTagAttribute>(customAttributes);
string xmlNodeRestylized = tagAttribute?.Format(xmlNodeName);
string xmlNodeClassRestylized = classTagAttribute?.Format(xmlNodeName);
xmlNodeName = elementAttribute?.ElementName ?? xmlNodeRestylized ?? xmlNodeClassRestylized ?? xmlNodeName;
string formattedNode = xmlNodeName != null
? string.Format("<{0}>{1}</{0}>\n", xmlNodeName, objToString)
: objToString;
Append(formattedNode);
}
else if (typeof(IEnumerable).IsAssignableFrom(objType)) // If the type is IEnumerable
{
Type underlyingType = objType.GetGenericArguments().FirstOrDefault() ?? objType.GetElementType();
XmlArrayAttribute arrayAttribute = GetAttribute <XmlArrayAttribute>(customAttributes);
XmlArrayItemAttribute arrayItemAttribute = GetAttribute <XmlArrayItemAttribute>(customAttributes);
XmlElementAttribute arrayElementAttribute = GetAttribute <XmlElementAttribute>(customAttributes);
string collectionNodeName;
string itemNodeName;
bool indent;
if (arrayElementAttribute != null && (arrayAttribute != null || arrayItemAttribute != null))
{
throw new XmlException("Cannot have both element attribute and array attribute/s");
}
else if (arrayElementAttribute != null)
{
collectionNodeName = null;
itemNodeName = arrayElementAttribute.ElementName;
indent = false;
}
else
{
collectionNodeName = arrayAttribute?.ElementName ?? xmlNodeName;
itemNodeName = arrayItemAttribute?.ElementName ?? underlyingType.Name;
indent = true;
}
if (indent)
{
Append(string.Format("<{0}>\n", collectionNodeName));
nestCount++;
}
foreach (var item in obj as IEnumerable)
{
SerializeElement(item, new List <Attribute>(), itemNodeName, classTagAttribute);
}
if (indent)
{
nestCount--;
Append(string.Format("</{0}>\n", collectionNodeName));
}
}
else // If the type is object
{
customAttributes.AddRange(GetXmlAttributes(objType));
XmlRootAttribute rootAttribute = GetAttribute <XmlRootAttribute>(customAttributes);
XmlElementAttribute elementAttribute = GetAttribute <XmlElementAttribute>(customAttributes);
XmlTagAttribute tagAttribute = GetAttribute <XmlTagAttribute>(customAttributes);
xmlNodeName = elementAttribute?.ElementName ?? rootAttribute?.ElementName ?? xmlNodeName ?? objType.Name;
var properties = objType.GetProperties();
var fields = objType.GetFields();
int xmlRootIndex = Append("");
nestCount++;
Dictionary <string, string> xmlAttributes = new Dictionary <string, string>();
foreach (var property in properties)
{
List <Attribute> propertyAttributes = GetXmlAttributes(property);
XmlAttributeAttribute xmlAttribute = GetAttribute <XmlAttributeAttribute>(propertyAttributes);
if (xmlAttribute != null)
{
string name = xmlAttribute.AttributeName.Length != 0 ? xmlAttribute.AttributeName : property.Name;
xmlAttributes.Add(name, property.GetValue(obj, null).ToString());
}
else
{
SerializeElement(property.GetValue(obj, null), propertyAttributes, property.Name, tagAttribute ?? classTagAttribute);
}
}
foreach (var field in fields)
{
List <Attribute> fieldAttributes = GetXmlAttributes(field);
XmlAttributeAttribute xmlAttribute = GetAttribute <XmlAttributeAttribute>(fieldAttributes);
if (xmlAttribute != null)
{
string name = xmlAttribute.AttributeName.Length != 0 ? xmlAttribute.AttributeName : field.Name;
xmlAttributes.Add(name, field.GetValue(obj).ToString());
}
else
{
SerializeElement(field.GetValue(obj), fieldAttributes, field.Name, tagAttribute ?? classTagAttribute);
}
}
nestCount--;
Append(string.Format("</{0}>\n", xmlNodeName));
IEnumerable <string> wholeAttributes = xmlAttributes.Select(x => x.Key + "=\"" + x.Value + "\"");
string xmlRoot = string.Format("<{0}{1}{2}>\n", xmlNodeName, (wholeAttributes.Any() ? " " : ""), string.Join(" ", wholeAttributes));
stringList[xmlRootIndex] = xmlRoot;
}
}
/// <summary>
/// Adds specified instance of XmlArrayAttribute to current type or member
/// </summary>
public OverrideXml Attr(XmlArrayAttribute attribute)
{
Open();
_attributes.XmlArray = attribute;
return(this);
}
protected virtual void ProcessProperty(PropertyInfo property,
ICollection <Serializer <TContext> > attributeSerializers,
ICollection <Serializer <TContext> > elementSerializers)
{
XmlAttributeAttribute attribute_attribute = null;
XmlElementAttribute element_attribute = null;
XmlFlagAttribute flag_attribute = null;
XmlArrayAttribute array_attribute = null;
XmlArrayItemAttribute array_item_attribute = null;
XmlValueAttribute value_attribute = null;
foreach (var custom_attribute in property.GetCustomAttributes(false))
{
if (custom_attribute is DoNotSerializeAttribute)
{
attribute_attribute = null;
element_attribute = null;
flag_attribute = null;
array_attribute = null;
value_attribute = null;
break;
}
var attribute = custom_attribute as XmlAttributeAttribute;
if (attribute != null)
{
attribute_attribute = attribute;
continue;
}
var element = custom_attribute as XmlElementAttribute;
if (element != null)
{
element_attribute = element;
continue;
}
var flag = custom_attribute as XmlFlagAttribute;
if (flag != null)
{
flag_attribute = flag;
continue;
}
var array = custom_attribute as XmlArrayAttribute;
if (array != null)
{
array_attribute = array;
continue;
}
var array_item = custom_attribute as XmlArrayItemAttribute;
if (array_item != null)
{
array_item_attribute = array_item;
continue;
}
var value = custom_attribute as XmlValueAttribute;
if (value != null)
{
value_attribute = value;
continue;
}
}
if (attribute_attribute != null)
{
attributeSerializers.Add(
CreateSerializer(property, CreateAttributeSerializer(property, attribute_attribute)));
}
else if (element_attribute != null)
{
elementSerializers.Add(
CreateSerializer(property, CreateElementSerializer(property, element_attribute)));
}
else if (flag_attribute != null)
{
elementSerializers.Add(
CreateSerializer(property, CreateFlagSerializer(property, flag_attribute)));
}
else if (array_attribute != null)
{
elementSerializers.Add(
CreateSerializer(property,
CreateArraySerializer(property, array_attribute, array_item_attribute)));
}
else if (array_item_attribute != null)
{
elementSerializers.Add(
CreateSerializer(property, CreateArrayItemSerializer(property, array_item_attribute)));
}
else if (value_attribute != null)
{
elementSerializers.Add(
CreateSerializer(property, CreateValueSerializer(property)));
}
}
