internal static object InternalGetDefaultValue(Type type, string strValue, object defaultValue,
ReadSettings settings, bool throwException)
{
ITkTypeConverter converter = TkTypeDescriptor.GetConverter(type);
if (throwException)
{
TkDebug.AssertNotNull(converter, string.Format(ObjectUtil.SysCulture,
"无法获取类型{0}的TypeConverter，请确认是否为其配置TypeConverterAttribute",
type), null);
}
else
{
if (converter == null)
{
return(GetTypeDefaultValue(type));
}
}
try
{
return(strValue == null?InternalGetDefaultValue(type, defaultValue)
: converter.ConvertFromString(strValue, settings));
}
catch
{
return(InternalGetDefaultValue(type, defaultValue));
}
}
internal static void AssertTypeConverter(object sender, Type type,
ITkTypeConverter converter, string propertyName)
{
TkDebug.AssertNotNull(converter, string.Format(ObjectUtil.SysCulture,
"在分析属性{1}时出错：无法获取类型{0}的TypeConverter，请确认是否为其配置TkTypeConverterAttribute",
type, propertyName), sender);
}
public SimpleObjectPropertyInfo(object value, Type valueType,
SimpleElementAttribute attribute, ITkTypeConverter converter)
: base(attribute, null)
{
fValue = value;
fValueType = value.GetType();
fLocalName = attribute.LocalName;
Converter = converter;
}
public static object GetValue(object sender, Type type, string strValue,
object defaultValue, ReadSettings settings)
{
TkDebug.AssertArgumentNull(type, "type", sender);
ITkTypeConverter converter = TkTypeDescriptor.GetConverter(type);
AssertTypeConverter(sender, type, converter);
return(InternalGetValue(type, strValue, defaultValue, settings, converter));
}
private static void WriteDictionary(IDictionary dict, JsonWriter jsonWriter,
ITkTypeConverter converter, WriteSettings settings)
{
jsonWriter.WriteStartObject();
foreach (DictionaryEntry item in dict)
{
jsonWriter.WritePropertyName(item.Key.ToString());
jsonWriter.WriteValue(ObjectUtil.ToString(converter, item.Value, settings));
}
jsonWriter.WriteEndObject();
}
public static object GetPropertyObject(object receiver, ReadSettings settings,
ObjectPropertyInfo info, string value, Type objType)
{
ITkTypeConverter converter = info.Converter ?? TkTypeDescriptor.GetConverter(objType);
ObjectUtil.AssertTypeConverter(receiver, objType, converter, info.PropertyName);
object obj = ObjectUtil.InternalGetValue(objType, value, info.Attribute.DefaultValue,
settings, converter);
return(obj);
}
public static string ToString(object obj, WriteSettings settings)
{
if (obj == null)
{
return(string.Empty);
}
ITkTypeConverter converter = TkTypeDescriptor.GetConverter(obj.GetType());
if (converter != null)
{
return(converter.ConvertToString(obj, settings));
}
else
{
return(obj.ToString());
}
}
public static ITkTypeConverter GetConverter(Type type)
{
ITkTypeConverter result = GetSimpleConverter(type);
if (result != null)
{
return(result);
}
if (BaseGlobalVariable.Current != null)
{
result = BaseGlobalVariable.Current.GetExTypeConverter(type);
if (result != null)
{
return(result);
}
}
return(null);
}
private static object GetDefaultValue(Type type, object defaultValue,
ITkTypeConverter converter, ReadSettings settings)
{
if (defaultValue != null)
{
if (ObjectUtil.IsSubType(type, defaultValue.GetType()))
{
return(defaultValue);
}
else
{
try
{
string value = defaultValue.ToString();
return(converter.ConvertFromString(value, settings));
}
catch
{
return(null);
}
}
}
else
{
if (type.IsEnum)
{
return(GetFirstEnumValue(type));
}
else if (type.IsValueType)
{
return(ObjectUtil.CreateObject(type));
}
else
{
return(null);
}
}
}
public static ITkTypeConverter GetConverter(PropertyInfo property, Type propertyType)
{
TkDebug.AssertArgumentNull(property, "property", null);
TkDebug.AssertArgumentNull(propertyType, "propertyType", null);
Attribute attr = Attribute.GetCustomAttribute(property, typeof(TkTypeConverterAttribute));
if (attr != null)
{
return(attr.Convert <TkTypeConverterAttribute>().CreateTypeConverter(propertyType));
}
if (BaseGlobalVariable.Current != null)
{
ITkTypeConverter result = BaseGlobalVariable.Current.GetExTypeConverter(property);
if (result != null)
{
return(result);
}
}
return(null);
}
private static BaseDictionaryAttribute GetDictionaryAttribute(object receiver, QName root)
{
Type valueType = ObjectUtil.GetDictionaryValueType(receiver.GetType(), "", null);
ITkTypeConverter converter = TkTypeDescriptor.GetSimpleConverter(valueType);
BaseDictionaryAttribute attr;
if (converter == null)
{
attr = new ObjectDictionaryAttribute {
ObjectType = valueType
}
}
;
else
{
attr = new DictionaryAttribute {
ObjectType = valueType
}
};
attr.Assign(root);
return(attr);
}
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);
}
internal static object InternalGetValue(Type type, string strValue,
object defaultValue, ReadSettings settings, ITkTypeConverter converter)
{
try
{
return(strValue == null?GetDefaultValue(type, defaultValue, converter, settings)
: converter.ConvertFromString(strValue, settings));
}
catch
{
return(GetDefaultValue(type, defaultValue, converter, settings));
}
}
public NullableConverter(ITkTypeConverter converter)
{
TkDebug.AssertArgumentNull(converter, "converter", null);
fConverter = converter;
}
public CustomPropertyInfo(Type dataType, NamedAttribute attribute, ITkTypeConverter converter)
: this(dataType, attribute)
{
Converter = converter;
}
public static void WriteObject(IObjectSerializer serializer, object writer,
object receiver, string modelName, WriteSettings settings, QName root,
BaseObjectAttribute attribute, object serializerData, SerializerOptions options)
{
Type type = receiver.GetType();
if (receiver is IDictionary)
{
BaseDictionaryAttribute attr = attribute as BaseDictionaryAttribute;
options.CheckWriteDictionary(serializer, attr);
if (attr == null)
{
attr = GetDictionaryAttribute(receiver, root);
}
serializer.WriteDictionary(writer, receiver.Convert <IDictionary>(), attr,
modelName, settings, root, serializerData);
}
else if (type.IsArray || receiver is IList)
{
SimpleElementAttribute attr = attribute as SimpleElementAttribute;
options.CheckWriteList(serializer, attr);
if (attr == null)
{
Type valueType;
if (type.IsArray)
{
Array arr = receiver as Array;
if (arr.Length == 0)
{
return;
}
var enumerator = arr.GetEnumerator();
enumerator.MoveNext();
valueType = enumerator.Current.GetType();
}
else
{
valueType = ObjectUtil.GetListValueType(type, "", null);
}
attr = GetElementAttribute(receiver, valueType);
}
serializer.WriteList(writer, receiver.Convert <IEnumerable>(), attr,
modelName, settings, root, serializerData);
}
else
{
options.CheckWriteObject(serializer);
ITkTypeConverter converter = TkTypeDescriptor.GetSimpleConverter(type);
if (converter != null)
{
SimpleElementAttribute simpleAttr = new SimpleElementAttribute
{
LocalName = root.LocalName,
NamespaceUri = root.Namespace
};
var info = new SimpleObjectPropertyInfo(receiver, type, simpleAttr, converter);
serializer.WriteElement(simpleAttr, writer, receiver, settings, info, serializerData);
}
else
{
serializer.WriteObject(writer, receiver, modelName, settings, root, serializerData);
}
}
}
