LazyLoad no Virtual

@ajcvickers would like to know what impact this would cause. I’ve been working on something where not necessarily I would have “Virtual” type navigators, where today we are forced to declare everything as “Virtual” by activating LazyLoad. I made a little adjustment where everything works perfectly for me.

Here is an example:

public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
    if (_options?.UseLazyLoadingProxies == true)
    {
        foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
        {
            if (entityType.ClrType != null
                && !entityType.ClrType.IsAbstract
                && entityType.GetNavigations().Any(p => p.PropertyInfo.GetMethod.IsVirtual))
            {
                if (entityType.ClrType.IsSealed)
                {
                    throw new InvalidOperationException(ProxiesStrings.ItsASeal(entityType.DisplayName()));
                }

                var proxyType = _proxyFactory.CreateLazyLoadingProxyType(entityType);

                var serviceProperty = entityType.GetServiceProperties().FirstOrDefault(e => e.ClrType == typeof(ILazyLoader));
                if (serviceProperty == null)
                {
                    serviceProperty = entityType.AddServiceProperty(_lazyLoaderProperty, ConfigurationSource.Convention);
                    serviceProperty.SetParameterBinding(
                        (ServiceParameterBinding)new LazyLoaderParameterBindingFactory().Bind(
                            entityType,
                            typeof(ILazyLoader),
                            nameof(IProxyLazyLoader.LazyLoader)));
                }

                var binding = (ConstructorBinding)entityType[CoreAnnotationNames.ConstructorBinding];
                if (binding == null)
                {
                    _directBindingConvention.Apply(modelBuilder);
                }

                binding = (ConstructorBinding)entityType[CoreAnnotationNames.ConstructorBinding];

                entityType[CoreAnnotationNames.ConstructorBinding]
                    = new FactoryMethodConstructorBinding(
                        _proxyFactory,
                        _createLazyLoadingProxyMethod,
                        new List<ParameterBinding>
                        {
                            new EntityTypeParameterBinding(),
                            new DefaultServiceParameterBinding(typeof(ILazyLoader), typeof(ILazyLoader), serviceProperty),
                            new ObjectArrayParameterBinding(binding.ParameterBindings)
                        },
                        proxyType);

                foreach (var navigation in entityType.GetNavigations())
                {
                    if (navigation.PropertyInfo == null)
                    {
                        throw new InvalidOperationException(
                            ProxiesStrings.FieldNavigation(navigation.Name, entityType.DisplayName()));
                    }

                    if (navigation.PropertyInfo.GetMethod.IsVirtual)
                    {
                        navigation.SetPropertyAccessMode(PropertyAccessMode.Field);
                    }
                    
                }
            }
        }
    }

    return modelBuilder;
}

I added just this: entityType.GetNavigations().Any(p => p.PropertyInfo.GetMethod.IsVirtual)) And:

 if (navigation.PropertyInfo.GetMethod.IsVirtual)
 {
    navigation.SetPropertyAccessMode(PropertyAccessMode.Field);
 }

I believe that with this it would not be necessary to force the user to define a virtual type navigation property.

Thank you in advance.

[divega]

@ralmsdeveloper sure we could provide granular control at the navigation property level, assuming that is what you meant.

No offense taken 😄 Service and delegate injection give you complete control at the cost of more complexity in your entity types.

[ralmsdeveloper]

All right then, I’ll follow up on this issue https://github.com/aspnet/EntityFrameworkCore/issues/10787 Thanks!