public void ReadObjectElement(ObjectElementAttribute attribute, object reader, object receiver,
ReadSettings settings, ObjectPropertyInfo info, object serializerData)
{
DataTable table = serializerData.Convert <DataTable>();
if (table.Rows.Count == 0)
{
return;
}
Type objectType = info.ObjectType;
IObjectSerializer rowSerializer = ObjectExtension.CreateSerializer("DataRow");
if (attribute.IsMultiple)
{
IList list = attribute.GetList(receiver, info);
foreach (DataRow row in table.Rows)
{
object subObject = ReadObject(attribute.UseConstructor, settings, row, objectType,
receiver, rowSerializer, info.ModelName);
list.Add(subObject);
}
}
else
{
object subObject = ReadObject(attribute.UseConstructor, settings, table.Rows[0],
objectType, receiver, rowSerializer, info.ModelName);
info.SetValue(receiver, subObject);
}
}
public void Add(BaseXmlConfigFactory factory, string regName, BaseObjectElementAttribute attr, Type type)
{
ObjectElementAttribute objAttr = new ObjectElementAttribute(attr.NamespaceType)
{
LocalName = regName,
ObjectType = type,
UseConstructor = attr.UseConstructor
};
if (attr.NamespaceType == NamespaceType.Namespace)
{
objAttr.NamespaceUri = attr.NamespaceUri;
}
QName qName = objAttr.GetQName(objAttr.LocalName);
VersionData data = ObjectUtil.TryGetValue(fLocalElements, qName.LocalName);
if (data == null)
{
data = new VersionData();
fLocalElements.Add(qName.LocalName, data);
fXmlElements.Add(qName, data);
}
data.Add(attr, objAttr, factory.DefaultVersion);
fTypeElements.Add(type, objAttr);
}
public void WriteObjectElement(ObjectElementAttribute attribute, object writer,
object value, WriteSettings settings, ObjectPropertyInfo info, object serializerData)
{
DictionaryBuilder builder = writer.Convert <DictionaryBuilder>();
QName name = info.QName;
if (attribute.IsMultiple)
{
IList list = value.Convert <IList>();
List <Dictionary <string, object> > itemList =
new List <Dictionary <string, object> >(list.Count);
foreach (var itemValue in list)
{
DictionaryBuilder subBuilder = builder.CreateBuilder();
WriteObject(subBuilder, itemValue, info.ModelName, settings, name, null);
itemList.Add(subBuilder.Data);
}
builder.Add(name.LocalName, itemList);
}
else
{
DictionaryBuilder subBuilder = builder.CreateBuilder();
WriteObject(subBuilder, value, info.ModelName, settings, name, null);
builder.Add(name.LocalName, subBuilder);
}
}
public void WriteObjectElement(ObjectElementAttribute attribute, object writer, object value,
WriteSettings settings, ObjectPropertyInfo info, object serializerData)
{
string tableName = info.LocalName;
DataSet ds = writer.Convert <DataSet>();
if (ds.Tables.Contains(tableName))
{
return;
}
IEnumerable list;
if (attribute.IsMultiple)
{
list = value as IList;
}
else
{
list = EnumUtil.Convert(value);
}
DataTable table = list.CreateTable(tableName, info.ModelName, settings);
if (table != null)
{
ds.Tables.Add(table);
}
}
public CustomPropertyInfo CanRead(string localName, string version)
{
if (localName == SIMPLE_NAME)
{
CustomPropertyInfo result = new CustomPropertyInfo(typeof(string),
new DictionaryAttribute {
NamespaceType = NamespaceType.Toolkit
});
return(result);
}
else if (fFactories.ContainsKey(localName))
{
CustomPropertyInfo result = new CustomPropertyInfo(typeof(Dictionary <string, object>),
new DynamicDictionaryAttribute(fFactories[localName]));
return(result);
}
else if (fObjectConfig.ContainsKey(localName))
{
var attr = new ObjectElementAttribute
{
ObjectType = fObjectConfig[localName]
};
return(new CustomPropertyInfo(attr.ObjectType, attr));
}
return(null);
}
public void WriteObjectElement(ObjectElementAttribute attribute, object writer, object value,
WriteSettings settings, ObjectPropertyInfo info, object serializerData)
{
string xml = value.WriteXml(settings, QName.ToolkitNoNS);
SetValue(writer, info.LocalName, xml, info, settings);
}
public void WriteObjectElement(ObjectElementAttribute attribute, object writer,
object value, WriteSettings settings, ObjectPropertyInfo info, object serializerData)
{
JsonTextWriter jsonWriter = writer.Convert <JsonTextWriter>();
QName name = info.QName;
if (attribute.IsMultiple)
{
var list = value.Convert <IEnumerable>();
if (attribute.UseJsonObject)
{
var valueList = EnumUtil.Convert(list);
IElementWriter elementWriter = serializerData.Convert <IElementWriter>();
var itemGroup = from item in valueList
where item != null
let propInfo = elementWriter.Get(item.GetType())
group new { Item = item, Info = propInfo } by propInfo.LocalName;
foreach (var group in itemGroup)
{
jsonWriter.WritePropertyName(group.Key);
jsonWriter.WriteStartArray();
foreach (var item in group)
{
WriteAObject(writer, item.Item, item.Info.ModelName, settings, jsonWriter);
}
jsonWriter.WriteEndArray();
}
//foreach (object itemValue in list)
//{
// if (itemValue == null)
// continue;
// var subPropertyInfo = elementWriter.Get(itemValue.GetType());
// jsonWriter.WritePropertyName(subPropertyInfo.LocalName);
// WriteAObject(writer, itemValue, subPropertyInfo.ModelName, settings, jsonWriter);
//}
}
else
{
if (info.WriteMode == SerializerWriteMode.WriteName)
{
jsonWriter.WritePropertyName(name.LocalName);
}
jsonWriter.WriteStartArray();
foreach (var itemValue in list)
{
Write(writer, itemValue, info.ModelName, settings, name, serializerData, null);
}
jsonWriter.WriteEndArray();
}
}
else
{
jsonWriter.WritePropertyName(name.LocalName);
Write(writer, value, info.ModelName, settings, name, serializerData, null);
}
}
private void CalcDefaultVersion()
{
if (fElements.Count == 0)
{
return;
}
string version = fElements.Min(item => item.Key);
fDefaultVersion = fElements[version];
}
public ObjectPropertyInfo Get(Type type)
{
ObjectElementAttribute attr = fConfigData[type];
if (attr == null)
{
return(null);
}
return(CreatePropertyInfo(attr));
}
public void WriteObjectElement(ObjectElementAttribute attribute, object writer,
object value, WriteSettings settings, ObjectPropertyInfo info, object serializerData)
{
var current = serializerData.Convert <XElement>();
XElement element = new XElement(info.QName.ToXName());
current.Add(element);
Write(writer, value, info.ModelName, settings, info.QName, element, null);
//InternalWriteXml(writer, value, settings, element, info.ModelName);
}
public void Add(ObjectElementAttribute attr, PropertyInfo info)
{
TkDebug.AssertNotNullOrEmpty(attr.LocalName, string.Format(ObjectUtil.SysCulture,
"属性{0}由于配置多个ObjectElement，因此需要指定LocalName", info.Name), attr);
TkDebug.AssertNotNull(attr.ObjectType, string.Format(ObjectUtil.SysCulture,
"属性{0}由于配置多个ObjectElement，因此需要指定LocalName", info.Name), attr);
QName name = attr.GetQName(attr.LocalName);
fXmlElements.Add(name, attr);
fLocalElements.Add(name.LocalName, attr);
fTypeElements.Add(attr.ObjectType, attr);
}
public void ReadObjectElement(ObjectElementAttribute attribute, object reader,
object receiver, ReadSettings settings, ObjectPropertyInfo info, object serializerData)
{
Type objectType = info.ObjectType;
object subObject = attribute.UseConstructor ? ObjectUtil.CreateObjectWithCtor(objectType)
: ObjectUtil.CreateObject(objectType);
Read(reader, subObject, info.ModelName, settings, info.QName, null);
SerializerUtil.SetParent(receiver, subObject);
SerializerUtil.AddElementValue(attribute, receiver, info, subObject);
}
public void WriteObjectElement(ObjectElementAttribute attribute, object writer,
object value, WriteSettings settings, ObjectPropertyInfo info, object serializerData)
{
PrefixTable prefixTable = serializerData.Convert <PrefixTable>();
Write(writer, value, info.ModelName, settings, info.QName, prefixTable, null);
//XmlWriter xmlWriter = writer.Convert<XmlWriter>();
//WriteStartElement(xmlWriter, info.QName, prefixTable);
//InternalWriteXml(writer, value, info.ModelName, settings, prefixTable);
//xmlWriter.WriteEndElement();
}
public void ReadDynamicDictionary(DynamicDictionaryAttribute attribute, object reader,
object receiver, ReadSettings settings, ObjectPropertyInfo info, object serializerData)
{
XmlReader xml = reader.Convert <XmlReader>();
QName name = info.QName;
IDictionary dict = attribute.GetDictionary(receiver, info);
if (xml.IsEmptyElement)
{
return;
}
var configData = attribute.PlugInFactory.ConfigData;
//var propertyInfo = info.Convert<ReflectorObjectPropertyInfo>().Property;
var elementReader = new ConfigFactoryElementReader(attribute, info, info.ModelName);
while (xml.Read())
{
if (xml.NodeType == XmlNodeType.EndElement)
{
QName nodeName = QName.Get(xml);
if (nodeName == name)
{
return;
}
}
if (xml.NodeType == XmlNodeType.Element)
{
QName nodeName = QName.Get(xml);
ObjectPropertyInfo subPropertyInfo;
if (elementReader.SupportVersion)
{
string version = xml.GetAttribute(ToolkitConst.VERSION);
subPropertyInfo = elementReader[nodeName, version];
}
else
{
subPropertyInfo = elementReader[nodeName];
}
if (subPropertyInfo != null)
{
ObjectElementAttribute elementAttr = subPropertyInfo.Attribute.Convert <ObjectElementAttribute>();
Type objectType = elementAttr.ObjectType;
object subObject = elementAttr.UseConstructor ? ObjectUtil.CreateObjectWithCtor(objectType)
: ObjectUtil.CreateObject(objectType);
Read(reader, subObject, info.ModelName, settings, nodeName, null);
SerializerUtil.SetParent(receiver, subObject);
dict[nodeName.LocalName] = subObject;
}
}
}
}
public CustomPropertyInfo CanRead(string localName, string version)
{
ObjectElementAttribute attr = fConfigData.GetObjectElementAttribute(localName, version);
if (attr != null)
{
fLocalName = localName;
fVersion = version;
return(new CustomPropertyInfo(attr.ObjectType, attr));
}
return(null);
}
public ObjectPropertyInfo this[string name]
{
get
{
ObjectElementAttribute attr = fConfigData[name];
if (attr == null)
{
return(null);
}
return(CreatePropertyInfo(attr));
}
}
public ObjectPropertyInfo this[QName name, string version]
{
get
{
ObjectElementAttribute attr = fConfigData.GetObjectElementAttribute(name, version);
if (attr == null)
{
return(null);
}
return(CreatePropertyInfo(attr));
}
}
public CustomPropertyInfo CanRead(string localName, string version)
{
if (fConfig.ContainsKey(localName))
{
var attr = new ObjectElementAttribute
{
ObjectType = fConfig[localName]
};
return(new CustomPropertyInfo(attr.ObjectType, attr));
}
return(null);
}
public void Add(BaseObjectElementAttribute baseAttr, ObjectElementAttribute attr, string defaultVersion)
{
string version = string.IsNullOrEmpty(baseAttr.Version) ? defaultVersion : baseAttr.Version;
if (!fElements.ContainsKey(version))
{
fElements.Add(version, attr);
if (defaultVersion == version && fDefaultVersion != null)
{
fDefaultVersion = attr;
}
}
}
public void Add(BaseXmlConfigFactory factory, string regName, BaseObjectElementAttribute attr, Type type)
{
ObjectElementAttribute objAttr = new ObjectElementAttribute(attr.NamespaceType)
{
LocalName = regName,
ObjectType = type,
UseConstructor = attr.UseConstructor
};
if (attr.NamespaceType == NamespaceType.Namespace)
{
objAttr.NamespaceUri = attr.NamespaceUri;
}
QName qName = objAttr.GetQName(objAttr.LocalName);
fXmlElements.Add(qName, objAttr);
fLocalElements.Add(qName.LocalName, objAttr);
fTypeElements.Add(type, objAttr);
}
internal ObjectElementAttribute ConvertTo(string localName, Type objectType,
DynamicElementAttribute dynamic)
{
ObjectElementAttribute attr = new ObjectElementAttribute(NamespaceType)
{
LocalName = localName,
ObjectType = objectType,
UseConstructor = UseConstructor,
Order = dynamic.Order,
IsMultiple = dynamic.IsMultiple,
CollectionType = dynamic.CollectionType
};
if (NamespaceType == NamespaceType.Namespace)
{
attr.NamespaceUri = NamespaceUri;
}
return(attr);
}
public void ReadDynamicDictionary(DynamicDictionaryAttribute attribute, object reader,
object receiver, ReadSettings settings, ObjectPropertyInfo info, object serializerData)
{
XElementData currentData = reader.Convert <XElementData>();
XElement current = currentData.Current;
IDictionary dict = attribute.GetDictionary(receiver, info);
var configData = attribute.PlugInFactory.ConfigData;
//var propertyInfo = info.Convert<ReflectorObjectPropertyInfo>().Property;
var elementReader = new ConfigFactoryElementReader(attribute, info, info.ModelName);
foreach (XElement child in current.Elements())
{
string nodeName = child.Name.LocalName;
QName qName = child.Name.ToQName();
ObjectPropertyInfo subPropertyInfo;
if (elementReader.SupportVersion)
{
var verAttr = child.Attribute(ToolkitConst.VERSION);
string version = verAttr != null ? verAttr.Value : string.Empty;
subPropertyInfo = elementReader[nodeName, version];
}
else
{
subPropertyInfo = elementReader[nodeName];
}
if (subPropertyInfo != null)
{
ObjectElementAttribute elementAttr = subPropertyInfo.Attribute.Convert <ObjectElementAttribute>();
Type objectType = elementAttr.ObjectType;
object subObject = elementAttr.UseConstructor ? ObjectUtil.CreateObjectWithCtor(objectType)
: ObjectUtil.CreateObject(objectType);
XElementData next = new XElementData {
Current = child, Root = currentData.Root
};
Read(next, subObject, info.ModelName, settings, QName.Get(nodeName), null);
SerializerUtil.SetParent(receiver, subObject);
dict[nodeName] = subObject;
}
}
}
private ObjectPropertyInfo CreatePropertyInfo(ObjectElementAttribute attr)
{
ObjectElementAttribute newAttr = new ObjectElementAttribute(attr.NamespaceType)
{
LocalName = attr.LocalName,
ObjectType = attr.ObjectType,
UseConstructor = attr.UseConstructor,
Order = fOrder,
IsMultiple = fMultiple,
CollectionType = fCollectionType,
UseJsonObject = fUseJsonObject
};
if (attr.NamespaceType == NamespaceType.Namespace)
{
newAttr.NamespaceUri = attr.NamespaceUri;
}
ObjectPropertyInfo result = fObjectInfo.Clone(newAttr); //new ReflectorObjectPropertyInfo(fInfo, newAttr, fModelName);
return(result);
}
public void ReadObjectElement(ObjectElementAttribute attribute, object reader, object receiver,
ReadSettings settings, ObjectPropertyInfo info, object serializerData)
{
if (attribute.IsMultiple)
{
throw new NotSupportedException();
}
string xml = GetValue(reader, info.LocalName);
if (string.IsNullOrEmpty(xml))
{
SerializerUtil.AddElementValue(attribute, receiver, info, null);
}
else
{
Type objectType = info.ObjectType;
object subObject = attribute.UseConstructor ? ObjectUtil.CreateObjectWithCtor(objectType)
: ObjectUtil.CreateObject(objectType);
subObject.ReadXml(xml, settings, QName.ToolkitNoNS);
SerializerUtil.AddElementValue(attribute, receiver, info, subObject);
SerializerUtil.SetParent(receiver, subObject);
}
}
private static SimpleElementAttribute GetElementAttribute(object receiver, Type valueType)
{
ITkTypeConverter converter = TkTypeDescriptor.GetSimpleConverter(valueType);
SimpleElementAttribute attr;
if (converter == null)
{
attr = new ObjectElementAttribute
{
ObjectType = valueType,
IsMultiple = true
}
}
;
else
{
attr = new SimpleElementAttribute
{
ObjectType = valueType,
IsMultiple = true
}
};
return(attr);
}
public void ReadObjectElement(ObjectElementAttribute attribute, object reader,
object receiver, ReadSettings settings, ObjectPropertyInfo info, object serializerData)
{
throw new NotSupportedException();
}
public void WriteObjectElement(ObjectElementAttribute attribute, object writer,
object value, WriteSettings settings, ObjectPropertyInfo info, object serializerData)
{
throw new NotImplementedException();
}
public void ReadObjectElement(ObjectElementAttribute attribute, object reader,
object receiver, ReadSettings settings, ObjectPropertyInfo info, object serializerData)
{
JsonTextReader jsonReader = reader.Convert <JsonTextReader>();
Type objectType = info.ObjectType;
// 考虑支持多层次Array读取，外层Object可能读取过，所以这里做判断对此进行屏蔽 2019.6.24
if (jsonReader.TokenType != JsonToken.StartArray)
{
AssertRead(jsonReader);
}
if (attribute.IsMultiple)
{
IList list = attribute.GetList(receiver, info);
if (attribute.UseJsonObject)
{
bool useArray = jsonReader.TokenType == JsonToken.StartArray;
if (useArray)
{
while (jsonReader.Read())
{
if (jsonReader.TokenType == JsonToken.EndArray)
{
break;
}
object subObject = ReadObject(attribute.UseConstructor, settings,
jsonReader, objectType, receiver, info.ModelName);
list.Add(subObject);
}
}
else
{
object subObject = ReadObject(attribute.UseConstructor, settings,
jsonReader, objectType, receiver, info.ModelName);
list.Add(subObject);
}
}
else
{
AssertReadState(jsonReader, JsonToken.StartArray, info.PropertyName);
while (jsonReader.Read())
{
if (jsonReader.TokenType == JsonToken.EndArray)
{
break;
}
object subObject = ReadObject(attribute.UseConstructor, settings,
jsonReader, objectType, receiver, info.ModelName);
list.Add(subObject);
}
}
}
else
{
AssertReadState(jsonReader, JsonToken.StartObject, info.PropertyName);
object subObject = ReadObject(attribute.UseConstructor, settings, jsonReader,
objectType, receiver, info.ModelName);
info.SetValue(receiver, subObject);
}
}
private ObjectPropertyInfo CreatePropertyInfo(ObjectElementAttribute attr)
{
ObjectPropertyInfo result = new ReflectorObjectPropertyInfo(fInfo, attr, fModelName);
return(result);
}
