Jak wywołać base.base.method ()?

// Cannot change source code
class Base
{
    public virtual void Say()
    {
        Console.WriteLine("Called from Base.");
    }
}

// Cannot change source code
class Derived : Base
{
    public override void Say()
    {
        Console.WriteLine("Called from Derived.");
        base.Say();
    }
}

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

class Program
{
    static void Main(string[] args)
    {
        SpecialDerived sd = new SpecialDerived();
        sd.Say();
    }
}

Wynik to:

Nazywany Special Derived.
Nazywany od Derived. / * to nie jest oczekiwane * /
Zadzwoniono z bazy.

Jak mogę przepisać klasę SpecialDerived, aby metoda klasy średniej „Derived” nie była wywoływana?

AKTUALIZACJA: Powodem, dla którego chcę dziedziczyć po Derived zamiast Base jest klasa pochodna, która zawiera wiele innych implementacji. Ponieważ nie mogę tego zrobić base.base.method(), myślę, że najlepszym sposobem jest wykonanie następujących czynności?

// Nie można zmienić kodu źródłowego

class Derived : Base
{
    public override void Say()
    {
        CustomSay();

        base.Say();
    }

    protected virtual void CustomSay()
    {
        Console.WriteLine("Called from Derived.");
    }
}

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

    protected override void CustomSay()
    {
        Console.WriteLine("Called from Special Derived.");
    }
}

Chcę tylko to dodać, ponieważ ludzie nadal wracają do tego pytania nawet po wielu latach. Oczywiście jest to zła praktyka, ale nadal można (w zasadzie) zrobić to, czego chce autor:

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();            
    }
}

Jest to zła praktyka programistyczna i niedozwolona w C #. To zła praktyka programistyczna, ponieważ

• Szczegóły dotyczące głównej bazy są szczegółami implementacji bazy; nie powinieneś na nich polegać. Klasa bazowa dostarcza abstrakcji ponad grandbase; powinieneś używać tej abstrakcji, a nie budować obejścia, aby tego uniknąć.

• Aby zilustrować konkretny przykład z poprzedniego punktu: jeśli jest to dozwolone, ten wzorzec byłby kolejnym sposobem uczynienia kodu podatnym na awarie klas bazowych. Załóżmy, że Cpochodzi z, z Bktórego pochodzi A. Kod Cużywany base.basedo wywołania metody A. Wtedy autor Bzdaje sobie sprawę, że włożyli zbyt wiele narzędzi do klasy Bi lepszym podejściem jest stworzenie klasy pośredniej, B2która pochodzi Ai Bpochodzi z B2. Po tej zmianie kod w Cwywołuje metodę w B2, a nie w A, ponieważ Cautor przyjął założenie, że szczegóły implementacji B, a mianowicie, że jego bezpośrednią klasą bazową jestA, nigdy się nie zmieni. Wiele decyzji projektowych w C # ma na celu złagodzenie prawdopodobieństwa różnego rodzaju kruchych awarii bazy; decyzja o uznaniu ich za base.basenielegalną całkowicie zapobiega temu szczególnemu posmakowi tego wzorca niepowodzenia.

• Wywodzisz się ze swojej bazy, ponieważ lubisz to, co robi i chcesz ją ponownie wykorzystać i rozszerzyć. Jeśli nie podoba ci się to, co robi i chcesz to obejść zamiast pracować z tym, to dlaczego w ogóle z tego wyprowadziłeś? Czerp sam z siebie, jeśli jest to funkcja, którą chcesz wykorzystać i rozszerzyć.

• Baza może wymagać pewnych niezmienników dla celów bezpieczeństwa lub spójności semantycznej, które są utrzymywane przez szczegóły dotyczące sposobu, w jaki baza używa metod grandbase. Zezwolenie klasie pochodnej bazy na pominięcie kodu, który utrzymuje te niezmienniki, może wprowadzić bazę w niespójny, uszkodzony stan.

Nie możesz z C #. W IL jest to faktycznie obsługiwane. Możesz zadzwonić non-virt do którejkolwiek ze swoich klas rodzicielskich ... ale nie rób tego. :)

Odpowiedź (o której wiem, że nie jest tym, czego szukasz) brzmi:

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

Prawda jest taka, że ​​masz bezpośrednią interakcję tylko z klasą, z której dziedziczysz. Pomyśl o tej klasie jak o warstwie - dostarczającej tyle lub tak mało jej lub funkcji rodzica, ile sobie tego życzy, do klas pochodnych.

EDYTOWAĆ:

Twoja edycja działa, ale myślę, że użyłbym czegoś takiego:

class Derived : Base
{
    protected bool _useBaseSay = false;

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

Oczywiście w prawdziwej implementacji możesz zrobić coś podobnego dla rozszerzalności i łatwości konserwacji:

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");
    }
}

Następnie klasy pochodne mogą odpowiednio kontrolować stan swoich rodziców.

Dlaczego po prostu nie rzucić klasy potomnej na określoną klasę nadrzędną i nie wywołać wtedy konkretnej implementacji? Jest to sytuacja szczególna i należy zastosować rozwiązanie dla przypadku specjalnego. Będziesz jednak musiał użyć newsłowa kluczowego w metodach dzieci.

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());
    }
}

public class A
{
    public int i = 0;
    internal virtual void test()
    {
        Console.WriteLine("A test");
    }
}

public class B : A
{
    public new int i = 1;
    public new void test()
    {
        Console.WriteLine("B test");
    }
}

public class C : B
{
    public new int i = 2;
    public new void test()
    {
        Console.WriteLine("C test - ");
        (this as A).test(); 
    }
}

Możesz również utworzyć prostą funkcję w klasie pochodnej pierwszego poziomu, aby wywołać funkcję grand base

Moim 2c w tym celu jest zaimplementowanie funkcjonalności, której potrzebujesz, aby zostać wywołanym w klasie zestawu narzędzi i wywołać ją z dowolnego miejsca:

// 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 ); }
}

Wymaga to przemyślenia, aby uzyskać uprawnienia dostępu, może być konieczne dodanie niektórych internalmetod dostępu, aby ułatwić funkcjonalność.

W przypadkach, w których nie masz dostępu do źródła klasy pochodnej, ale potrzebujesz całego źródła klasy pochodnej oprócz bieżącej metody, zalecałbym również wykonanie klasy pochodnej i wywołanie implementacji klasy pochodnej.

Oto przykład:

//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();  
     }         
}

Jak widać z poprzednich postów, można argumentować, że jeśli trzeba obejść funkcjonalność klas, to coś jest nie tak w architekturze klas. To może być prawda, ale nie zawsze można zrestrukturyzować lub zmienić strukturę klas w dużym, dojrzałym projekcie. Różne poziomy zarządzania zmianami mogą stanowić jeden problem, ale utrzymanie istniejącej funkcjonalności działającej tak samo po refaktoryzacji nie zawsze jest zadaniem trywialnym, zwłaszcza jeśli obowiązują ograniczenia czasowe. W dojrzałym projekcie powstrzymanie różnych testów regresji przed przejściem po restrukturyzacji kodu może być dużym przedsięwzięciem; często pojawiają się niejasne „dziwactwa”. Mieliśmy podobny problem w niektórych przypadkach dziedziczona funkcjonalność nie powinna być wykonywana (lub powinna wykonywać coś innego). Podejście, które zastosowaliśmy poniżej, polegało na umieszczeniu kodu podstawowego, który należy wykluczyć, w oddzielnej funkcji wirtualnej. Tę funkcję można następnie przesłonić w klasie pochodnej, a funkcjonalność wykluczyć lub zmienić. W tym przykładzie można zapobiec wyświetlaniu „Tekstu 2” w klasie pochodnej.

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.
    }
}

Wydaje się, że istnieje wiele pytań dotyczących dziedziczenia metody składowej z klasy dziadków, przesłaniania jej w drugiej klasie, a następnie ponownego wywoływania jej metody z klasy wnuków. Dlaczego po prostu nie odziedziczyć członków dziadków aż do wnuków?

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"

Wydaje się proste ... wnuk dziedziczy tutaj metodę dziadków. Pomyśl o tym… w ten sposób „Object” i jego składowe, takie jak ToString (), są dziedziczone do wszystkich klas w C #. Myślę, że Microsoft nie wykonał dobrej roboty w wyjaśnianiu podstawowego dziedziczenia. Zbyt duży nacisk kładzie się na polimorfizm i implementację. Kiedy przeglądam ich dokumentację, nie ma przykładów na tę bardzo podstawową ideę. :(

Jeśli chcesz uzyskać dostęp do danych klasy bazowej, musisz użyć słowa kluczowego „this” lub użyć tego słowa kluczowego jako odniesienia dla klasy.

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;
        }
    }
}