public void SerializationEvents()
{
var settings = new DataContractSerializerSettings
{
DataContractResolver = new ProxyDataContractResolver()
};
var tester = new XmlDataContractSerializerTester<IEnumerable<Category>>(
_testOutputHelper,
new DataContractSerializer(typeof (IEnumerable<Category>), settings),
true);
List<Category> categories = _dbContext.Categories.ToList();
var deserializedCategories = tester.SerializeAndDeserialize(categories).ToList();
}
public void IDataContractSurrogate()
{
var orders = dbContext.Orders.ToArray();
var knownTypes = new List<Type>
{
typeof (Order)
};
IDataContractSurrogate surrogate = new OrderSurrogate();
var tester = new XmlDataContractSerializerTester<IEnumerable<Order>>(
new DataContractSerializer(typeof(IEnumerable<Order>), knownTypes, Int32.MaxValue, false, true,
surrogate),
true);
tester.SerializeAndDeserialize(orders);
}
public void ISerializationSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var selector = new SurrogateSelector();
selector.AddSurrogate(type: typeof(Order_Detail),
context: new StreamingContext(StreamingContextStates.All, dbContext),
surrogate: new Order_DetailsSerializationSurrogate()
);
var serializer = new NetDataContractSerializer();
serializer.SurrogateSelector = selector;
var tester = new XmlDataContractSerializerTester <IEnumerable <Order_Detail> >(serializer, true);
var orderDetails = dbContext.Order_Details.ToList();
tester.SerializeAndDeserialize(orderDetails);
}
public void ISerializable()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var t = (dbContext as IObjectContextAdapter).ObjectContext;
var tester = new XmlDataContractSerializerTester <IEnumerable <Product> >(new NetDataContractSerializer(), true);
var products = dbContext.Products.ToList();
foreach (var p in products)
{
t.LoadProperty(p, f => f.Category);
t.LoadProperty(p, f => f.Supplier);
t.LoadProperty(p, f => f.Order_Details);
}
tester.SerializeAndDeserialize(products);
}
public void ISerializable()
{
var dataContractSerializerSettings = new DataContractSerializerSettings
{
DataContractResolver = this.resolver
};
var dataContractSerializer = new DataContractSerializer(
typeof(IEnumerable<Product>),
dataContractSerializerSettings);
var products = this.context.Products.ToList();
var tester = new XmlDataContractSerializerTester<IEnumerable<Product>>(dataContractSerializer, true);
var productsBack = tester.SerializeAndDeserialize(products);
}
public void ISerializable()
{
var settings = new DataContractSerializerSettings
{
DataContractResolver = new ProxyDataContractResolver(),
KnownTypes = new List<Type>() {typeof (Supplier)}
};
var tester = new XmlDataContractSerializerTester<IEnumerable<Product>>(
_testOutputHelper,
new DataContractSerializer(typeof (IEnumerable<Product>), settings),
true);
var products = _dbContext.Products.ToList();
var deserializedOrders = tester.SerializeAndDeserialize(products);
}
public void SerializationCallbacks()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var serializationContext = new SerializationContext
{
ObjectContext = (dbContext as IObjectContextAdapter).ObjectContext,
TypeToSerialize = typeof(Category)
};
var xmlSerializer = new NetDataContractSerializer(new StreamingContext(StreamingContextStates.All, serializationContext));
var tester = new XmlDataContractSerializerTester <IEnumerable <Category> >(xmlSerializer, true);
var categories = dbContext.Categories.ToList();
tester.SerializeAndDeserialize(categories);
}
public void ISerializationSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var tester = new XmlDataContractSerializerTester <IEnumerable <Order_Detail> >(new NetDataContractSerializer(), true);
var orderDetails = dbContext.Order_Details.ToList();
var objContext = (dbContext as IObjectContextAdapter).ObjectContext;
foreach (var detail in orderDetails)
{
objContext.LoadProperty(detail, f => f.Order);
objContext.LoadProperty(detail, f => f.Product);
}
tester.SerializeAndDeserialize(orderDetails);
}
public void ISerializable()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var serializationContext = new SerializationContext
{
ObjectContext = (dbContext as IObjectContextAdapter).ObjectContext,
TypeToSerialize = typeof(Product)
};
var xmlSerializer = new NetDataContractSerializer(new StreamingContext(StreamingContextStates.All, serializationContext));
var tester = new XmlDataContractSerializerTester <IEnumerable <Product> >(xmlSerializer, true);
var products = dbContext.Products.ToList();
tester.SerializeAndDeserialize(products);
}
public void ISerializationSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = false;
SurrogateSelector ss = new SurrogateSelector();
ss.AddSurrogate(typeof(Order_Detail),
sc,
new Order_DetailSerializationSurrogate());
var tester = new XmlDataContractSerializerTester <IEnumerable <Order_Detail> >(new NetDataContractSerializer(sc)
{
SurrogateSelector = ss
}, true);
var orderDetails = dbContext.Order_Details.ToList();
tester.SerializeAndDeserialize(orderDetails);
}
public void IDataContractSurrogate()
{
_dbContext.Configuration.ProxyCreationEnabled = true;
_dbContext.Configuration.LazyLoadingEnabled = true;
var serializerSettings = new DataContractSerializerSettings
{
DataContractSurrogate = new OrdersDataContractSurrogate()
};
var serializer = new DataContractSerializer(typeof(IEnumerable <Order>), serializerSettings);
var tester = new XmlDataContractSerializerTester <IEnumerable <Order> >(serializer, true);
var orders = _dbContext.Orders.ToList();
tester.SerializeAndDeserialize(orders);
}
public void SerializationCallbacks()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var tester = new XmlDataContractSerializerTester <IEnumerable <Category> >(new NetDataContractSerializer(), true);
var categories = dbContext.Categories.ToList();
var c = categories.First();
var res = tester.SerializeAndDeserialize(categories);
Assert.IsTrue(res.Any());
foreach (var category in res)
{
Assert.IsTrue(category.Products.Any());
}
}
public void SerializationCallbacks()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var tester = new XmlDataContractSerializerTester <IEnumerable <Category> >(new NetDataContractSerializer(), true);
var categories = dbContext.Categories.ToList();
var t = (dbContext as IObjectContextAdapter).ObjectContext;
foreach (var category in categories)
{
t.LoadProperty(category, x => x.Products);
}
dbContext.Categories.Include(x => x.Products).ToList();
tester.SerializeAndDeserialize(categories);
}
public void IDataContractSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = true;
dbContext.Configuration.LazyLoadingEnabled = true;
CustomerSurrogate surrogate = new CustomerSurrogate();
var dataContractSerializer = new DataContractSerializer(
typeof(IEnumerable <Order>),
new List <Type>(),
Int16.MaxValue,
false,
true,
surrogate);
var tester = new XmlDataContractSerializerTester <IEnumerable <Order> >(new DataContractSerializer(typeof(Order)), true);
var orders = dbContext.Orders.ToList();
tester.SerializeAndDeserialize(orders);
}
public void IDataContractSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = true;
dbContext.Configuration.LazyLoadingEnabled = true;
var tester = new XmlDataContractSerializerTester <IEnumerable <Order> >(
new DataContractSerializer(typeof(IEnumerable <Order>),
new DataContractSerializerSettings()
{
PreserveObjectReferences = true,
IgnoreExtensionDataObject = false,
MaxItemsInObjectGraph = int.MaxValue,
DataContractSurrogate = new OrderIDataContractSurrogate()
}), true);
var orders = dbContext.Orders.ToList();
tester.SerializeAndDeserialize(orders);
}
public void ISerializable()
{
#region ARRANGE
_dbContext.Configuration.ProxyCreationEnabled = false;
#endregion
#region ACT
var tester = new XmlDataContractSerializerTester <IEnumerable <Product> >(new NetDataContractSerializer(), true);
var products = _dbContext.Products.ToList();
#endregion
#region ASSERT
tester.SerializeAndDeserialize(products);
#endregion
}
public void ISerializationSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var serializationContext = new SerializationContext
{
ObjectContext = (dbContext as IObjectContextAdapter).ObjectContext,
TypeToSerialize = typeof(Order_Detail)
};
var xmlSerializer = new NetDataContractSerializer()
{
SurrogateSelector = new OrderDetailSurrogateSelector(),
Context = new StreamingContext(StreamingContextStates.All, serializationContext)
};
var tester = new XmlDataContractSerializerTester <IEnumerable <Order_Detail> >(xmlSerializer, true);
var orderDetails = dbContext.Order_Details.ToList();
tester.SerializeAndDeserialize(orderDetails);
}
public void ISerializable()
{
var products =
dbContext.Products.Include(x => x.Category)
.Include(x => x.Supplier)
.Include(x => x.Order_Details)
.ToList();
var knownTypes = new List<Type>
{
typeof (HashSet<Order_Detail>),
typeof (Supplier),
typeof (Category)
};
var tester =
new XmlDataContractSerializerTester<IEnumerable<Product>>(
new DataContractSerializer(typeof(IEnumerable<Product>)
, knownTypes, int.MaxValue, false, true, null), true);
tester.SerializeAndDeserialize(products);
}
public void IDataContractSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = true;
dbContext.Configuration.LazyLoadingEnabled = true;
//var tester =
// new XmlDataContractSerializerTester<IEnumerable<Order>>
// (
// new DataContractSerializer(typeof(IEnumerable<Order>)),
// true
// );
//var orders = dbContext.Orders.ToList();
//tester.SerializeAndDeserialize(orders);
var formatterSettings = new DataContractSerializerSettings()
{
DataContractSurrogate = new OrderSurrogate()
};
var formatter = new DataContractSerializer(typeof(IEnumerable <Order>), formatterSettings);
var tester = new XmlDataContractSerializerTester <IEnumerable <Order> >(formatter, true);
var orders = dbContext.Orders.ToList();
var res = tester.SerializeAndDeserialize(orders);
Assert.IsTrue(res.Any());
foreach (var o in res)
{
Assert.IsNotNull(o.Customer);
Assert.IsNotNull(o.Employee);
Assert.IsTrue(o.GetType() == typeof(Order));
Assert.IsTrue(o.Customer.GetType() == typeof(Customer));
Assert.IsTrue(o.Employee.GetType() == typeof(Employee));
}
}
public void ISerializationSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = false;
//var tester = new XmlDataContractSerializerTester<IEnumerable<Order_Detail>>(new NetDataContractSerializer(), true);
//var orderDetails = dbContext.Order_Details.ToList();
//
//var res = tester.SerializeAndDeserialize(orderDetails);
//Assert.IsTrue(res.Any());
//foreach (var orderDetail in res)
//{
// Assert.IsNotNull(orderDetail.Product);
//}
SurrogateSelector selector = new SurrogateSelector();
selector.AddSurrogate(
typeof(Order_Detail),
new StreamingContext(StreamingContextStates.All),
new OrderDetailSurrogate());
var formatter = new NetDataContractSerializer();
formatter.SurrogateSelector = selector;
var tester = new XmlDataContractSerializerTester <IEnumerable <Order_Detail> >(formatter, true);
var orderDetails = dbContext.Order_Details.ToList();
var res = tester.SerializeAndDeserialize(orderDetails);
Assert.IsTrue(res.Any());
foreach (var orderDetail in res)
{
Assert.IsNotNull(orderDetail.Order);
Assert.IsNotNull(orderDetail.Product);
}
}
public void ISerializationSurrogate()
{
_dbContext.Configuration.ProxyCreationEnabled = false;
SurrogateSelector surrogateSelector = new SurrogateSelector();
surrogateSelector.AddSurrogate(
typeof(Order_Detail),
new StreamingContext(StreamingContextStates.All, _dbContext),
new OrderDetailSerializationSurrogate());
var tester = new XmlDataContractSerializerTester <IEnumerable <Order_Detail> >(
new NetDataContractSerializer()
{
Context = new StreamingContext(StreamingContextStates.All, _dbContext),
SurrogateSelector = surrogateSelector
},
true);
var orderDetails = _dbContext.Order_Details.ToList();
tester.SerializeAndDeserialize(orderDetails);
}
public void SerializationCallbacks()
{
#region ARRANGE
_dbContext.Configuration.ProxyCreationEnabled = false;
#endregion
#region ACT
var tester = new XmlDataContractSerializerTester <IEnumerable <Category> >(new NetDataContractSerializer(), true);
var categories = _dbContext.Categories.ToList();
var c = categories.First();
#endregion
#region ASSERT
tester.SerializeAndDeserialize(categories);
#endregion
}
public void IDataContractSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = true;
dbContext.Configuration.LazyLoadingEnabled = true;
var tester = new XmlDataContractSerializerTester <IEnumerable <Order> >(new DataContractSerializer(typeof(IEnumerable <Order>), new DataContractSerializerSettings()
{
DataContractSurrogate = new OrderDataContractSurrogate(), PreserveObjectReferences = true, DataContractResolver = new ProxyDataContractResolver()
}), true);
var orders = dbContext.Orders.ToList();
var t = (dbContext as IObjectContextAdapter).ObjectContext;
foreach (var order in orders)
{
t.LoadProperty(order, o => o.Shipper);
t.LoadProperty(order, o => o.Customer);
t.LoadProperty(order, o => o.Employee);
t.LoadProperty(order, o => o.Order_Details);
}
tester.SerializeAndDeserialize(orders);
}
public void ISerializationSurrogate()
{
dbContext.Configuration.ProxyCreationEnabled = false;
var surrogateSelector = new SurrogateSelector();
surrogateSelector.AddSurrogate(typeof(Order_Detail), new StreamingContext(), new OrderDetailsSerializationSurrogate());
var tester = new XmlDataContractSerializerTester <IEnumerable <Order_Detail> >(new NetDataContractSerializer()
{
SurrogateSelector = surrogateSelector
}, true);
var orderDetails = dbContext.Order_Details.ToList();
var t = (dbContext as IObjectContextAdapter).ObjectContext;
foreach (var od in orderDetails)
{
t.LoadProperty(od, p => p.Product);
t.LoadProperty(od, p => p.Order);
}
tester.SerializeAndDeserialize(orderDetails);
}
public void SerializationEvents()
{
var categories = dbContext.Categories.Include(x => x.Products).ToList();
var knownTypes = new List<Type>
{
typeof (HashSet<Order_Detail>)
};
var tester =
new XmlDataContractSerializerTester<IEnumerable<Category>>(
new DataContractSerializer(typeof(IEnumerable<Category>)
, knownTypes, int.MaxValue, false, true, null), true);
tester.SerializeAndDeserialize(categories);
}
public void IDataContractSurrogate()
{
var settings = new DataContractSerializerSettings
{
DataContractResolver = new ProxyDataContractResolver(),
DataContractSurrogate = new OrderDataContractSurrogate(),
};
var tester = new XmlDataContractSerializerTester<IEnumerable<Order>>(
_testOutputHelper,
new DataContractSerializer(typeof(IEnumerable<Order>), settings),
true);
var orders = _dbContext.Orders.Take(10).ToList();
var deserializedOrders = tester.SerializeAndDeserialize(orders);
}
public void SerializationCallbacks()
{
var dataContractSerializerSettings = new DataContractSerializerSettings
{
DataContractResolver = this.resolver
};
var dataContractSerializer = new DataContractSerializer(typeof(Category), dataContractSerializerSettings);
var tester = new XmlDataContractSerializerTester<Category>(dataContractSerializer, true);
var category = this.context.Categories.First();
var categoryBack = tester.SerializeAndDeserialize(category);
}
