Как вызвать base.base.method ()?

Просто хочу добавить это сюда, поскольку люди все равно возвращаются к этому вопросу даже спустя много времени. Конечно, это плохая практика, но все же можно (в принципе) делать то, что хочет автор:

class SpecialDerived : Derived
{
    public override void Say()
    {
        Console.WriteLine("Called from Special Derived.");
        var ptr = typeof(Base).GetMethod("Say").MethodHandle.GetFunctionPointer();            
        var baseSay = (Action)Activator.CreateInstance(typeof(Action), this, ptr);
        baseSay();            
    }
}

Это плохая практика программирования, и она не разрешена в C #. Это плохая практика программирования, потому что

• Детали grandbase - это детали реализации базы; не стоит на них полагаться. Базовый класс предоставляет абстракцию поверх grandbase; вы должны использовать эту абстракцию, а не строить обходной путь, чтобы избежать этого.

• Чтобы проиллюстрировать конкретный пример предыдущего пункта: если он разрешен, этот шаблон был бы еще одним способом сделать код уязвимым для сбоев хрупкого базового класса. Предположим, что C происходит от B, которое происходит от A. Код в C использует base.base для вызова метода A. Затем автор B понимает, что они вложили слишком много снаряжения в класс B, и лучший подход - создать промежуточный класс B2, который является производным от A, а B является производным от B2. После этого изменения код в C вызывает метод в B2, а не в A, потому что автор C сделал предположение, что детали реализации B, а именно, что его прямой базовый класс A, никогда не изменится. Многие проектные решения в C # призваны снизить вероятность различных видов хрупких отказов основания; решение сделать base.base незаконным полностью предотвращает эту особую разновидность этой схемы отказа.

• Вы заимствовали свою базу, потому что вам нравится то, что она делает, и вы хотите ее повторно использовать и расширять. Если вам не нравится то, что он делает, и вы хотите обойти это, а не работать с этим, то почему вы вообще взяли это? Самостоятельно используйте grandbase, если хотите использовать и расширить эту функциональность.

• Базе могут потребоваться определенные инварианты для целей безопасности или семантической согласованности, которые поддерживаются деталями того, как база использует методы большой базы. Разрешение производному классу базы пропускать код, поддерживающий эти инварианты, может привести базу в несогласованное, поврежденное состояние.

Вы не можете этого сделать с C #. В IL это действительно поддерживается. Вы можете сделать вызов любого из ваших родительских классов без поддержки virt ... но, пожалуйста, не делайте этого. :)

Ответ (я знаю, что это не то, что вы ищете):

class SpecialDerived : Base
{
    public override void Say()
    {
        Console.WriteLine("Called from Special Derived.");
        base.Say();
    }
}

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

РЕДАКТИРОВАТЬ:

Ваше редактирование работает, но я бы использовал что-то вроде этого:

class Derived : Base
{
    protected bool _useBaseSay = false;

    public override void Say()
    {
        if(this._useBaseSay)
            base.Say();
        else
            Console.WriteLine("Called from Derived");
    }
}

Конечно, в реальной реализации вы могли бы сделать что-то подобное для расширяемости и ремонтопригодности:

class Derived : Base
{
    protected enum Mode
    {
        Standard,
        BaseFunctionality,
        Verbose
        //etc
    }

    protected Mode Mode
    {
        get; set;
    }

    public override void Say()
    {
        if(this.Mode == Mode.BaseFunctionality)
            base.Say();
        else
            Console.WriteLine("Called from Derived");
    }
}

Затем производные классы могут соответствующим образом управлять состоянием своих родителей.

Почему бы просто не привести дочерний класс к определенному родительскому классу и затем вызвать конкретную реализацию? Это особая ситуация, и следует использовать особое решение. Однако вам придется использовать ключевое слово new в дочерних методах.

public class SuperBase
{
    public string Speak() { return "Blah in SuperBase"; }
}

public class Base : SuperBase
{
    public new string Speak() { return "Blah in Base"; }
}

public class Child : Base
{
    public new string Speak() { return "Blah in Child"; }
}

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        Child childObj = new Child();

        Console.WriteLine(childObj.Speak());

        // casting the child to parent first and then calling Speak()
        Console.WriteLine((childObj as Base).Speak()); 

        Console.WriteLine((childObj as SuperBase).Speak());
    }
}

Вы также можете сделать простую функцию в производном классе первого уровня, чтобы вызвать большую базовую функцию

Мой 2c для этого - реализовать функции, которые вам требуются для вызова в классе инструментария, и вызывать его из любого места, где вам нужно:

// Util.cs
static class Util 
{
    static void DoSomething( FooBase foo ) {}
}

// FooBase.cs
class FooBase
{
    virtual void Do() { Util.DoSomething( this ); }
}


// FooDerived.cs
class FooDerived : FooBase
{
    override void Do() { ... }
}

// FooDerived2.cs
class FooDerived2 : FooDerived
{
    override void Do() { Util.DoSomething( this ); }
}

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

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

Вот пример:

//No access to the source of the following classes
public class Base
{
     public virtual void method1(){ Console.WriteLine("In Base");}
}
public class Derived : Base
{
     public override void method1(){ Console.WriteLine("In Derived");}
     public void method2(){ Console.WriteLine("Some important method in Derived");}
}

//Here should go your classes
//First do your own derived class
public class MyDerived : Base
{         
}

//Then derive from the derived class 
//and call the bass class implementation via your derived class
public class specialDerived : Derived
{
     public override void method1()
     { 
          MyDerived md = new MyDerived();
          //This is actually the base.base class implementation
          MyDerived.method1();  
     }         
}

Как видно из предыдущих сообщений, можно утверждать, что если необходимо обойти функциональность класса, то в архитектуре класса что-то не так. Это может быть правдой, но не всегда можно реструктурировать или реорганизовать структуру классов в большом зрелом проекте. Различные уровни управления изменениями могут быть одной проблемой, но сохранить существующие функции, работающие одинаково после рефакторинга, не всегда является тривиальной задачей, особенно если применяются временные ограничения. В зрелом проекте может оказаться непростым делом не допустить прохождения различных регрессионных тестов после реструктуризации кода; часто обнаруживаются неясные "странности". У нас была аналогичная проблема, в некоторых случаях унаследованные функции не должны выполняться (или должны выполнять что-то еще). Подход, который мы использовали ниже, заключался в том, чтобы поместить базовый код, который необходимо исключить, в отдельную виртуальную функцию. Затем эту функцию можно переопределить в производном классе, а ее функциональность исключить или изменить. В этом примере «Текст 2» можно запретить выводить в производном классе.

public class Base
{
    public virtual void Foo()
    {
        Console.WriteLine("Hello from Base");
    }
}

public class Derived : Base
{
    public override void Foo()
    {
        base.Foo();
        Console.WriteLine("Text 1");
        WriteText2Func();
        Console.WriteLine("Text 3");
    }

    protected virtual void WriteText2Func()
    {  
        Console.WriteLine("Text 2");  
    }
}

public class Special : Derived
{
    public override void WriteText2Func()
    {
        //WriteText2Func will write nothing when 
        //method Foo is called from class Special.
        //Also it can be modified to do something else.
    }
}

Кажется, есть много этих вопросов, связанных с наследованием метода-члена от класса Grandparent, его переопределением во втором классе, а затем повторным вызовом его метода из класса Grandchild. Почему бы просто не унаследовать члены дедушки и бабушки внукам?

class A
{
    private string mystring = "A";    
    public string Method1()
    {
        return mystring;
    }
}

class B : A
{
    // this inherits Method1() naturally
}

class C : B
{
    // this inherits Method1() naturally
}


string newstring = "";
A a = new A();
B b = new B();
C c = new C();
newstring = a.Method1();// returns "A"
newstring = b.Method1();// returns "A"
newstring = c.Method1();// returns "A"

Кажется простым .... здесь внук наследует метод дедушки и бабушки. Подумайте об этом ... вот как "Object" и его члены, такие как ToString (), наследуются всем классам в C #. Я думаю, что Microsoft не очень хорошо объяснила базовое наследование. Слишком много внимания уделяется полиморфизму и реализации. Когда я копаюсь в их документации, я не вижу примеров этой очень простой идеи. :(

Если вы хотите получить доступ к данным базового класса, вы должны использовать ключевое слово this или использовать это ключевое слово как ссылку для класса.

namespace thiskeyword
{
    class Program
    {
        static void Main(string[] args)
        {
            I i = new I();
            int res = i.m1();
            Console.WriteLine(res);
            Console.ReadLine();
        }
    }

    public class E
    {
        new public int x = 3;
    }

    public class F:E
    {
        new public int x = 5;
    }

    public class G:F
    {
        new public int x = 50;
    }

    public class H:G
    {
        new public int x = 20;
    }

    public class I:H
    {
        new public int x = 30;

        public int m1()
        {
           // (this as <classname >) will use for accessing data to base class

            int z = (this as I).x + base.x + (this as G).x + (this as F).x + (this as E).x; // base.x refer to H
            return z;
        }
    }
}