c# - 如何实现虚拟静态属性？

Question

据我所知C#不支持虚拟静态属性。如何实现这样的行为C#？

我想归档基类的所有派生类都必须覆盖静态属性。获取派生类型，我想访问一个名为的静态属性Identifier

Type t = typeof(DerivedClass);
var identifier= (String) t.GetProperty("Identifier", BindingFlags.Static).GetValue(null, null);

score 6 · Accepted Answer

对于有相同想法并通过谷歌搜索到达这篇文章的人，请考虑抽象工厂模式而不是这里的解决方案。

--

因为大约五年后您仍然没有接受的答案，让我试一试（再次）..

我曾经考虑过将奇怪重复的模板模式作为一种解决方法，但是由于您将打开BaseClass继承，这不是一个好主意。您可能想查看Lippert 先生的博文，以更好地理解原因。

解决方案1：你不注册，我不认识..

public abstract class BaseClass {
    protected static void Register<U>(String identifier) where U : BaseClass {
        m_identities.Add(typeof(U).GetHashCode(), identifier);
    }

    public static String GetIdentifier<U>() where U : BaseClass {
        var t = typeof(U);
        var identifier = default(String);
        RuntimeHelpers.RunClassConstructor(t.TypeHandle);
        m_identities.TryGetValue(t.GetHashCode(), out identifier);
        return identifier;
    }

    static Dictionary<int, String> m_identities = new Dictionary<int, String> { };
}

public class DerivedClassA:BaseClass {
    static DerivedClassA() {
        BaseClass.Register<DerivedClassA>("12dc2490-065d-449e-a199-6ba051c93622");
    }
}

public class DerivedClassB:BaseClass {
    static DerivedClassB() {
        BaseClass.Register<DerivedClassB>("9745e24a-c38b-417d-a44d-0717e10e3b96");
    }
}

测试：

Debug.Print("{0}", BaseClass.GetIdentifier<DerivedClassA>());
Debug.Print("{0}", BaseClass.GetIdentifier<DerivedClassB>());

这是通过类型初始化器的一个相对简单的模式。该Register方法只暴露给派生类；并且GetIdentifier和Register方法都被限制为使用派生自的类型参数调用BaseClass。虽然我们不强制派生类覆盖任何东西，但如果它没有注册自己，GetIdentifier就不会识别它并返回null。

解决方案2：在你显示你的身份之前，我给你买了一个默认值。无论你认为自己是谁，我都相信——只要没有歧义。

public abstract class BaseClass {
    public abstract String Identifier {
        get;
    }

    public static Type GetDerivedClass(String identifier) {
        return m_aliases[identifier];
    }

    public static String GetIdentifier(Type t) {
        var value = default(String);

        if(t.IsSubclassOf(typeof(BaseClass))) {
            var key = t.GetHashCode();

            if(!m_identities.TryGetValue(key, out value)) {
                value=""+key;
                m_aliases.Add(value, t);
                m_identities[key]=value;
            }
        }

        return value;
    }

    static void UpdateAlias(BaseClass x) {
        var t = x.GetType();
        var value = x.Identifier;
        m_aliases.Add(value, t);
        m_identities[t.GetHashCode()]=value;
    }

    protected BaseClass() {
        BaseClass.UpdateAlias(this);
    }

    static Dictionary<String, Type> m_aliases = new Dictionary<String, Type> { };
    static Dictionary<int, String> m_identities = new Dictionary<int, String> { };
}

public class DerivedClassA:BaseClass {
    public override String Identifier {
        get {
            return "just text";
        }
    }
}

public class DerivedClassB:BaseClass {
    public override String Identifier {
        get {
            return "just text";
        }
    }
}

和测试：

public static void TestMethod() {
    var idBeforeInstantiation = BaseClass.GetIdentifier(typeof(DerivedClassA));
    var y = new DerivedClassA { };
    var idAfterInstantiation = BaseClass.GetIdentifier(typeof(DerivedClassA));

    Debug.Print("B's: {0}", BaseClass.GetIdentifier(typeof(DerivedClassB)));
    Debug.Print("A's after: {0}", idAfterInstantiation);
    Debug.Print("A's before: {0}", idBeforeInstantiation);
    Debug.Print("A's present: {0}", BaseClass.GetIdentifier(typeof(DerivedClassA)));

    var type1 = BaseClass.GetDerivedClass(idAfterInstantiation);
    var type2 = BaseClass.GetDerivedClass(idBeforeInstantiation);

    Debug.Print("{0}", type2==type1); // true
    Debug.Print("{0}", type2==typeof(DerivedClassA)); // true
    Debug.Print("{0}", type1==typeof(DerivedClassA)); // true

    var typeB=BaseClass.GetDerivedClass(BaseClass.GetIdentifier(typeof(DerivedClassB)));

    var x = new DerivedClassB { }; // confilct
}

显然这是一个更复杂的解决方案。但是，正如您所看到的idBeforeInstantiation，idAfterInstantiation它们是不同的，它们要么是DerivedClassA. m_identities包含每个派生类的最后更新标识符，m_aliases并将包含派生类的所有标识符别名。由于虚拟和静态的组合目前不是该语言的特性（也许永远不会......），如果我们想要强制覆盖，那么我们必须通过一些解决方法来做到这一点。如果您选择解决方案2，您可能想要实现您自己的UpdateAlias防止派生类为单一类型提供过多的各种别名，尽管它们都是有效的。测试中的最后一条语句是故意放置的，以证明标识符的冲突。

因为这两个解决方案是为您考虑不实例化派生类而精心设计的，它们都不需要这样做。

score 4 · Accepted Answer

简单地说，你不能，所以我谦虚地建议你离开它并尝试其他东西。

请参阅此 SO帖子中的答案。如果您可以实现这样的功能，您将遇到严重的继承问题。

去过也做过。在我再次清醒后，我采用了常规继承方法。我想你可能也应该这样做。

score 0 · Accepted Answer

另一种不需要注册类但确实需要一些额外工作的方法是创建一个静态类，该类保存每个派生类类型的“静态”数据并从静态返回一个常量/静态值班级。让我解释一下这种方法的细节。

对于类的每个成员来说，拥有一个始终相同的静态属性的一个重要原因是避免不必要的内存使用和重复。虽然这里演示的方法并没有完全避免这种情况，但它仍然绕过了大部分“额外”开销。以下示例不满足的唯一用例是，如果使用静态属性的原因是您不必拥有实例，因为您必须拥有实例才能获取数据。

如果您需要一个对于类的每个成员（静态）始终相同的虚拟字段或属性，请使用返回“常量”或静态数据的非静态属性，如下所示：

public static class MyStaticData
{
    public static const string Class1String = "MyString1";
    public static const int Class1Int = 1;
    public static const string Class2String = "MyString2";
    public static const int Class2Int = 2;
    // etc...
}

public abstract class MyBaseClass
{
    public abstract string MyPseudoVirtualStringProperty { get; }
    public abstract int MyPseudoVirtualIntProperty { get; }
}

public class MyDerivedClass1 : My BaseClass
{
    public override string MyPseudoVirtualStringProperty { get { return MyStaticData.Class1String; } }
    public override int MyPseudoVirtualIntProperty { get { return MyStaticData.Class1Int } }
}

public class MyDerivedClass2 : My BaseClass
{
    public override string MyPseudoVirtualStringProperty { get { return MyStaticData.Class2String; } }
    public override int MyPseudoVirtualIntProperty { get { return MyStaticData.Class2Int } }
}

c# - 如何实现虚拟静态属性？

3 回答 3

Related

Reference