How to ignore all properties that are marked as virtual

Question

I am using virtual keyword for some of my properties for EF lazy loading. I have a case in which all properties in my models that are marked as virtual

Answer 1

To correct the answer of @Alexei, don't use the ForSourceMember method, like it's answered here in this issu on github. It's just for validation.

An other way is to use ForAllPropertyMaps like in this answer.

Answer 2

inquisitive's answer works fine, but it can be augmented for real life usage, when some mappings are performed from data models to service models and virtual members from source type should be ignored.

Also, if the type implements some interface, those properties will appear as virtual, so !IsFinal condition must be added to remove these false positive virtual properties.

public static class AutoMapperExtensions
{
    public static IMappingExpression<TSource, TDestination> IgnoreAllDestinationVirtual<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
    {
        var desType = typeof(TDestination);
        foreach (var property in desType.GetProperties().Where(p => p.GetGetMethod().IsVirtual && !p.GetGetMethod().IsFinal))
        {
            expression.ForMember(property.Name, opt => opt.Ignore());
        }

        return expression;
    }

    public static IMappingExpression<TSource, TDestination> IgnoreAllSourceVirtual<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
    {
        var srcType = typeof(TSource);
        foreach (var property in srcType.GetProperties().Where(p => p.GetGetMethod().IsVirtual && !p.GetGetMethod().IsFinal))
        {
            expression.ForSourceMember(property.Name, opt => opt.Ignore());
        }

        return expression;
    }
}

Answer 3

You can create a mapping extension and use it:

namespace MywebProject.Extensions.Mapping
{
    public static class IgnoreVirtualExtensions
    {
        public static IMappingExpression<TSource, TDestination>
               IgnoreAllVirtual<TSource, TDestination>(
                   this IMappingExpression<TSource, TDestination> expression)
        {
            var desType = typeof(TDestination);
            foreach (var property in desType.GetProperties().Where(p =>   
                                     p.GetGetMethod().IsVirtual))
            {
                expression.ForMember(property.Name, opt => opt.Ignore());
            }

            return expression;
        }
    }
}

Usage :

Mapper.CreateMap<Source,Destination>().IgnoreAllVirtual();

Answer 4

As we were using some virtual properties, I had to rewrite the extension as follows:

private static readonly Type CollectionBaseType = typeof(ICollection<>);

public static IMappingExpression<TSource, TDestination> IgnoreNavigationProperties<TSource, TDestination>(
    this IMappingExpression<TSource, TDestination> expression)
{
    var desType = typeof(TDestination);
    foreach (var property in desType.GetProperties()
                        .Where(p => IsCollectionProperty(p) || HasForeignKeyAttribute(p)))
    {
        expression.ForMember(property.Name, opt => opt.Ignore());
    }

    return expression;
}

private static bool IsCollectionProperty(PropertyInfo property)
{
    var propertyType = property.PropertyType;
    return propertyType.IsGenericType && 
           propertyType.GetGenericTypeDefinition() == CollectionBaseType;
}

private static bool HasForeignKeyAttribute(PropertyInfo property) =>
    property.GetCustomAttribute<ForeignKeyAttribute>() != null;

In essence I check if the property either is of type ICollection<> or if it has the [ForeignKey] attribute.

Answer 5

in case you wanna do it without needing to configure a second instance of automapper :

public static class ClearNavigationExtension
{
    public static void ClearNavigation(this object entity)
    {
        var type = entity.GetType();

        foreach (var property in type.GetProperties().Where(p => p.GetGetMethod().IsVirtual))
        {
            property.SetValue(entity, null);
        }
    }

    public static T ClearNavigation<T>(this T entity)
    {
        var type = entity.GetType();
        var entityCopy = Mapper.Map<T, T>(entity);

        foreach (var property in type.GetProperties().Where(p => p.GetGetMethod().IsVirtual))
        {
            property.SetValue(entityCopy, null);
        }

        return entityCopy;
    }

}