/// <summary>
/// Convert an IEnumerable to an array
/// </summary>
/// <param name="obj">Object to convert</param>
/// <param name="expectedType">Expected type</param>
/// <returns>The converted object</returns>
internal static object ConvertObjectToExpectedType(object obj, Type expectedType)
{
if (obj == null)
{
return obj;
}
var objectType = obj.GetType();
if (objectType == expectedType
|| objectType.IsSubclassOf(expectedType))
{
return obj;
}
if (IQueryableCloner.IsGenericIQueryableType(expectedType))
{
var m = QueryableMih.AsQueryable(expectedType.GetGenericArguments()[0]);
return m.Invoke(null, new[] { obj });
}
if (typeof(IQueryable).IsAssignableFrom(expectedType))
{
return IQueryableCloner.ConvertToNonGenericQueryable(obj);
}
return obj;
}
public void DuplicateIQueryableInsideExpandoObject()
{
var list = new List <ClassWithoutSerializableAttribute>
{
new ClassWithoutSerializableAttribute
{
PublicPropertyValue = 123
},
null,
new ClassWithoutSerializableAttribute
{
PublicPropertyValue = 456
}
};
dynamic eo = new ExpandoObject();
eo.Property1 = 123;
eo.Property2 = "abc";
eo.Property3 = new ClassWithGenericInt(349);
eo.Property4 = new object();
eo.Property5 = null;
eo.Property6 = list.AsQueryable();
var instance = new List <ExpandoObject>
{
eo,
null,
eo
};
var duplicatedList = Duplicate(instance);
Assert.Equal(3,
duplicatedList.Count);
dynamic duplicatedValue = duplicatedList[0];
Assert.Equal(eo.Property1,
duplicatedValue.Property1);
Assert.Equal(eo.Property2,
duplicatedValue.Property2);
Assert.Equal(eo.Property3,
duplicatedValue.Property3);
Assert.True(duplicatedValue.Property4.GetType() == typeof(object));
Assert.Null(duplicatedValue.Property5);
Assert.True(ReferenceEquals(duplicatedList[0],
duplicatedList[2]));
var duplicatedValueProperty6 = duplicatedValue.Property6;
Assert.True(duplicatedValueProperty6 is IQueryable);
Assert.True(((object)duplicatedValueProperty6).GetType()
.IsGenericType);
Assert.True(IQueryableCloner.IsGenericIQueryableType(((object)duplicatedValueProperty6).GetType()));
var duplicatedValueProperty6AsArray = System.Linq.Enumerable.ToArray((IQueryable <ClassWithoutSerializableAttribute>)duplicatedValueProperty6);
Assert.Equal(list[0].PublicPropertyValue,
duplicatedValueProperty6AsArray[0].PublicPropertyValue);
Assert.Null(duplicatedValueProperty6AsArray[1]);
}
public void QueryableClonerConvertToNonGenericQueryableShouldNotModifyAClass()
{
var instance = new ClassWithGenericInt()
{
Value = 44
};
Assert.True(ReferenceEquals(instance, IQueryableCloner.ConvertToNonGenericQueryable(instance)));
}
/// <summary>
/// Clone an object
/// </summary>
/// <typeparam name="T">Any reference type</typeparam>
/// <param name="obj">Object to clone</param>
/// <returns>The cloned object</returns>
public static T Clone <T>(T obj)
{
if (obj == null)
{
return(default(T));
}
object objToClone = ObjectCleaner.PrepareObjectForSerialization(obj);
var refTracker = new ObjectClonerReferenceTracker();
var clone = CloneImpl(objToClone.GetType())(objToClone, refTracker);
var queryable = IQueryableCloner.GetInterfaceType(obj.GetType(), typeof(IQueryable <>));
if (queryable != null)
{
var genericArgumentType = queryable.GetGenericArguments()[0];
return((T)Deserializer.ConvertObjectToIQueryable(clone, typeof(IQueryable <>).MakeGenericType(genericArgumentType)));
}
return((T)clone);
}
public void QueryableClonerConvertToNonGenericQueryableShouldReturnNull()
{
Assert.Null(IQueryableCloner.ConvertToNonGenericQueryable(null));
}
/// <summary>
/// Throws an exception if the type is not supported for serialization or cloning
/// </summary>
/// <param name="type">Type to analyze</param>
public static void ValidateSupportedTypes(Type type)
{
if (typeof(Expression).IsAssignableFrom(type))
{
throw new NotSupportedException(type.ToString());
}
if (typeof(Delegate).IsAssignableFrom(type))
{
throw new NotSupportedException(type.ToString());
}
if (type.IsPointer)
{
throw new NotSupportedException($"Pointer types such as {type} are not suported");
}
if (InternalSerializationStuff.GetFields(type).Any(x => x.FieldType.IsPointer))
{
throw new NotSupportedException($"Type {type} cannot contains fields that are pointers.");
}
if (type == typeof(IQueryable))
{
throw new NotSupportedException(type.ToString());
}
if (type == typeof(IEnumerable))
{
throw new NotSupportedException(type.ToString());
}
var enumerableType = IQueryableCloner.GetInterfaceType(type, typeof(IEnumerable <>));
if (enumerableType != null)
{
var genericArgument = enumerableType.GetGenericArguments()[0];
if (genericArgument.IsGenericType &&
genericArgument.GetGenericTypeDefinition() == typeof(IGrouping <,>))
{
throw new NotSupportedException(type.ToString());
}
}
if (Attribute.IsDefined(type, typeof(CompilerGeneratedAttribute), false) &&
type.IsGenericType && type.Name.Contains("AnonymousType") &&
(type.Name.StartsWith("<>", StringComparison.OrdinalIgnoreCase)
||
type.Name.StartsWith("VB$", StringComparison.OrdinalIgnoreCase)) &&
(type.Attributes & TypeAttributes.NotPublic) == TypeAttributes.NotPublic)
{
throw new NotSupportedException(type.ToString());
}
if (!type.IsArray &&
type.Namespace != null &&
(type.Namespace.StartsWith("System.") || type.Namespace.StartsWith("Microsoft.")) &&
type.GetCustomAttribute <SerializableAttribute>() == null &&
type != typeof(ExpandoObject) &&
type != typeof(BigInteger))
{
throw new NotSupportedException(type.ToString());
}
}
