dotnet/efcore · error · ArgumentException

The DbFunction '{function}' is generic. Mapping generic meth

Error message

The DbFunction '{function}' is generic. Mapping generic methods as a DbFunction is not supported.

What it means

Thrown by the DbFunction constructor when the registered MethodInfo.IsGenericMethod is true. EF Core cannot map generic methods to a single database function because each closed generic type would imply a different signature/store function, so it rejects them outright at registration.

Source

Thrown at src/EFCore.Relational/Metadata/Internal/DbFunction.cs:57

    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
    ///     any release. You should only use it directly in your code with extreme caution and knowing that
    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
    /// </summary>
    public DbFunction(
        MethodInfo methodInfo,
        IMutableModel model,
        ConfigurationSource configurationSource)
        : this(
            methodInfo.Name,
            methodInfo.ReturnType,
            methodInfo.GetParameters().Select(pi => (pi.Name!, pi.ParameterType)),
            model,
            configurationSource)
    {
        if (methodInfo.IsGenericMethod)
        {
            throw new ArgumentException(RelationalStrings.DbFunctionGenericMethodNotSupported(methodInfo.DisplayName()));
        }

        if (!methodInfo.IsStatic
            && !typeof(DbContext).IsAssignableFrom(methodInfo.DeclaringType))
        {
            // ReSharper disable once AssignNullToNotNullAttribute
            throw new ArgumentException(
                RelationalStrings.DbFunctionInvalidInstanceType(
                    methodInfo.DisplayName(), methodInfo.DeclaringType!.ShortDisplayName()));
        }

        MethodInfo = methodInfo;

        ModelName = GetFunctionName(methodInfo);
    }

    /// <summary>
    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

View on GitHub (pinned to dbf9771522)

Solutions

Replace the generic method with one or more non-generic methods, one per closed type you need to map.
If using reflection, close the generic first (MakeGenericMethod(typeof(X))) so IsGenericMethod is false before registering.
Register each concrete overload as a separate DbFunction with a distinct store function name.
Avoid generic methods entirely for DbFunction mappings; map closed concrete methods.

Example fix

// before
public IQueryable<T> Find<T>(int id) where T : class
    => Set<T>().Where(e => EF.Property<int>(e, "Id") == id);
modelBuilder.HasDbFunction(typeof(Ctx).GetMethod("Find")); // generic

// after
public IQueryable<Order> FindOrder(int id) => Orders.Where(o => o.Id == id);
public IQueryable<Customer> FindCustomer(int id) => Customers.Where(c => c.Id == id);
modelBuilder.HasDbFunction(typeof(Ctx).GetMethod("FindOrder"));
modelBuilder.HasDbFunction(typeof(Ctx).GetMethod("FindCustomer"));

Defensive patterns

Strategy: validation

Validate before calling

// Validate the method is non-generic before registering
var method = typeof(Ctx).GetMethod("Foo");
if (method is null || method.IsGenericMethod)
    throw new InvalidOperationException("DbFunction must be a non-generic method.");
modelBuilder.HasDbFunction(method);

Type guard

static bool IsMappableDbFunction(MethodInfo m) => !m.IsGenericMethod;

Prevention

Never register open generic methods as DbFunctions.
If you need type variants, write explicit non-generic methods per closed type.
When using reflection, close generics with MakeGenericMethod before registering.

When it happens

Trigger: Calling HasDbFunction on an open generic method (e.g. a method with a <T> type parameter), or on a method that happens to be generic (HasDbFunction(typeof(Ctx).GetMethod("Foo").MakeGenericMethod(...)) where the method info reports IsGenericMethod).

Common situations: Developers try to reuse a generic helper as a DbFunction, or pass a MethodInfo that is still open-generic. Also when reflection picks the generic definition instead of a closed instance.

Related errors

AI-assisted analysis of dotnet/efcore@dbf9771522 (2026-08-06). Data as JSON: /api/errors/f9e408d640752f73. Report an issue: GitHub.