делегат c# и абстрактный класс

В качестве варианта темы, предложенной Руне Гримстад, я думаю, вы могли бы использовать шаблон стратегии (например,
Введение в шаблон стратегии GOF в C # ).

Это было бы особенно интересно в случае, когда вы не можете изменить LegacyClass (и, следовательно, возможно, не можете легко использовать «интерфейсный подход», предложенный Корнелиусом), и если вы используете внедрение зависимостей (DI; Injection Dependency ]). Я бы (возможно) позволил вам внедрить правильную реализацию (конкретную стратегию) в нужное место.

Стратегия:

public interface INodeFetcher<T> { 
    List<T> GetNodes(int k);
}

Конкретные стратегии:

public class CurrentSelector<T> : INodeFetcher<T>
{
    public List<T> GetNodes(int argument) 
    {
    // Return the result "current" method
    }
}

public class LegacySelector<T> : INodeFetcher<T>
{
    public List<T> GetNodes(int argument) 
    {
    // Return the result "legacy" method
    }
}

-> Внедрить / реализовать правильную конкретную стратегию.

С уважением

У вас может быть делегат, который инициализируется ссылками на различные методы в зависимости от некоторых условий.

Что касается ваших вопросов:
1) Я не уверен, что вы имеете в виду под "знает". Вы можете передать делегату любой метод, поэтому если вы можете написать метод, который "знает" о некоторых других методах, то вы можете сделать аналогичный делегат.
2) Опять же, делегаты могут быть созданы из любого метода, который может быть выполнен. Например, если у вас есть инициализированная локальная переменная типа ClassCurrent, вы можете создать делегат для любого метода экземпляра типа ClassCurrent.
3) Делегат может вызывать только тот метод, который действительно может быть вызван. То есть, вы не можете вызвать ClassCurrent.GetAllRootNodes, потому что GetAllRootNodes не является статическим методом, поэтому для его вызова нужен экземпляр ClassCurrent.

Делегат может находиться в любом классе, который имеет доступ к ClassCurrent и MyClassLegacy.

Например, вы можете создать что-то вроде:

class SomeActionAccessor<T>
{
    // Declare delegate and fied of delegate type.
    public delegate T GetAllNodesDelegate(int i);

    private GetAllNodesDelegate getAllNodesDlg;

    // Initilaize delegate field somehow, e.g. in constructor.
    public SomeActionAccessor(GetAllNodesDelegate getAllNodesDlg)
    {
        this.getAllNodesDlg = getAllNodesDlg;
    }

    // Implement the method that calls the delegate.
    public T GetAllNodes(int i)
    {
        return this.getAllNodesDlg(i);
    }
}

Делегаты могут обертывать как статический метод, так и метод экземпляра. Единственная разница в том, что для создания делегата с методом экземпляра вам нужен экземпляр класса, которому принадлежит метод.

Зачем вам для этого нужен делегат? Звучит слишком сложно. Я бы просто создал метод в новом классе, который вы могли бы создать, когда вам нужно было вызвать свой метод. Этому классу может быть предоставлена ​​некоторая контекстная информация, которая поможет ему принять решение. Затем я бы реализовал логику в новом методе, которая решала бы, вызывать ли текущий метод или унаследованный метод.

Примерно так:

public class CurrentOrLegacySelector<T>
{

  public CurrentOrLegacySelector(some type that describe context)
  {   
     // .. do something with the context. 
     // The context could be a boolean or something more fancy.
  }

  public List<T> GetNodes(int argument) 
  {
    // Return the result of either current or
    // legacy method based on context information
  }
}

Это даст вам чистую оболочку для методов, которую легко читать и понимать.

Пусть и ClassCurrent, и MyClassLegacy реализуют интерфейс INodeFetcher:

public interface INodeFetcher<T> { 
    List<T> GetNodes(int k);
} 

Для ClassCurrent вызвать метод GetAllRootNodes из реализации интерфейса, а для MyLegacyClass метод GetAllLeaveNodes.