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

結果は次のとおりです。

Special Derivedから呼び出されました。
Derivedから呼び出されました。/ *これは予期されない* /
ベースから呼び出されました。

中間クラスの「Derived」のメソッドが呼び出されないように、SpecialDerivedクラスをどのように書き直すことができますか？

更新： BaseではなくDerivedから継承したいのは、Derivedクラスが他の多くの実装を含んでいるためです。base.base.method()ここではできないので、次のようにするのが一番だと思いますか？

//ソースコードを変更できません

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

人々がまだ何度もこの質問に戻っているので、これをここに追加したいだけです。もちろんそれは悪い習慣ですが、作者が望むことを（原則として）行うことはまだ可能です：

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＃では許可されていません。なぜなら、それは悪いプログラミング習慣です。

• グランドベースの詳細は、ベースの実装の詳細です。あなたはそれらに頼るべきではありません。基本クラスは、グランドベースの上に抽象化を提供します。あなたはそれを避けるためにバイパスを構築するのではなく、その抽象化を使用するべきです。

• 前のポイントの特定の例を説明すると、このパターンは、もし許可されれば、コードを脆弱な基本クラスの障害の影響を受けやすくするもう1つの方法になります。がCからB派生すると仮定しますA。のメソッドを呼び出すためにC使用base.baseするコードA。その後の著者B、彼らはクラスであまりにも多くのギアを入れていることを認識Bし、より良いアプローチは、中間クラスを作ることですB2から派生していることA、およびB導出するからB2。その変更後にコードCでメソッドを呼び出してB2いないで、Aため、Cの著者が仮定したが実装の詳細ことB、すなわち、その直接の基底クラスであることA、変更されることはありません。C＃での多くの設計上の決定は、さまざまな種類の脆弱なベース障害の可能性を軽減することです。base.base非合法にするという決定は、その失敗パターンのこの特定のフレーバーを完全に防ぎます。

• あなたはそれが何をするのが好きで、それを再利用して拡張したいので、ベースから派生しました。それが何をするのが好きではなく、それで作業するのではなく、それを回避したいのであれば、なぜ最初からそれから派生したのですか？それがあなたが使用して拡張したい機能であるなら、自分自身でグランドベースから派生してください。

• ベースは、ベースがグランドベースのメソッドを使用する方法の詳細によって維持される、セキュリティまたはセマンティックの一貫性の目的で特定の不変条件を必要とする場合があります。ベースの派生クラスがそれらの不変条件を維持するコードをスキップできるようにすると、ベースが一貫性のない、破損した状態になる可能性があります。

C＃からはできません。ILから、これは実際にサポートされています。親クラスのいずれに対しても非仮想呼び出しを行うことができます...しないでください。:)

答え（私が知っているのはあなたが探しているものではないことです）は次のとおりです。

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

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

最初のレベルの派生クラスで単純な関数を作成して、グランドベース関数を呼び出すこともできます。

このための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();  
     }         
}

以前の投稿からわかるように、クラスの機能を回避する必要がある場合、クラスアーキテクチャに問題があると主張できます。それは本当かもしれませんが、大規模な成熟したプロジェクトでクラス構造を常に再構築またはリファクタリングできるとは限りません。さまざまなレベルの変更管理が1つの問題になる可能性がありますが、特に時間の制約が適用される場合は、リファクタリング後に既存の機能を同じように動作させることは、常に簡単な作業ではありません。成熟したプロジェクトでは、コードの再構築後にさまざまなリグレッションテストに合格しないようにするのは非常に困難です。多くの場合、不明瞭な「奇妙さ」が現れます。継承された機能が実行されない（または他の機能を実行する）必要がある場合に、同様の問題が発生しました。以下のアプローチは、除外する必要がある基本コードを別の仮想関数に配置することでした。次に、この関数を派生クラスでオーバーライドし、機能を除外または変更できます。この例では、「テキスト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.
    }
}

祖父母クラスからメンバーメソッドを継承し、2番目のクラスでそれをオーバーライドして、孫クラスからそのメソッドを再度呼び出すことに関して、これらの質問がたくさんあるようです。祖父母のメンバーを孫に継承するだけではどうですか？

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