An expression tree may not contain an access of static abstract interface member

[KillerBoogie]

I'm using value objects for all properties of entities. Since a lot of them are of type string that just have a min and max length, I created a base class that has the common code. To use value objects with EF Core I need a seperate converter for each type. Therefore I was trying to use the new preview feature of static abstract methods in interfaces.

Static interface members should finally make it possible to call a static factory to create the object, but T.Create(v).Value produces a compile error stating:

CS8927 An expression tree may not contain an access of static abstract interface member

What is this limitation about? Is it a limitation of the preview feature? Is there another way to achive the goal differently?

The converter looks like this:

 public class DBConverter<T> where T : IText<T>
    {
        public static ValueConverter<T, string> TextConverter
        {
            get
            {
                var converter = new ValueConverter<T, string>(
                    v => v.Value,
                    v => T.Create(v).Value);
                return converter;
            }
        }
    }

I then can use in fluent api:

.HasConversion(DBConverter<ProductComment).TextConverter)

The interface is defined as:

public interface IText<T>
    {
        static abstract int MinLength { get; }
        static abstract int MaxLength { get; }
        static abstract Expression<Func<string>> FieldKey { get; }
        public string Value { get; }
        public abstract static Result<T> Create(string text); 
    }

The base class for text value objects is defined as:
(The FieldKey is a lambda to a resource key, which allows multi-language error messages. They key is checked at compile time.)

public class TextBase<T> : ValueObject
{
    public string Value { get; }

    protected TextBase(string value)
    {
        Value = value;
    }

    protected static Result Validate(string comment, int maxLength, Expression<Func<string>> fieldKey)
    {
        return Validate(comment, minLength: 0, maxLength, fieldKey);
    }

    protected static Result Validate(string comment, int minLength, int maxLength, Expression<Func<string>> fieldKey)
    {
        if (String.IsNullOrWhiteSpace(comment))
            return Result.Failure(Error.Validation().Not_Only_Whitespace(fieldKey));

        if (comment?.Length > maxLength)
            return Result.Failure(Error.Validation().Max_Char_Length_Exceeded(fieldKey, maxLength));

        if (comment?.Length < minLength)
            return Result.Failure(Error.Validation().Min_Char_Length_Deceeded(fieldKey, minLength));

        return Result.Success();
    }

    public override string ToString()
    {
        return Value;
    }

    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return Value;
    }
}

For creating a new value object type, for example ProductComment, I just need to write this code:

 public class ProductComment: TextBase<ProductComment>, IText<ProductComment>
    {
        public static int MinLength => 1;
        public static int MaxLength => 100;
        public static Expression<Func<string>> FieldKey => () => Field.Comment;

        private ProductComment(string text) : base(text)  {  }

        public static Result<ProductComment> Create(string text)
        {
            Result result = Validate(text);
            if (result.IsFailure)
            {
                return Result<ProductComment>.Failure(result);
            }
            else
            {
                return Result<ProductComment>.Success(new ProductComment(text));
            }
        }

        public static Result Validate(string text)
        {
            return Validate(text, MinLength, MaxLength, FieldKey);
        }
    }
}

[PathogenDavid]

What is this limitation about?

A lot of newer language features are not supported by expression trees. See #4727 and #158 for discussions on modernizing them.

Back in August 2021 the LDT expressed interest in looking at this sooner rather than later:

Historically, our inability to improve this space has been because of concern about breaking our customers. However, recent discussions between EF and members of the LDT have us encouraged, and we plan to look at this.

My understanding is that the EF team is currently working on a more formalized spec for how this modernization will happen.

Not sure if static abstracts is something they plan to add or if they're focusing on features that have already shipped. (@AndriySvyryd probably knows.)

[imdbere]

I have the exact same issue, did you find any way around this ?

[KennethHoff]

I solved it by creating a method that itself called the interface never. So, instead of () => T.X(value) I did () => Create<T>(value) & private T Create (?? value => T X(value);

Are there any news on the plan from the EF Core team?

[KillerBoogie]

Kenneth, I understand what you want to achive, but not the exact details. Where do you put the private method? Can you post a complete example code, please.

[KennethHoff]

var a = queryable.Select(x => Create<MyStatic>(x));

private static readonly Create<T>(T val) where T: IStatic
{
    return T.CreateThing(val);
}

class MyStatic : IStatic { ... }

[KillerBoogie]

Thank you so much, Kenneth!

[joepb]

@KennethHoff Thanks for the workaround!

Small remark: that readonly is supposed to be T.