Calculate NotMapped property when loading from EF Core

Actually (at least in EF Core 6) you can use DI when constructing entities. Solution is a little bit hacky and based on the EF Core capability to inject "native" services like the context itself into entities constructors:

Currently, only services known by EF Core can be injected. Support for injecting application services is being considered for a future release.

And AccessorExtensions.GetService<TService> extension method which seems to support resolving services from DI.

So basically just introduce ctor accepting your DbContext as a parameter to the entity and call GetService on it and use service:

public class MyEntity
{
    public MyEntity()
    {        
    }

    public MyEntity(SomeContext context)
    {
        var valueProvider = context.GetService<IValueProvider>();
        NotMapped = valueProvider.GetValue();
    }

    public int Id { get; set; }

    [NotMapped]
    public string NotMapped { get; set; }
}


// Example value provider:
public interface IValueProvider
{
    string GetValue();
}

class ValueProvider : IValueProvider
{
    public string GetValue() => "From DI";
}

Example context:

public class SomeContext : DbContext
{
    public SomeContext(DbContextOptions<SomeContext> options) : base(options)
    {
    }

    public DbSet<MyEntity> Entities { get; set; }
}

And example:

var serviceCollection = new ServiceCollection();
serviceCollection.AddTransient<IValueProvider, ValueProvider>();
serviceCollection.AddDbContext<SomeContext>(builder => 
    builder.UseSqlite($"Filename={nameof(SomeContext)}.db"));
var serviceProvider = serviceCollection.BuildServiceProvider();
// init db and add one item
using (var scope = serviceProvider.CreateScope())
{
    var someContext = scope.ServiceProvider.GetRequiredService<SomeContext>();
    someContext.Database.EnsureDeleted();
    someContext.Database.EnsureCreated();
    someContext.Add(new MyEntity());
    someContext.SaveChanges();
}

// check that value provider is used
using (var scope = serviceProvider.CreateScope())
{
    var someContext = scope.ServiceProvider.GetRequiredService<SomeContext>();
    var myEntities = someContext.Entities.ToList();
    Console.WriteLine(myEntities.First().NotMapped); // prints "From DI"
}

Note that var valueProvider = context.GetService<IValueProvider>(); will throw if service is not registered so possibly next implementation is better:

public MyEntity(SomeContext context)
{
    var serviceProvider = context.GetService<IServiceProvider>();
    var valueProvider = serviceProvider.GetService<IValueProvider>();
    NotMapped = valueProvider?.GetValue() ?? "No Provider";
}

Also you can consider removing not mapped property and creating separate model with it and service which will perform the mapping.

Also in 7th version of EF Core a new hook for exactly this case should be added. See this github issue.

In your DbContext or whatever your context file is called you can intercept the SaveChanges() method and override it with your own things. In my example I override SaveChanges() to automatically add my audit fields so I don't have to duplicate it all over the code in a million places.

here is my example. So when a new object is being created you can override it. In My example I override both New records Added and Records modified.

These are notated at EntitState.Added and EntityStateModified.

Here is the code.

public override int SaveChanges()
        {

            var state = this.ChangeTracker.Entries().Select(x => x.State).ToList();

            state.ForEach(x => {
                if (x == EntityState.Added)
                {
                    //Create new record changes
                    var created = this.ChangeTracker.Entries().Where(e => e.State == EntityState.Added).Select(e => e.Entity).ToArray();

                    foreach (var entity in created)
                    {
                        if (entity is AuditFields)
                        {
                            var auditFields = entity as AuditFields;
                            auditFields.CreateDateTimeUtc = DateTime.UtcNow;
                            auditFields.ModifiedDateTimeUtc = DateTime.UtcNow;
                            auditFields.Active = true;
                        }
                    }
                }

                else if (x == EntityState.Modified)
                {
                    //Modified record changes
                    var modified = this.ChangeTracker.Entries().Where(e => e.State == EntityState.Modified).Select(e => e.Entity).ToArray();

                    foreach (var entity in modified)
                    {
                        if (entity is AuditFields)
                        {
                            var auditFields = entity as AuditFields;
                            auditFields.ModifiedDateTimeUtc = DateTime.UtcNow;
                        }
                    }

                }
                else
                {
                    //do nothing
                }

            });

            return base.SaveChanges();
        }

Since you said:

is there any way to intercept the creation of new User objects?

You would want to do your logic in the EntityState.Added area of code above and this will allow you to intercept the creation of your new User and do whatever you want to do before it is saved to Database.