public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
var value = valueReader.DirectRead();
if (value is T tValue)
{
return(tValue);
}
var reader = RWHelper.CreateReader(value);
if (reader is T tResult)
{
return(tResult);
}
if (reader != null && reader.As <TKey>() is T tResult2)
{
return(tResult2);
}
return(XConvert <T> .FromObject(value));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
if (valueReader is IValueReader <System.Reflection.Assembly> assemblyReader)
{
return((T)assemblyReader.ReadValue());
}
var value = valueReader.DirectRead();
if (value == null)
{
return(null);
}
if (value is T tValue)
{
return(tValue);
}
if (value is string sValue)
{
return((T)System.Reflection.Assembly.Load(sValue));
}
throw new NotSupportedException(StringHelper.Format("Cannot Read a 'Assembly' by '{0}'.", value.ToString()));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
if (valueReader is IValueReader <Type> typeReader)
{
return((T)typeReader.ReadValue());
}
var value = valueReader.DirectRead();
if (value == null)
{
return(null);
}
if (value is T tValue)
{
return(tValue);
}
if (value is string sValue)
{
return((T)Type.GetType(sValue));
}
throw new NotSupportedException(StringHelper.Format("Cannot Read a 'TypeInfo' by '{0}'.", value.ToString()));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> )
{
return(((IValueReader <T>)valueReader).ReadValue());
}
return(XConvert.FromObject <T>(valueReader.DirectRead()));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> )
{
return(((IValueReader <T>)valueReader).ReadValue());
}
return(DConvert <T> .Convert(valueReader.DirectRead()));
}
public T ReadValue(IValueReader valueReader)
{
var value = valueReader.DirectRead();
if (value is T tValue)
{
return(tValue);
}
throw new NotSupportedException(StringHelper.Format("Cannot read a '{0}', It is a data reader.", typeof(T).Name));
}
public DBNull ReadValue(IValueReader valueReader)
{
var value = valueReader.DirectRead();
if (value == null || value == DBNull.Value)
{
return(DBNull.Value);
}
throw new NotSupportedException("Unable convert value to DbNull.");
}
public void OnWriteValue(string key, IValueReader valueReader)
{
DataColumn column;
if (DataRow != null && (column = DataRow.Table.Columns[key]) != null && column.DataType != typeof(object))
{
DataRow[column] = ValueInterface.GetInterface(column.DataType).Read(valueReader);
return;
}
Items.Add(new KeyValuePair <string, object>(key, valueReader.DirectRead()));
}
public ValueCopyer ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <ValueCopyer> reader)
{
return(reader.ReadValue());
}
var valueCopyer = new ValueCopyer();
var value = valueReader.DirectRead();
ValueInterface.WriteValue(valueCopyer, value);
return(valueCopyer);
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> )
{
return(((IValueReader <T>)valueReader).ReadValue());
}
var directValue = valueReader.DirectRead();
if (directValue is T || directValue == null)
{
return((T)directValue);
}
return(XConvert.FromObject <T>(directValue));
}
public TimeSpan ReadValue(IValueReader valueReader)
{
object directValue = valueReader.DirectRead();
if (directValue is TimeSpan)
{
return((TimeSpan)directValue);
}
if (directValue is string)
{
return(TimeSpan.Parse((string)directValue));
}
return(DConvert <TimeSpan> .Convert(directValue));
}
public T?ReadValue(IValueReader valueReader)
{
if (valueReader.GetBasicType() == BasicTypes.Null)
{
var directValue = valueReader.DirectRead();
if (directValue == null)
{
return(null);
}
return(DConvert <T> .Convert(directValue));
}
return(ValueInterface <T> .Content.ReadValue(valueReader));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
var value = valueReader.DirectRead();
if (value is string st)
{
return((T)Enum.Parse(EnumType, valueReader.ReadString()));
}
return((T)Enum.ToObject(EnumType, value));
}
public TTask ReadValue(IValueReader valueReader)
{
var task = Run();
if (task is TTask ret)
{
return(ret);
}
return(XConvert <TTask> .FromObject(task));
async Task Run()
{
valueReader.DirectRead();
}
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> )
{
return(((IValueReader <T>)valueReader).ReadValue());
}
object directValue = valueReader.DirectRead();
if (directValue is T || directValue == null)
{
return((T)directValue);
}
return(DConvert <T> .Convert(directValue));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
if (valueReader is IValueFiller <TKey> tFiller &&
typeof(IDataWriter <TKey>).IsAssignableFrom(typeof(T)))
{
T instance = default(T);
try
{
instance = Activator.CreateInstance <T>();;
}
catch (Exception)
{
goto Direct;
}
tFiller.FillValue((IDataWriter <TKey>)instance);
return(instance);
}
Direct:
var value = valueReader.DirectRead();
if (value is T tValue)
{
return(tValue);
}
var reader = RWHelper.CreateReader(value);
if (reader is T tResult)
{
return(tResult);
}
throw new NotSupportedException(StringHelper.Format("Cannot read a '{0}', It is a data {1}.", typeof(T).Name, "reader"));
}
public TimeSpan ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <TimeSpan> timeSpanReader)
{
return(timeSpanReader.ReadValue());
}
object directValue = valueReader.DirectRead();
if (directValue is TimeSpan)
{
return((TimeSpan)directValue);
}
if (directValue is string)
{
return(TimeSpan.Parse((string)directValue));
}
return(XConvert.FromObject <TimeSpan>(directValue));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
if (valueReader is IValueReader <Type> typeReader)
{
return((T)typeReader.ReadValue());
}
var value = valueReader.DirectRead();
if (value is string typeName && Type.GetType(typeName) is T result)
{
return(result);
}
return(XConvert <T> .FromObject(value));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> )
{
return(((IValueReader <T>)valueReader).ReadValue());
}
var value = valueReader.DirectRead();
if (value is T ret)
{
return(ret);
}
if (value is null)
{
return((T)(object)null);
}
return(XConvert.FromObject <T>(value));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
if (valueReader is IValueReader <Assembly> assemblyReader)
{
return((T)assemblyReader.ReadValue());
}
var value = valueReader.DirectRead();
if (value is string sssemblyString && Assembly.Load(sssemblyString) is T result)
{
return(result);
}
return(XConvert <T> .FromObject(value));
}
public DateTimeOffset ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <DateTimeOffset> dateTimeOffsetReader)
{
return(dateTimeOffsetReader.ReadValue());
}
object directValue = valueReader.DirectRead();
if (directValue is DateTimeOffset)
{
return((DateTimeOffset)directValue);
}
if (directValue is string)
{
return(DateTimeOffset.Parse((string)directValue));
}
return(DConvert <DateTimeOffset> .Convert(directValue));
}
/// <summary>
/// 将数据读取器中的值设置到指定名称的成员中。
/// </summary>
/// <param name="key">成员的名称</param>
/// <param name="valueReader">值读取器</param>
public void OnWriteValue(string key, IValueReader valueReader)
{
if (xTypeInfo.rwFields.TryGetValue(key, out var field))
{
if (field.CanWrite)
{
field.OnWriteValue(obj, valueReader);
}
else if (field.CannotSetException)
{
throw new MissingMethodException($"Property '{xTypeInfo.type.Name}.{key}' No define '{"set"}' method or cannot access.");
}
}
else if ((xTypeInfo.flags & XBindingFlags.RWNotFoundException) != 0)
{
throw new MissingMemberException(xTypeInfo.type.Name, key);
}
else
{
valueReader.DirectRead();
}
}
/// <summary>
/// 将数据读取器中的值设置到指定名称的成员中。
/// </summary>
/// <param name="key">成员的名称</param>
/// <param name="valueReader">值读取器</param>
public void OnWriteValue(string key, IValueReader valueReader)
{
if (fields.TryGetValue(key, out var field))
{
if (field.CanWrite)
{
field.OnWriteValue(this, valueReader);
return;
}
else if ((flags & XBindingFlags.RWCannotSetException) != 0)
{
throw new MissingMethodException(StringHelper.Format("Property '{0}.{1}' No define '{2}' method or cannot access.", Type.Name, key, "set"));
}
}
else if ((flags & XBindingFlags.RWNoFoundException) != 0)
{
throw new MissingMemberException(Type.Name, key);
}
valueReader.DirectRead();
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
var value = valueReader.DirectRead();
if (value is T tValue)
{
return(tValue);
}
var reader = RWHelper.CreateReader(value);
if (reader is T tResult)
{
return(tResult);
}
throw new NotSupportedException($"Cannot read a '{typeof(T).Name}', It is a data {"reader"}.");
}
public void OnWriteValue(string key, IValueReader valueReader)
{
var dataColumn = Content.Table.Columns[key];
if (dataColumn == null)
{
var type = typeof(object);
var value = valueReader.DirectRead();
if (value != null)
{
type = value.GetType();
}
dataColumn = Content.Table.Columns.Add(key, type);
Content[dataColumn.Ordinal] = value;
return;
}
Content[dataColumn.Ordinal] = ValueInterface.GetInterface(dataColumn.DataType).Read(valueReader);
}
public void OnWriteValue(TKey key, IValueReader valueReader)
{
this[key].DirectWrite(valueReader.DirectRead());
}
public object ReadValue(IValueReader valueReader)
{
return(valueReader.DirectRead());
}
public void OnWriteValue(int key, IValueReader valueReader)
{
ValueInterface.WriteValue(this[key], valueReader.DirectRead());
}
public JsonValue ReadValue(IValueReader valueReader)
{
return(new JsonValue(valueReader.DirectRead()));
}
public T ReadValue(IValueReader valueReader)
{
if (valueReader is IValueReader <T> tReader)
{
return(tReader.ReadValue());
}
if (IsAssignableToMethodInfo && valueReader is IValueReader <MethodInfo> methodReader)
{
return((T)(object)methodReader.ReadValue());
}
if (IsAssignableToFieldInfo && valueReader is IValueReader <MethodInfo> fieldReader)
{
return((T)(object)fieldReader.ReadValue());
}
if (IsAssignableToPropertyInfo && valueReader is IValueReader <PropertyInfo> propertyReader)
{
return((T)(object)propertyReader.ReadValue());
}
if (IsAssignableToConstructorInfo && valueReader is IValueReader <ConstructorInfo> constructorReader)
{
return((T)(object)constructorReader.ReadValue());
}
if (IsAssignableToEventInfo && valueReader is IValueReader <EventInfo> eventReader)
{
return((T)(object)eventReader.ReadValue());
}
var value = valueReader.DirectRead();
if (value is null)
{
return(null);
}
if (RWHelper.CreateReader(value, false) is IDataReader <string> infoReader)
{
var declaringType = ValueInterface <Type> .ReadValue(infoReader["DeclaringType"]);
var name = ValueInterface <string> .ReadValue(infoReader["Name"]);
if (name == ConstructorName || IsAssignableToConstructorInfo)
{
var parameterTypes = ValueInterface <Type[]> .ReadValue(infoReader["ParameterTypes"]);
var constructor = declaringType.GetConstructor(parameterTypes);
if (constructor != null && constructor is T ret)
{
return(ret);
}
}
else if (name == IndexerName)
{
var parameterTypes = ValueInterface <Type[]> .ReadValue(infoReader["ParameterTypes"]);
var propertyType = ValueInterface <Type> .ReadValue(infoReader["PropertyType"]);
var indexer = declaringType.GetProperty(parameterTypes);
if (indexer != null && indexer.PropertyType == propertyType && indexer is T ret)
{
return(ret);
}
}
else if (IsAssignableToFieldInfo)
{
var fieldType = ValueInterface <Type> .ReadValue(infoReader["FieldType"]);
var field = declaringType.GetField(name);
if (field != null && field.FieldType == fieldType && field is T ret)
{
return(ret);
}
}
else if (IsAssignableToPropertyInfo)
{
var propertyType = ValueInterface <Type> .ReadValue(infoReader["PropertyType"]);
var property = declaringType.GetProperty(name);
if (property != null && property.PropertyType == propertyType && property is T ret)
{
return(ret);
}
}
else if (IsAssignableToEventInfo)
{
var eventHandlerType = ValueInterface <Type> .ReadValue(infoReader["EventHandlerType"]);
var @event = declaringType.GetEvent(name);
if (@event != null && @event.EventHandlerType == eventHandlerType && @event is T ret)
{
return(ret);
}
}
else if (IsAssignableToMethodInfo)
{
goto Method;
}
else
{
var member = declaringType.GetMember(name, Flags);
if (member.Length > 0)
{
switch (member[0].MemberType)
{
case MemberTypes.Event:
{
var eventHandlerType = ValueInterface <Type> .ReadValue(infoReader["EventHandlerType"]);
if (member[0] is EventInfo @event && @event.EventHandlerType == eventHandlerType && @event is T ret)
{
return(ret);
}
}
break;
case MemberTypes.Field:
{
var fieldType = ValueInterface <Type> .ReadValue(infoReader["FieldType"]);
if (member[0] is FieldInfo field && field.FieldType == fieldType && field is T ret)
{
return(ret);
}
}
break;
case MemberTypes.Property:
{
var propertyType = ValueInterface <Type> .ReadValue(infoReader["PropertyType"]);
if (member[0] is PropertyInfo property && property.PropertyType == propertyType && property is T ret)
{
return(ret);
}
}
break;
case MemberTypes.Method:
goto Method;
default:
throw new NotSupportedException();
}
}
}
NoFound:
throw new MissingMemberException(declaringType.FullName, name);
Method:
{
var parameterTypes = ValueInterface <Type[]> .ReadValue(infoReader["ParameterTypes"]);
var returnType = ValueInterface <Type> .ReadValue(infoReader["ReturnType"]);
var method = declaringType.GetMethod(name, Flags, Type.DefaultBinder, parameterTypes, null);
if (method != null && method.ReturnType == returnType && method is T ret)
{
return(ret);
}
goto NoFound;
}
}
if (value is string memberName)
{
try
{
if (Type.GetType(memberName) is T ret)
{
return(ret);
}
}
catch
{
}
}
return(XConvert <T> .FromObject(value));
}
