public void Check_That_Custom_Comparer_Factory_Returns_Publisher_Comparer()
{
var customComparerFactory = new CustomComparerFactory();
ICustomComparer comparer = customComparerFactory.GetComparer(typeof(Publisher));
Assert.IsInstanceOfType(comparer, typeof(PublisherComparer));
}
/// <summary>
/// Adds a specific comparer for the givenn sort expression.
/// </summary>
/// <param name="sortExpression"></param>
/// <param name="comparer"></param>
public void AddCustomSort(string sortExpression, ICustomComparer <T> comparer)
{
if (_sortDictionary.ContainsKey(sortExpression))
{
_sortDictionary[sortExpression] = comparer;
}
else
{
_sortDictionary.Add(sortExpression, comparer);
}
}
public static void Sort(ICustomComparer icomparer, int[][] array)
{
for (int i = 0; i < array.Length; i++)
{
for (int j = 0; j < array.Length; j++)
{
if (icomparer.Comparer(array[i], array[j]) == -1)
{
Swap(array, i, j);
}
}
}
}
/// <summary>
/// Sort a matrix of integers
/// </summary>
/// <param name="matrix">Sortable matrix</param>
/// <param name="compare"></param>
public static void Sorting(int[][] matrix, ICustomComparer compare)
{
if (matrix == null || compare == null)
{
throw new ArgumentNullException();
}
for (int i = 0; i < matrix.Length - 1; i++)
{
for (int j = i + 1; j < matrix.Length; j++)
{
if (compare.CompareArrays(matrix[i], matrix[j]) > 0)
{
Swap(ref matrix[i], ref matrix[j]);
}
}
}
}
/// <summary>
/// Method that implements binary search in sorted array of generic type items
/// </summary>
/// <typeparam name="T">T parameter type</typeparam>
/// <param name="array">Sorted array of T type items</param>
/// <param name="key">Item to search</param>
/// <param name="comparer">Instance of IComparer interface type</param>
/// <returns>Number of position of wanted element in given array</returns>
public static int BinarySearchGeneric <T>(this T[] array, T key, ICustomComparer <T> comparer)
{
InputValidation(array, key, comparer.Compare);
if (comparer is null)
{
if (key is IComparable && array[0] is IComparable)
{
return(BinarySearchGeneric(array, key, Comparer <T> .Default.Compare));
}
else
{
throw new ArgumentException(nameof(comparer));
}
}
return(BinarySearchGeneric(array, key, comparer.Compare));
}
public void Synchronize(TNorthwindEntity northwindEntity)
{
DbSet <TEntity> tEntityDbSet = _gameStoreDbContext.Set <TEntity>();
if (northwindEntity.IsProxy())
{
northwindEntity = northwindEntity.UnProxy(_northwindDbContext);
}
var entityFromNorthwind = Mapper.Map <TEntity>(northwindEntity);
string northwindIdPropertyName = typeof(TNorthwindEntity).IdentifierPropertyName();
var northwindEntityId = (int)northwindEntity.GetPropValue(northwindIdPropertyName);
TEntity gameStoreEntity = tEntityDbSet
.FirstOrDefault(x => x.NorthwindId == northwindEntityId);
if (gameStoreEntity == null)
{
tEntityDbSet.Add(entityFromNorthwind);
}
else
{
if (gameStoreEntity.IsProxy())
{
gameStoreEntity = gameStoreEntity.UnProxy(_gameStoreDbContext);
}
string gameStoreIdPropertyName = typeof(TEntity).IdentifierPropertyName();
PropertyInfo idPropertyInfo = typeof(TEntity).GetProperty(gameStoreIdPropertyName);
var gameStoreEntityId = (int)gameStoreEntity.GetPropValue(gameStoreIdPropertyName);
idPropertyInfo.SetValue(entityFromNorthwind, gameStoreEntityId, null);
ICustomComparer comparer = _comparerFactory.GetComparer(typeof(TEntity));
if (!comparer.AreEqual(gameStoreEntity, entityFromNorthwind))
{
_gameStoreDbContext.Entry(gameStoreEntity).CurrentValues.SetValues(entityFromNorthwind);
}
}
}
public static bool AreSimilar <T>(T first, T second)
{
//Return true for both references null or same
if (first == null || second == null || object.ReferenceEquals(first, second))
{
return(true);
}
//Return false for different types
if (!first.GetType().Equals(second.GetType()))
{
return(false);
}
//Compare directly values for primitive and string types
if ((first.GetType().IsPrimitive || (typeof(string).Equals(second.GetType()))))
{
Compare = compfactory.CompareObject("Primitive");
return(Compare.compare <T>(first, second));
}
//compare arrays
if (first.GetType().IsArray&& second.GetType().IsArray)
{
Compare = compfactory.CompareObject("Array");
return(Compare.compare <T>(first, second));
}
else
{
if (first.GetType().GetProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).Length > 0)
{
Compare = compfactory.CompareObject("Class");
return(Compare.compare <T>(first, second));
}
}
return(true);
}
public void Synchronize(Order_Detail orderDetail)
{
DbSet <OrderItem> gameStoreDbSet = _gameStoreDbContext.Set <OrderItem>();
DbSet <Order_Detail> northwindDbSet = _northwindDbContext.Set <Order_Detail>();
if (orderDetail.IsProxy())
{
orderDetail = orderDetail.UnProxy(_northwindDbContext);
}
var northwindOrderItem = Mapper.Map <OrderItem>(orderDetail);
OrderItem gameStoreOrderItem = gameStoreDbSet
.FirstOrDefault(x => x.NorthwindOrderId == orderDetail.OrderID &&
x.NorthwindProductId == orderDetail.ProductID);
if (gameStoreOrderItem == null)
{
_gameStoreDbContext.Set <OrderItem>().Add(northwindOrderItem);
}
else
{
if (gameStoreOrderItem.IsProxy())
{
gameStoreOrderItem = gameStoreOrderItem.UnProxy(_gameStoreDbContext);
}
northwindOrderItem.OrderItemId = gameStoreOrderItem.OrderItemId;
ICustomComparer comparer = _comparerFactory.GetComparer(typeof(OrderItem));
if (!comparer.AreEqual(gameStoreOrderItem, northwindOrderItem))
{
_gameStoreDbContext.Entry(gameStoreOrderItem).CurrentValues.SetValues(northwindOrderItem);
}
}
}
public ICustomComparer CompareObject(object type)
{
ICustomComparer customobj = null;
switch (type)
{
case "Primitive":
customobj = new PrimitiveTypeComparer();
break;
case "Array":
customobj = new ArrayComparer();
break;
case "IList":
customobj = new ListComparer();
break;
case "Class":
customobj = new ReferenceTypeComparer();
break;
}
return(customobj);
}
public ICustomComparer GetComparer(Type type)
{
ICustomComparer result = _customComparers.ContainsKey(type) ? _customComparers[type]() : null;
return(result);
}
