Custom proxy generation for entities

[mortenbock]

I would like to generate my own proxies for the entities returned by EF.

The particular feature I would like to be able to implement, is similar to the LazyLoading proxies. But instead of lazy loading, I want to throw exceptions when un-loaded navigational properties are accessed.

And example navigational path could be Blog => Post => Comment.

A method that takes a Post as an argument might not know if the Comments list was loaded by the query. So if the Comments property is accessed, I would want my proxy to throw an exception, if there was no Include for that relation in the query.

Currently, the issue is that the property would just be null, which could be interpreted wrongly be the runtime code.

I looked at the LazyLoading implementation, but it seems most of the code required to do this is marked as "Internal, do not use", so I would suggest there was a supported way of doing this. (If there is, I could not find it, but would love to know)

[ajcvickers]

Putting this in 3.0 to review the internal code used and ensure that proxies can be created without depending on internal code.

[ajcvickers]

Re-opening this since we decided in #17159 to make the annotations needed internal again.

[davidkraus]

Hey, i'm looking for the same functionality - Is this now possible? If yes can someone give me a hint where to start.

[ajcvickers]

@davidkraus The only issue here is that you may need to make use of some EF internal APIs, which could mean your proxy implementation breaks when we change those APIs. If that's something you can live with, then the best place to start is with the code for proxies in the this repo. I'd be interested to hear how it goes.

[davidkraus]

@ajcvickers using internal APIs is fine since it is 'just' a feature to catch errors earlier.

I gave it a shot and it seems to work - I copied the whole Proxy package (the 3.1.8 version, not the current one) into our Project and startet from there.

The important changes i made are in the LazyLoadingInterceptor (renamed it to RestrictedLoadingInterceptor), the rest of the Proxy code is nearly unchanged.

Code

  public class RestrictedLoadingInterceptor : IInterceptor
    {
        private static readonly PropertyInfo _lazyLoaderProperty
            = typeof(IProxyLazyLoader).GetProperty(nameof(IProxyLazyLoader.LazyLoader));

        private static readonly MethodInfo _lazyLoaderGetter = _lazyLoaderProperty.GetMethod;
        private static readonly MethodInfo _lazyLoaderSetter = _lazyLoaderProperty.SetMethod;

        private readonly IEntityType _entityType;
        private ILazyLoader _loader;
        private ICurrentDbContext _currentDbContext;

        public RestrictedLoadingInterceptor(
            [NotNull] IEntityType entityType,
            [NotNull] ILazyLoader loader,
            [NotNull] ICurrentDbContext currentDbContext)
        {
            _entityType = entityType;
            _loader = loader;
            _currentDbContext = currentDbContext;
        }

        public virtual void Intercept(IInvocation invocation)
        {
            var methodName = invocation.Method.Name;

            if (_lazyLoaderGetter.Equals(invocation.Method))
            {
                invocation.ReturnValue = _loader;
            }
            else if (_lazyLoaderSetter.Equals(invocation.Method))
            {
                _loader = (ILazyLoader)invocation.Arguments[0];
            } else {
                if (_loader != null
                    && methodName.StartsWith("get_", StringComparison.Ordinal)) {

                    var navigationName = methodName.Substring(4);
                    var navigation = _entityType.FindNavigation(navigationName);

                    if (navigation != null) {
                        if (!_currentDbContext.Context.Entry(invocation.InvocationTarget).Reference(navigationName)
                            .IsLoaded) {

                            throw new RestrictedLoadingException(
                                $"Could not access {navigation.Name} on Entity {_entityType.Name} because it was not previously loaded. Use .Include to make sure it is loaded."); 
                        }
                    }
                }

                invocation.Proceed();
            }
        }
    }

To get it working i added an injection for ICurrentDbContext and used _currentDbContext.Context.Entry(invocation.InvocationTarget).Reference(navigationName).IsLoaded to find out if that property is already loaded. If not i just throw a custom Exception. As i am pretty new to C# and EF Core i can't really say if that is a bullet proof solution. The thing i'm worried about (and feels hacky) is the usage of invocation.InvocationTarget. It works in a trivial unit test but it would be great if a more advanced developer could give me some input on that code.

[ajcvickers]

@davidkraus I've been pondering what to say here. My experience of proxies has not been all that great, primarily for two reasons:

• It's easy to not create a proxy without realizing you're doing anything wrong. (Or alternately, you force everything to always be a proxy, which becomes painful when you want to create an entity instance without direct access to the context.)
• The fact that the CLR type of the instance is now a proxy type can cause issues with comparisons, serialization. etc.

Now I'm not sayin that these are insurmountable issues, but it feels to me like introducing proxies in order to override and throw exceptions is probably not the correct trade-off.

One thing that would be easier and not have these issues would be to inject the DbContext into your entities like this:

public class Blog
{
    private readonly DbContext _context;
    private ICollection<Post> _posts;

    public Blog()
    {
    }

    private Blog(DbContext context)
    {
        _context = context;
    }
    
    public int Id { get; set; }

    public ICollection<Post> Posts
    {
        get
        {
            if (_context != null && !_context.Entry(this).Navigation(nameof(Posts)).IsLoaded)
            {
                throw new InvalidOperationException("Posts is not loaded.");
            }
            return _posts;
        }
        set => _posts = value;
    }
}

public class Post
{
    private readonly DbContext _context;
    private Blog _blog;

    public Post()
    {
    }

    private Post(DbContext context)
    {
        _context = context;
    }
    
    public int Id { get; set; }

    public Blog Blog
    {
        get
        {
            if (_context != null && !_context.Entry(this).Navigation(nameof(Blog)).IsLoaded)
            {
                throw new InvalidOperationException("Posts is not loaded.");
            }
            return _blog;
        }
        set => _blog = value;
    }
}

Note however, that this does put an EF dependency directly into your entity type.