This issue is really bad for EF Core changetracking.

For us, this means any Relation in an update needs to be manually ignored, synchronized and mapped.
We have two helpers for that.

You can imagine how much clutter this adds just to make sure a user can't override a relation entity ID.
we have entities with many Owned-Properties and Relations, our mapping-files are 90% manually synchronization.

We really like using Mapperly, as it allows compile time checking, evaluation of generated code, is Hot-Reloadable, and is composable.

But some built-in way of doing

// use IComparable<T>, IEquatable<T> or similar to enable this feature.
[MapComparableProperty(nameof(source.Something), nameof(target.Something))]
// manually specifying an Equality method
[MapComparableProperty(nameof(source.Something), nameof(target.Something), Use = nameof(CompareSourceDestMethod))]
private static partial void MapInto(TheSource source, TheTarget target);

// maybe support generic overloads? idk.
private static bool CompareSourceDestMethod<A, B>(A a, B b)
    where A: IHaveId,
    where B: IHaveId => a.Id == b.Id;

would be exceptionally great.

Synchronize Property

private static void SynchronizeProperty<TSource, TDestination>(TSource? source,
	TDestination? destination,
	Action<TDestination?> setValueAction,
	Func<TSource, TDestination> createAction,
	Action<TSource, TDestination> mapAction)
	where TSource : class
	where TDestination : class, new()
{
	if (source != null && destination != null)
	{
		mapAction(source, destination);
	}
	else if (source != null && destination == null)
	{
		var item = createAction(source);
		mapAction(source, item);
		setValueAction(item);
	}
	else if (source == null)
	{
		setValueAction(null);
	}
}

Usage

[MapperIgnoreSource(nameof(entity.UserDefined))]
private static partial void IntoEntityInternal(this TheContract source, TheEntity entity);

public static TheEntity ToEntity(this TheContract source)
{
	var destination = new TheEntity();
	IntoEntity(source, destination);

	SynchronizeProperty(source.UserDefined, destination.UserDefined, value => destination.UserDefined= value, _ => new(), MapIntoUserDefined);
}

Equally ugly with Collections of child entities

CollectionSynchronizer.SyncCollections

public static class CollectionSynchronizer
{
	public static void SyncInto<T, U>(
		this ICollection<T> contracts,
		ICollection<U> entities,
		Func<T, U, bool> equalsFunc,
		Action<T, U> mapping)
		where U : new()
	{
		SyncCollections(
			contracts,
			entities,
			equalsFunc,
			newItemFunc: _ => new U(),
			mapping);
	}

	public static void SyncCollections<T, U>(
		ICollection<T> contracts,
		ICollection<U> entities,
		Func<T, U, bool> equalsFunc,
		Action<T, U> mapping)
		where U : new()
	{
		SyncCollections(
			contracts,
			entities,
			equalsFunc,
			newItemFunc: _ => new U(),
			mapping);
	}

	public static void SyncCollections<T, U>(
		ICollection<T> contracts,
		ICollection<U> entities,
		Func<T, U, bool> equalsFunc,
		Func<T, U> newItemFunc,
		Action<T, U> mapping)
	{
		U[] deleted = contracts.Count > 0
			// Wenn wir filtern müssen
			? entities.Where(x => contracts.All(c => !equalsFunc(c, x))).ToArray()
			// wenns keine mehr gibt im Contract
			: entities.ToArray();

		List<T> newItems = contracts.Where(x => entities.All(e => !equalsFunc(x, e))).ToList();

		T[] updateItems = contracts
			.Except(newItems)
			.Where(x => entities.Any(e => equalsFunc(x, e))).ToArray();

		foreach (U entry in deleted)
		{
			entities.Remove(entry);
		}

		foreach (T contract in updateItems)
		{
			if (entities.FirstOrDefault(x => equalsFunc(contract, x)) is { } existing)
			{
				mapping(contract, existing);
			}
			else
			{
				newItems.Add(contract);
			}
		}

		foreach (T contract in newItems)
		{
			var mapped = newItemFunc(contract);
			mapping(contract, mapped);
			entities.Add(mapped);
		}
	}
}

Usage

[MapperIgnoreSource(nameof(entity.UserDefined))]
private static partial void IntoEntityInternal(this TheContract source, TheEntity entity);

public static TheEntity ToEntity(this TheContract source)
{
	var destination = new TheEntity();
	IntoEntity(source, destination);

	CollectionSynchronizer.SyncCollections(source.UserDefined, destination.UserDefined, (source, dest) => source.Id == dest.Id, MapIntoUserDefined);
	 // shorter
	source.UserDefined.SyncInto(destination.UserDefined, (source, dest) => source.Id == dest.Id, MapIntoUserDefined);
	return destination;
}

Uh oh!

Uh oh!

Map to nested existing target instances #1311

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions