为什么不这样做呢？

#include <type_traits>

//template<typename T>
//concept EnumClass = is_scoped_enum<T>::value; // implementation as seen https://en.cppreference.com/w/cpp/types/is_scoped_enum 

template<typename T>
concept EnumClass = std::is_enum_v<T>; // for testing locally

enum class A { a };
enum class B { b };

template <EnumClass ECA, EnumClass ECB>
class Bar
{
public:
    template<ECA ECAval, ECB ECBval>
    void Foo() {}
};

class Deriving : 
    public Bar<A, B>
{
public:
    void Foo() 
    {
        // you can reuse "base implementation" here if needed
        Bar<A, B>::Foo<A::a, B::b>();
        /* impl... */ 
    }
};

int main()
{
}

我建议使用标记调度来重载，而不是专门化：

template <EnumClass ECA, EnumClass ECB, ECA ECAval, ECB ECBval>
void FooImpl(std::integral_constant<ECA, ECAval>,
             std::integral_constant<ECB, ECBval>)
{
    // generic implementation
}

template <EnumClass ECA, EnumClass ECB>
class Bar
{
    template<ECA ECAval, ECB ECBval>
    void Foo()
    {
       FooImpl(std::integral_constant<ECA, ECAval>{},
               std::integral_constant<ECB, ECBval>{});
    }
};

enum class A{a};
enum class B{b};

FooImpl(std::integral_constant<A, A::a>, std::integral_constant<B, B::b>)
{
    // Your specialization
}

不使用Derived ...