Yes, abstracting the logic to be reusable across multiple entities

Question

Yes, abstracting the logic to be reusable across multiple entities

based on dynamic properties can be achieved using a combination of generics, reflection, and expressions. The idea would be to create a generic validation service that can validate any entity based on specified unique properties.

Here's a high-level approach:

### 1. Define a Generic Repository Method

First, you'd need a way to find an entity by a given property in your repositories. A generic method could look like:

public async Task<TEntity> FindByPropertyAsync<TEntity, TValue>(Expression<Func<TEntity, bool>> predicate) where TEntity : class;

### 2. Create a Generic Validation Service

This service will use reflection to validate entities based on provided properties.

public interface IUniquePropertyValidationService
{
Task<(bool IsValid, string ErrorMessage)> ValidateUniquePropertyAsync<TEntity, TValue>(
TEntity entity,
Expression<Func<TEntity, TValue>> propertySelector,
TValue value,
int? entityId = null) where TEntity : class, new();
}

public class UniquePropertyValidationService : IUniquePropertyValidationService
{
private readonly IUnitOfWork _unitOfWork;

public UniquePropertyValidationService(IUnitOfWork unitOfWork)
{
_unitOfWork = unitOfWork;
}

public async Task<(bool IsValid, string ErrorMessage)> ValidateUniquePropertyAsync<TEntity, TValue>(
TEntity entity,
Expression<Func<TEntity, TValue>> propertySelector,
TValue value,
int? entityId = null) where TEntity : class, new()
{
// Convert the property selector to a predicate.
var parameter = Expression.Parameter(typeof(TEntity), "x");
var body = Expression.Equal(propertySelector.Body, Expression.Constant(value, typeof(TValue)));
var lambda = Expression.Lambda<Func<TEntity, bool>>(body, parameter);

var existingEntity = await _unitOfWork.YourGenericRepository.FindByPropertyAsync(lambda);

if (existingEntity != null)
{
// If we have an entityId, we're in update mode, so we check if the found entity's ID matches the updating entity's ID.
var existingEntityId = (int)typeof(TEntity).GetProperty("Id").GetValue(existingEntity);
if (!entityId.HasValue || existingEntityId != entityId.Value)
{
var propertyName = ((MemberExpression)propertySelector.Body).Member.Name;
return (false, $"{typeof(TEntity).Name} with the same {propertyName} already exists.");
}
}

return (true, string.Empty);
}
}

### 3. Use the Service

For instance, for the currency entity:

var validationOutcome = await _uniquePropertyValidationService.ValidateUniquePropertyAsync<Currency, string>(
currencyToUpdate,
x => x.CurrencyCode,
request.CurrencyCode,
request.CurrencyId);

### Caveats:

- This approach assumes all entities have an Id property of type int. Adjustments might be necessary for different setups.
- Reflection can introduce overhead, so while this generic solution is elegant, there might be performance concerns when dealing with large volumes of data or frequent operations.
- The abstraction assumes uniqueness validation is based on a single property. If there are scenarios where uniqueness is based on combinations of properties, further adjustments would be needed.
- This is a more complex solution than having dedicated validation for each entity. Ensure the complexity aligns with your project's needs.