public static ReflectionObject Create(Type t, MethodBase?creator, params string[] memberNames)
{
ReflectionDelegateFactory delegateFactory = JsonTypeReflector.ReflectionDelegateFactory;
ObjectConstructor <object>?creatorConstructor = null;
if (creator != null)
{
creatorConstructor = delegateFactory.CreateParameterizedConstructor(creator);
}
else
{
if (ReflectionUtils.HasDefaultConstructor(t, false))
{
Newtonsoft.Json.Serialization.Func <object> ctor = delegateFactory.CreateDefaultConstructor <object>(t);
creatorConstructor = args => ctor();
}
}
ReflectionObject d = new ReflectionObject(creatorConstructor);
foreach (string memberName in memberNames)
{
MemberInfo[] members = t.GetMember(memberName, BindingFlags.Instance | BindingFlags.Public);
if (members.Length != 1)
{
throw new ArgumentException("Expected a single member with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, memberName));
}
MemberInfo member = members.Single();
ReflectionMember reflectionMember = new ReflectionMember();
switch (member.MemberType())
{
case MemberTypes.Field:
case MemberTypes.Property:
if (ReflectionUtils.CanReadMemberValue(member, false))
{
reflectionMember.Getter = delegateFactory.CreateGet <object>(member);
}
if (ReflectionUtils.CanSetMemberValue(member, false, false))
{
reflectionMember.Setter = delegateFactory.CreateSet <object>(member);
}
break;
case MemberTypes.Method:
MethodInfo method = (MethodInfo)member;
if (method.IsPublic)
{
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length == 0 && method.ReturnType != typeof(void))
{
MethodCall <object, object?> call = delegateFactory.CreateMethodCall <object>(method);
reflectionMember.Getter = target => call(target);
}
else if (parameters.Length == 1 && method.ReturnType == typeof(void))
{
MethodCall <object, object?> call = delegateFactory.CreateMethodCall <object>(method);
reflectionMember.Setter = (target, arg) => call(target, arg);
}
}
break;
default:
throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".FormatWith(CultureInfo.InvariantCulture, member.MemberType(), member.Name));
}
reflectionMember.MemberType = ReflectionUtils.GetMemberUnderlyingType(member);
d.Members[memberName] = reflectionMember;
}
return(d);
}
/// <summary>
/// Converts the value to the specified type.
/// </summary>
/// <param name="initialValue">The value to convert.</param>
/// <param name="culture">The culture to use when converting.</param>
/// <param name="targetType">The type to convert the value to.</param>
/// <returns>The converted type.</returns>
public static object Convert(object initialValue, CultureInfo culture, Type targetType)
{
if (initialValue == null)
{
throw new ArgumentNullException("initialValue");
}
if (ReflectionUtils.IsNullableType(targetType))
{
targetType = Nullable.GetUnderlyingType(targetType);
}
Type initialType = initialValue.GetType();
if (targetType == initialType)
{
return(initialValue);
}
// use Convert.ChangeType if both types are IConvertible
if (ConvertUtils.IsConvertible(initialValue.GetType()) && ConvertUtils.IsConvertible(targetType))
{
if (targetType.IsEnum())
{
if (initialValue is string)
{
return(Enum.Parse(targetType, initialValue.ToString(), true));
}
else if (IsInteger(initialValue))
{
return(Enum.ToObject(targetType, initialValue));
}
}
return(System.Convert.ChangeType(initialValue, targetType, culture));
}
#if !NET20
if (initialValue is DateTime && targetType == typeof(DateTimeOffset))
{
return(new DateTimeOffset((DateTime)initialValue));
}
#endif
if (initialValue is byte[] && targetType == typeof(Guid))
{
return(new Guid((byte[])initialValue));
}
if (initialValue is string)
{
if (targetType == typeof(Guid))
{
return(new Guid((string)initialValue));
}
if (targetType == typeof(Uri))
{
return(new Uri((string)initialValue, UriKind.RelativeOrAbsolute));
}
if (targetType == typeof(TimeSpan))
{
return(ParseTimeSpan((string)initialValue));
}
if (typeof(Type).IsAssignableFrom(targetType))
{
return(Type.GetType((string)initialValue, true));
}
}
#if !(NET20 || NET35 || SILVERLIGHT || PORTABLE40 || PORTABLE)
if (targetType == typeof(BigInteger))
{
return(ToBigInteger(initialValue));
}
if (initialValue is BigInteger)
{
return(FromBigInteger((BigInteger)initialValue, targetType));
}
#endif
if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract())
{
throw new ArgumentException("Target type {0} is not a value type or a non-abstract class.".FormatWith(CultureInfo.InvariantCulture, targetType), "targetType");
}
#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
// see if source or target types have a TypeConverter that converts between the two
TypeConverter toConverter = GetConverter(initialType);
if (toConverter != null && toConverter.CanConvertTo(targetType))
{
#if !SILVERLIGHT
return(toConverter.ConvertTo(null, culture, initialValue, targetType));
#else
return(toConverter.ConvertTo(initialValue, targetType));
#endif
}
TypeConverter fromConverter = GetConverter(targetType);
if (fromConverter != null && fromConverter.CanConvertFrom(initialType))
{
#if !SILVERLIGHT
return(fromConverter.ConvertFrom(null, culture, initialValue));
#else
return(fromConverter.ConvertFrom(initialValue));
#endif
}
#endif
#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
// handle DBNull and INullable
if (initialValue == DBNull.Value)
{
if (ReflectionUtils.IsNullable(targetType))
{
return(EnsureTypeAssignable(null, initialType, targetType));
}
throw new Exception("Can not convert null {0} into non-nullable {1}.".FormatWith(CultureInfo.InvariantCulture, initialType, targetType));
}
#endif
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE40 || PORTABLE)
if (initialValue is INullable)
{
return(EnsureTypeAssignable(ToValue((INullable)initialValue), initialType, targetType));
}
#endif
throw new InvalidOperationException("Can not convert from {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, initialType, targetType));
}
// Token: 0x06000E46 RID: 3654 RVA: 0x00010D08 File Offset: 0x0000EF08
public static bool IsDictionaryType(Type type)
{
ValidationUtils.ArgumentNotNull(type, "type");
return(typeof(IDictionary).IsAssignableFrom(type) || ReflectionUtils.ImplementsGenericDefinition(type, typeof(IDictionary <, >)));
}
public static ReflectionObject Create(Type t, MethodBase creator, params string[] memberNames)
{
MemberInfo memberInfo;
ReflectionMember reflectionMember;
MemberTypes memberType;
ReflectionObject reflectionObject = new ReflectionObject();
ReflectionDelegateFactory reflectionDelegateFactory = JsonTypeReflector.ReflectionDelegateFactory;
if (creator != null)
{
reflectionObject.Creator = reflectionDelegateFactory.CreateParameterizedConstructor(creator);
}
else if (ReflectionUtils.HasDefaultConstructor(t, false))
{
Func <object> func = reflectionDelegateFactory.CreateDefaultConstructor <object>(t);
reflectionObject.Creator = (object[] args) => func();
}
string[] strArrays = memberNames;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
MemberInfo[] member = t.GetMember(str, BindingFlags.Instance | BindingFlags.Public);
if ((int)member.Length != 1)
{
throw new ArgumentException("Expected a single member with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, str));
}
memberInfo = ((IEnumerable <MemberInfo>)member).Single <MemberInfo>();
reflectionMember = new ReflectionMember();
memberType = memberInfo.MemberType();
if (memberType != MemberTypes.Field)
{
if (memberType != MemberTypes.Method)
{
goto Label1;
}
MethodInfo methodInfo = (MethodInfo)memberInfo;
if (methodInfo.IsPublic)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length == 0 && methodInfo.ReturnType != typeof(void))
{
MethodCall <object, object> methodCall = reflectionDelegateFactory.CreateMethodCall <object>(methodInfo);
reflectionMember.Getter = (object target) => methodCall(target, new object[0]);
}
else if ((int)parameters.Length == 1 && methodInfo.ReturnType == typeof(void))
{
MethodCall <object, object> methodCall1 = reflectionDelegateFactory.CreateMethodCall <object>(methodInfo);
reflectionMember.Setter = (object target, object arg) => methodCall1(target, new object[] { arg });
}
}
}
else
{
goto Label0;
}
Label2:
if (ReflectionUtils.CanReadMemberValue(memberInfo, false))
{
reflectionMember.Getter = reflectionDelegateFactory.CreateGet <object>(memberInfo);
}
if (ReflectionUtils.CanSetMemberValue(memberInfo, false, false))
{
reflectionMember.Setter = reflectionDelegateFactory.CreateSet <object>(memberInfo);
}
reflectionMember.MemberType = ReflectionUtils.GetMemberUnderlyingType(memberInfo);
reflectionObject.Members[str] = reflectionMember;
}
return(reflectionObject);
Label0:
if (ReflectionUtils.CanReadMemberValue(memberInfo, false))
{
reflectionMember.Getter = reflectionDelegateFactory.CreateGet <object>(memberInfo);
}
if (ReflectionUtils.CanSetMemberValue(memberInfo, false, false))
{
reflectionMember.Setter = reflectionDelegateFactory.CreateSet <object>(memberInfo);
goto Label2;
}
else
{
goto Label2;
}
Label1:
if (memberType != MemberTypes.Property)
{
throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".FormatWith(CultureInfo.InvariantCulture, memberInfo.MemberType(), memberInfo.Name));
}
else
{
goto Label0;
}
}
public static object Convert(object initialValue, CultureInfo culture, Type targetType)
{
if (initialValue == null)
{
throw new ArgumentNullException("initialValue");
}
if (ReflectionUtils.IsNullableType(targetType))
{
targetType = Nullable.GetUnderlyingType(targetType);
}
Type type = initialValue.GetType();
if (targetType == type)
{
return(initialValue);
}
if (initialValue is string && typeof(Type).IsAssignableFrom(targetType))
{
return(Type.GetType((string)initialValue, true));
}
if (targetType.get_IsInterface() || targetType.get_IsGenericTypeDefinition() || targetType.get_IsAbstract())
{
throw new ArgumentException("Target type {0} is not a value type or a non-abstract class.".FormatWith(CultureInfo.get_InvariantCulture(), new object[]
{
targetType
}), "targetType");
}
if (initialValue is IConvertible && typeof(IConvertible).IsAssignableFrom(targetType))
{
if (targetType.get_IsEnum())
{
if (initialValue is string)
{
return(Enum.Parse(targetType, initialValue.ToString(), true));
}
if (ConvertUtils.IsInteger(initialValue))
{
return(Enum.ToObject(targetType, initialValue));
}
}
return(System.Convert.ChangeType(initialValue, targetType, culture));
}
if (initialValue is DateTime && targetType == typeof(DateTimeOffset))
{
return(new DateTimeOffset((DateTime)initialValue));
}
if (initialValue is string)
{
if (targetType == typeof(Guid))
{
return(new Guid((string)initialValue));
}
if (targetType == typeof(Uri))
{
return(new Uri((string)initialValue));
}
if (targetType == typeof(TimeSpan))
{
return(TimeSpan.Parse((string)initialValue));
}
}
TypeConverter converter = ConvertUtils.GetConverter(type);
if (converter != null && converter.CanConvertTo(targetType))
{
return(converter.ConvertTo(null, culture, initialValue, targetType));
}
TypeConverter converter2 = ConvertUtils.GetConverter(targetType);
if (converter2 != null && converter2.CanConvertFrom(type))
{
return(converter2.ConvertFrom(null, culture, initialValue));
}
if (initialValue != DBNull.Value)
{
throw new Exception("Can not convert from {0} to {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[]
{
type,
targetType
}));
}
if (ReflectionUtils.IsNullable(targetType))
{
return(ConvertUtils.EnsureTypeAssignable(null, type, targetType));
}
throw new Exception("Can not convert null {0} into non-nullable {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[]
{
type,
targetType
}));
}
public static bool CanConvertType(Type initialType, Type targetType, bool allowTypeNameToString)
{
ValidationUtils.ArgumentNotNull(initialType, "initialType");
ValidationUtils.ArgumentNotNull(targetType, "targetType");
if (ReflectionUtils.IsNullableType(targetType))
{
targetType = Nullable.GetUnderlyingType(targetType);
}
if (targetType == initialType)
{
return(true);
}
if (typeof(IConvertible).IsAssignableFrom(initialType) && typeof(IConvertible).IsAssignableFrom(targetType))
{
return(true);
}
if (initialType == typeof(DateTime) && targetType == typeof(DateTimeOffset))
{
return(true);
}
if (initialType == typeof(Guid) && (targetType == typeof(Guid) || targetType == typeof(string)))
{
return(true);
}
if (initialType == typeof(Type) && targetType == typeof(string))
{
return(true);
}
TypeConverter converter = ConvertUtils.GetConverter(initialType);
if (converter != null && !ConvertUtils.IsComponentConverter(converter) && converter.CanConvertTo(targetType) && (allowTypeNameToString || converter.GetType() != typeof(TypeConverter)))
{
return(true);
}
TypeConverter converter2 = ConvertUtils.GetConverter(targetType);
return((converter2 != null && !ConvertUtils.IsComponentConverter(converter2) && converter2.CanConvertFrom(initialType)) || (initialType == typeof(DBNull) && ReflectionUtils.IsNullable(targetType)));
}
private bool IsOverridden(string method)
{
return(ReflectionUtils.IsMethodOverridden(_proxy.GetType(), typeof(DynamicProxy <T>), method));
}
public static object CreateGeneric(Type genericTypeDefinition, IList <Type> innerTypes, params object[] args)
{
return(CreateGeneric(genericTypeDefinition, innerTypes, (t, a) => ReflectionUtils.CreateInstance(t, a.ToArray()), args));
}
private static ConvertResult TryConvertInternal(object initialValue, CultureInfo culture, Type targetType, out object value)
{
if (initialValue == null)
throw new ArgumentNullException("initialValue");
if (ReflectionUtils.IsNullableType(targetType))
targetType = Nullable.GetUnderlyingType(targetType);
Type initialType = initialValue.GetType();
if (targetType == initialType)
{
value = initialValue;
return ConvertResult.Success;
}
// use Convert.ChangeType if both types are IConvertible
if (ConvertUtils.IsConvertible(initialValue.GetType()) && ConvertUtils.IsConvertible(targetType))
{
if (targetType.IsEnum())
{
if (initialValue is string)
{
value = Enum.Parse(targetType, initialValue.ToString(), true);
return ConvertResult.Success;
}
else if (IsInteger(initialValue))
{
value = Enum.ToObject(targetType, initialValue);
return ConvertResult.Success;
}
}
value = System.Convert.ChangeType(initialValue, targetType, culture);
return ConvertResult.Success;
}
#if !NET20
if (initialValue is DateTime && targetType == typeof(DateTimeOffset))
{
value = new DateTimeOffset((DateTime)initialValue);
return ConvertResult.Success;
}
#endif
if (initialValue is byte[] && targetType == typeof(Guid))
{
value = new Guid((byte[])initialValue);
return ConvertResult.Success;
}
if (initialValue is Guid && targetType == typeof(byte[]))
{
value = ((Guid)initialValue).ToByteArray();
return ConvertResult.Success;
}
if (initialValue is string)
{
if (targetType == typeof(Guid))
{
value = new Guid((string)initialValue);
return ConvertResult.Success;
}
if (targetType == typeof(Uri))
{
value = new Uri((string)initialValue, UriKind.RelativeOrAbsolute);
return ConvertResult.Success;
}
if (targetType == typeof(TimeSpan))
{
value = ParseTimeSpan((string)initialValue);
return ConvertResult.Success;
}
if (targetType == typeof(byte[]))
{
value = System.Convert.FromBase64String((string)initialValue);
return ConvertResult.Success;
}
if (typeof(Type).IsAssignableFrom(targetType))
{
value = Type.GetType((string)initialValue, true);
return ConvertResult.Success;
}
}
#if !(NET20 || NET35 || PORTABLE40 || PORTABLE)
if (targetType == typeof(BigInteger))
{
value = ToBigInteger(initialValue);
return ConvertResult.Success;
}
if (initialValue is BigInteger)
{
value = FromBigInteger((BigInteger)initialValue, targetType);
return ConvertResult.Success;
}
#endif
#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
// see if source or target types have a TypeConverter that converts between the two
TypeConverter toConverter = GetConverter(initialType);
if (toConverter != null && toConverter.CanConvertTo(targetType))
{
value = toConverter.ConvertTo(null, culture, initialValue, targetType);
return ConvertResult.Success;
}
TypeConverter fromConverter = GetConverter(targetType);
if (fromConverter != null && fromConverter.CanConvertFrom(initialType))
{
value = fromConverter.ConvertFrom(null, culture, initialValue);
return ConvertResult.Success;
}
#endif
#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
// handle DBNull and INullable
if (initialValue == DBNull.Value)
{
if (ReflectionUtils.IsNullable(targetType))
{
value = EnsureTypeAssignable(null, initialType, targetType);
return ConvertResult.Success;
}
// cannot convert null to non-nullable
value = null;
return ConvertResult.CannotConvertNull;
}
#endif
#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
if (initialValue is INullable)
{
value = EnsureTypeAssignable(ToValue((INullable)initialValue), initialType, targetType);
return ConvertResult.Success;
}
#endif
if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract())
{
value = null;
return ConvertResult.NotInstantiableType;
}
value = null;
return ConvertResult.NoValidConversion;
}
public static ReflectionObject Create(
Type t,
MethodBase creator,
params string[] memberNames)
{
ReflectionObject reflectionObject = new ReflectionObject();
ReflectionDelegateFactory reflectionDelegateFactory = JsonTypeReflector.ReflectionDelegateFactory;
if (creator != null)
{
reflectionObject.Creator = reflectionDelegateFactory.CreateParameterizedConstructor(creator);
}
else if (ReflectionUtils.HasDefaultConstructor(t, false))
{
Func <object> ctor = reflectionDelegateFactory.CreateDefaultConstructor <object>(t);
reflectionObject.Creator = (ObjectConstructor <object>)(args => ctor());
}
foreach (string memberName in memberNames)
{
MemberInfo[] member = t.GetMember(memberName, BindingFlags.Instance | BindingFlags.Public);
if (member.Length != 1)
{
throw new ArgumentException("Expected a single member with the name '{0}'.".FormatWith((IFormatProvider)CultureInfo.InvariantCulture, (object)memberName));
}
MemberInfo memberInfo = ((IEnumerable <MemberInfo>)member).Single <MemberInfo>();
ReflectionMember reflectionMember = new ReflectionMember();
switch (memberInfo.MemberType())
{
case MemberTypes.Field:
case MemberTypes.Property:
if (ReflectionUtils.CanReadMemberValue(memberInfo, false))
{
reflectionMember.Getter = reflectionDelegateFactory.CreateGet <object>(memberInfo);
}
if (ReflectionUtils.CanSetMemberValue(memberInfo, false, false))
{
reflectionMember.Setter = reflectionDelegateFactory.CreateSet <object>(memberInfo);
break;
}
break;
case MemberTypes.Method:
MethodInfo methodInfo = (MethodInfo)memberInfo;
if (methodInfo.IsPublic)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length == 0 && methodInfo.ReturnType != typeof(void))
{
MethodCall <object, object> call = reflectionDelegateFactory.CreateMethodCall <object>((MethodBase)methodInfo);
reflectionMember.Getter = (Func <object, object>)(target => call(target, new object[0]));
break;
}
if (parameters.Length == 1 && methodInfo.ReturnType == typeof(void))
{
MethodCall <object, object> call = reflectionDelegateFactory.CreateMethodCall <object>((MethodBase)methodInfo);
object obj;
reflectionMember.Setter = (Action <object, object>)((target, arg) => obj = call(target, new object[1]
{
arg
}));
break;
}
break;
}
break;
default:
throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".FormatWith((IFormatProvider)CultureInfo.InvariantCulture, (object)memberInfo.MemberType(), (object)memberInfo.Name));
}
if (ReflectionUtils.CanReadMemberValue(memberInfo, false))
{
reflectionMember.Getter = reflectionDelegateFactory.CreateGet <object>(memberInfo);
}
if (ReflectionUtils.CanSetMemberValue(memberInfo, false, false))
{
reflectionMember.Setter = reflectionDelegateFactory.CreateSet <object>(memberInfo);
}
reflectionMember.MemberType = ReflectionUtils.GetMemberUnderlyingType(memberInfo);
reflectionObject.Members[memberName] = reflectionMember;
}
return(reflectionObject);
}
public static object CreateAndPopulateList(Type listType, Action <IList, bool> populateList)
{
ValidationUtils.ArgumentNotNull(listType, "listType");
ValidationUtils.ArgumentNotNull(populateList, "populateList");
IList list;
Type collectionType;
bool isReadOnlyOrFixedSize = false;
if (listType.IsArray)
{
// have to use an arraylist when creating array
// there is no way to know the size until it is finised
list = new List <object>();
isReadOnlyOrFixedSize = true;
}
else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>), out collectionType))
{
Type readOnlyCollectionContentsType = collectionType.GetGenericArguments()[0];
Type genericEnumerable = ReflectionUtils.MakeGenericType(typeof(IEnumerable <>), readOnlyCollectionContentsType);
bool suitableConstructor = false;
foreach (ConstructorInfo constructor in listType.GetConstructors())
{
IList <ParameterInfo> parameters = constructor.GetParameters();
if (parameters.Count == 1)
{
if (genericEnumerable.IsAssignableFrom(parameters[0].ParameterType))
{
suitableConstructor = true;
break;
}
}
}
if (!suitableConstructor)
{
throw new Exception("Read-only type {0} does not have a public constructor that takes a type that implements {1}.".FormatWith(CultureInfo.InvariantCulture, listType, genericEnumerable));
}
// can't add or modify a readonly list
// use List<T> and convert once populated
list = CreateGenericList(readOnlyCollectionContentsType);
isReadOnlyOrFixedSize = true;
}
else if (typeof(IList).IsAssignableFrom(listType))
{
if (ReflectionUtils.IsInstantiatableType(listType))
{
list = (IList)Activator.CreateInstance(listType);
}
else if (listType == typeof(IList))
{
list = new List <object>();
}
else
{
list = null;
}
}
else if (ReflectionUtils.ImplementsGenericDefinition(listType, typeof(ICollection <>)))
{
if (ReflectionUtils.IsInstantiatableType(listType))
{
list = CreateCollectionWrapper(Activator.CreateInstance(listType));
}
else
{
list = null;
}
}
else
{
list = null;
}
if (list == null)
{
throw new Exception("Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, listType));
}
populateList(list, isReadOnlyOrFixedSize);
// create readonly and fixed sized collections using the temporary list
if (isReadOnlyOrFixedSize)
{
if (listType.IsArray)
{
list = ToArray(((List <object>)list).ToArray(), ReflectionUtils.GetCollectionItemType(listType));
}
else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>)))
{
list = (IList)ReflectionUtils.CreateInstance(listType, list);
}
}
else if (list is IWrappedCollection)
{
return(((IWrappedCollection)list).UnderlyingCollection);
}
return(list);
}
public static IList CreateGenericList(Type listType)
{
ValidationUtils.ArgumentNotNull(listType, "listType");
return((IList)ReflectionUtils.CreateGeneric(typeof(List <>), listType));
}
private static bool IsCompatibleObject(object value)
{
return(value is T || (value == null && (!typeof(T).IsValueType() || ReflectionUtils.IsNullableType(typeof(T)))));
}
