c# - 如何强制所有派生类实现抽象方法或属性？

Question

抽象函数必须由所有具体类实现。

有时你想强制所有派生类实现抽象函数，甚至是具体类的派生类。

class Base { protected abstract Base Clone(); }
class Concrete : Base { protected override Base Clone(){...}; }
class Custom : Concrete {}

我希望编译器告诉程序员该类Custom需要实现Clone()。有办法吗？

Answer 1

编译器不可能强制执行此操作。您可能会考虑为Gendarme或FxCop编写自己的分析插件来强制执行此类要求。

Answer 2

我猜你并不真的需要所有派生类来实现抽象方法，但听起来你的设计肯定有一点代码味道。

如果您在 Concrete.Clone() 方法中没有任何功能，那么您也可以将您的“Concrete”类抽象化（只要确保更改名称；-）。忽略对 Clone() 方法的任何引用。

abstract class Base { protected abstract void Clone(); }
abstract class Concrete : Base { }
class Custom : Concrete { protected override void Clone() { /* do something */ } }

如果您在 Concrete.Clone() 方法中有一些基本功能，但需要来自更高级别的详细信息，则将其分解为它自己的抽象方法或属性，强制更高级别的实现提供此信息。

abstract class Base { protected abstract void Clone(); }

abstract class ConcreteForDatabases : Base 
{ 
    protected abstract string CopyInsertStatemement {get;}

    protected override void Clone()
    {
        // setup db connection & command objects
        string sql = CopyInsertStatemement;
        // process the statement
        // clean up db objects
    }
}

class CustomBusinessThingy : ConcreteForDatabases 
{
    protected override string CopyInsertStatemement {get{return "insert myTable(...) select ... from myTable where ...";}}
}

Answer 3

您将不得不创建Concrete一个抽象类来强制执行它。

Answer 4

您可以在运行时使用反射检查这一点并抛出异常以中断执行，从而对您的库的“不礼貌”用户造成严重破坏。即使您可以将静态HashSet<System.Type>存储在具有所有已验证类型的基本抽象类中，这在性能方面也不是很明智。

我认为您最好的选择是提供清晰的文档，告诉您的代码的任何用户认为有必要覆盖 Clone() 方法。

Answer 5

我进行了以下 NUnit 测试，它使用反射来检查实现。希望您可以根据需要进行调整。

我怀疑它不能很好地处理重载方法，但它足以满足我的需求。

（欢迎评论）

/// <summary>
/// Use on a (possibly abstract) method or property to indicate that all subclasses must provide their own implementation.
/// 
/// This is stronger than just abstract, as when you have
/// 
/// A { public abstract void Method()}
/// B: A { public override void Method(){} }
/// C: B {} 
/// 
/// C will be marked as an error
/// </summary>
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
public class AllSubclassesMustOverrideAttribute : Attribute
{

}

[TestFixture]
public class AllSubclassesMustOverrideAttributeTest
{
    [Test]
    public void SubclassesOverride()
    {
        var failingClasses = new List<string>();

        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
        {
            try
            {
                foreach (var type in assembly.GetTypes())
                {
                    foreach (var methodInfo in type.GetMethods().Where(m => m.HasAttributeOfType<AllSubclassesMustOverrideAttribute>()))
                    {
                        foreach (var subClass in type.ThisTypeAndSubClasses())
                        {
                            var subclassMethod = subClass.GetMethod(methodInfo.Name);

                            if (subclassMethod.DeclaringType != subClass)
                            {
                                failingClasses.Add(string.Format("Class {0} has no override for method {1}", subClass.FullName, methodInfo.Name));
                            }
                        }
                    }

                    foreach (var propertyInfo in type.GetProperties().Where(p => p.HasAttributeOfType<AllSubclassesMustOverrideAttribute>()))
                    {
                        foreach (var subClass in type.ThisTypeAndSubClasses())
                        {
                            var subclassProperty = subClass.GetProperty(propertyInfo.Name);

                            if (subclassProperty.DeclaringType != subClass)
                            {
                                failingClasses.Add(string.Format("Class {0} has no override for property {1}", subClass.FullName, propertyInfo.Name));
                            }
                        }

                    }
                }
            }
            catch (ReflectionTypeLoadException)
            {
                // This will happen sometimes when running the tests in the NUnit runner. Ignore.
            }
        }

        if (failingClasses.Any())
        {
            Assert.Fail(string.Join("\n", failingClasses));
        }
    }
}

它使用以下扩展方法

    public static bool HasAttributeOfType<T>(this ICustomAttributeProvider provider)
    {
        return provider.GetCustomAttributes(typeof(T), false).Length > 0;
    }

    public static IEnumerable<Type> ThisTypeAndSubClasses(this Type startingType)
    {
        var types = new List<Type>();
        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
        {
            try
            {
                foreach (var type in assembly.GetTypes())
                {
                    if (startingType.IsAssignableFrom(type))
                    {
                        types.Add(type);
                    }
                }
            }
            catch (ReflectionTypeLoadException)
            {
                // Some assembly types are unable to be loaded when running as nunit tests.
                // Move on to the next assembly
            }
        }
        return types;
    }

Answer 6

删除 concreate 类中的实现或使用基类