Имитировать механизм вызова метода наследования
У меня есть такая иерархия классов:
public class Base { }
public class Child1 : Base { }
public class Child2 : Base { }
Я хочу сгенерировать хеши для этих классов. Если бы я реализовал эти методы внутри классов, я мог бы легко использовать механизм наследования для получения правильных вызовов методов:
public class Base { public virtual string GetHash() { ... } }
public class Child1 : Base { public override string GetHash() { ... } }
public class Child2 : Base { public override string GetHash() { ... } }
Для данного экземпляра Basefoo я мог бы просто вызвать foo.GetHash(), и это всегда будет правильный метод, потому что механизм наследования перенаправляет на конкретный метод GetHash для конкретного экземпляра foo (если foo есть Child1, то он использует Child1.GetHash, если это Base, он использует Base.GetHash и т. д.).
Однако по причинам, не имеющим здесь отношения (связанным с разделением задач), я не могу реализовать методы хеширования внутри иерархии классов. Вместо этого у меня есть класс Hasher для этой работы.
Вот наивный способ реализовать это с помощью условной цепочки:
public class Hasher
{
public string GetHash(Base data)
{
if (data is Child1 c1)
return GetHashChild1(c1);
else if (data is Child2 c2)
return GetHashChild2(c2);
else
return GetHashBase(data);
}
private string GetHashChild1(Child1 c) { ... }
private string GetHashChild2(Child2 c) { ... }
private string GetHashBase(Base b) { ... }
}
Есть ли способ реализовать это по-другому, чтобы
- в случае, если я добавляю в иерархию новые классы
Child, мне нужно только реализовать соответствующие им методы хеширования (а не обновлять какие-либо операторы if-else-if/switch или заполнять словари и т. д.)? - другими словами: перенаправление на правильный метод происходит автоматически?
Может быть, общие методы (GetHash<T>(T ...)) могут как-то помочь?
Универсальные методы не могут помочь, они привязываются раньше, а виртуальные методы привязываются позже.
Существуют и другие методы регистрации класса где-то, похожие на виртуальные таблицы: статические конструкторы (чтобы сделать что-то с типом один раз), интерфейс со статическими членами (там можно реализовать все хеширование), АОП и отражение (а именно метод CreateDelegate после регистрации всех типов) . Я бы также упаковал разных дочерних элементов в модули с частичными классами для каждой функции (например, хеширования) и вложенности. Тогда создание нового дочернего элемента — это копирование/вставка, и не нужно никуда идти.
Ответы 1
Я бы предложил шаблон посетителя:
public class Base
{
public virtual T Accept<T>(IVisitor<T> visitor) => visitor.Visit(this);
}
public class Child1 : Base
{
public override T Accept<T>(IVisitor<T> visitor) => visitor.Visit(this);
}
public class Child2 : Base
{
public override T Accept<T>(IVisitor<T> visitor) => visitor.Visit(this);
}
public interface IVisitor<out T>
{
T Visit(Base child1);
T Visit(Child1 child1);
T Visit(Child2 child1);
}
public class GetHashVisitor : IVisitor<string>
{
public string Visit(Base child1) => "...";
public string Visit(Child1 child1) => "...";
public string Visit(Child2 child1) => "...";
}
Это позволяет достичь цели отделения хеширования от фактической иерархии объектов.
Если вы сделаете base.Accept абстрактным и удалите IVisitor.Visit(Base) метод, компилятор будет принудительно создавать новый метод для всех ваших посетителей всякий раз, когда добавляется новый дочерний класс. Таким образом, хотя это не проще, чем переключатель или список «если», это может быть безопаснее и гибче.
«по причинам, не относящимся к данному вопросу» Я сомневаюсь, что ваши причины на самом деле являются вескими причинами.