Understanding Compiler Error CS0704

When experimenting with modern C# extension syntax and generic math interfaces such as IBinaryInteger<T>, you may run into compiler error CS0704: cannot do non-virtual member lookup in 'type' because it is a type parameter.

This error occurs when you try to call a static extension method directly on a generic type parameter (for example, T.GetByteCount()) inside a generic context like MyClass<T>.

Why Does CS0704 Happen?

In C#, performing static member lookups directly on a generic type parameter T (such as T.SomeMethod()) is strictly limited by the language specification. The compiler only allows static syntax lookups on type parameters when the method is a static abstract or static virtual member declared directly inside an interface constraint on T.

Because static extension methods are syntactic sugar that map to static calls on an extension container class, the compiler cannot resolve static extension methods using a bare type parameter reference T.

How to Resolve CS0704

1. Call the Method via an Instance Property

If the method you need can be invoked from an instance (such as T.Zero provided by IBinaryInteger<T>), invoke it on the instance instead of the type parameter itself:

public class MyClass<T> where T : IBinaryInteger<T>
{
    // Call GetByteCount() on the instance property T.Zero
    public int NumBytes => T.Zero.GetByteCount();
}

2. Invoke the Extension Helper Directly

If you are writing custom utility logic, define it as a standard static method (or explicit extension method) and pass the type argument explicitly:

public static class UtilityExtensions
{
    public static int GetByteCount<T>() where T : IBinaryInteger<T>
        => T.Zero.GetByteCount();
}

public class MyClass<T> where T : IBinaryInteger<T>
{
    // Call the helper directly using the generic type parameter T
    public int NumBytes => UtilityExtensions.GetByteCount<T>();
}

3. Use Static Abstract Interface Members

If you want to support natural T.MyStaticMethod() syntax inside generic classes, define a custom interface utilizing static abstract members introduced in C# 11:

public interface IByteSizeProvider<TSelf> where TSelf : IByteSizeProvider<TSelf>
{
    static abstract int GetByteCount();
}

public class MyClass<T> where T : IBinaryInteger<T>, IByteSizeProvider<T>
{
    // Valid because GetByteCount is a static abstract member on the constraint
    public int NumBytes => T.GetByteCount();
}

Summary

Error CS0704 prevents direct static member lookups on generic type parameters unless those members are declared as static abstract or virtual interface constraints. To resolve this issue, call the extension method on a concrete instance (like T.Zero), invoke the extension container class explicitly, or leverage static abstract interface members.