Чи можна замінити невіртуальний метод?

Чи є спосіб замінити невіртуальний метод? або щось, що дає подібні результати (крім створення нового методу для виклику бажаного методу)?

Я хотів би замінити метод, Microsoft.Xna.Framework.Graphics.GraphicsDeviceмаючи на увазі модульне тестування.

Ні, ви не можете замінити невіртуальний метод. Найближче, що ви можете зробити, це приховати метод, створивши newметод з такою ж назвою, але це не доцільно, оскільки це порушує хороші принципи проектування.

Але навіть приховування методу не дасть вам часу виконання поліморфного відправлення викликів методів, як справжній виклик віртуального методу. Розглянемо цей приклад:

using System;

class Example
{
    static void Main()
    {
        Foo f = new Foo();
        f.M();

        Foo b = new Bar();
        b.M();
    }
}

class Foo
{
    public void M()
    {
        Console.WriteLine("Foo.M");
    }
}

class Bar : Foo
{
    public new void M()
    {
        Console.WriteLine("Bar.M");
    }
}

У цьому прикладі обидва виклики Mметоду print Foo.M. Як ви можете бачити , цей підхід дійсно дозволяє мати нову реалізацію методу до тих пір , як посилання на цей об'єкт має правильний похідний тип , але приховує базовий метод робить перерву поліморфізм.

Я б рекомендував вам не приховувати базові методи таким чином.

Я схильний дотримуватися тих, хто віддає перевагу поведінці за замовчуванням C #, згідно з якою методи за замовчуванням невіртуальні (на відміну від Java). Я пішов би ще далі і сказав, що класи також повинні бути запечатані за замовчуванням. Спадщину важко розробити належним чином, і той факт, що існує метод, який не позначений як віртуальний, вказує на те, що автор цього методу ніколи не передбачав, щоб метод був замінений.

Змінити: "час виконання поліморфного відправлення" :

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

Якби я зателефонував b.Fooу такому випадку, CLR правильно визначив би тип об’єкта, на який bвказує посилання, Barі надсилав би виклик Mналежним чином.

Ні, ти не можеш.

Ви можете замінити лише віртуальний метод - див. MSDN тут :

У C # похідні класи можуть містити методи з тим самим іменем, що і методи базового класу.

• Метод базового класу повинен бути визначений віртуальним.

Якщо базовий клас не запечатаний, тоді ви можете успадкувати його та написати новий метод, який приховує базовий (використовуйте ключове слово "new" у декларації методу). В іншому випадку ні, ви не можете його замінити, оскільки оригінальні автори ніколи не прагнули його замінити, отже, чому він не є віртуальним.

Я думаю, що ви перевантажуєтесь і перевизначаєте плутанину, перевантаження означає, що у вас є два або більше методів з однаковим іменем, але різні набори параметрів, а перевизначення означає, що у вас є інша реалізація методу у похідному класі (тим самим замінюючи або змінюючи поведінку в базовому класі).

Якщо метод віртуальний, ви можете замінити його, використовуючи ключове слово override у виведеному класі. Однак невіртуальні методи можуть приховати лише базову реалізацію, використовуючи нове ключове слово замість ключового слова override. Невіртуальний маршрут марний, якщо абонент отримує доступ до методу за допомогою змінної, введеної в якості базового типу, оскільки компілятор використовував би статичну відправку до базового методу (мається на увазі, що код у вашому похідному класі ніколи не буде викликаний).

Ніколи ніщо не заважає вам додати перевантаження до існуючого класу, але лише код, який знає про ваш клас, зможе отримати до нього доступ.

Ви не можете замінити невіртуальний метод будь-якого класу в C # (без злому CLR), але ви можете замінити будь-який метод інтерфейсу, який реалізує клас. Поміркуйте, що ми не запечатали

class GraphicsDevice: IGraphicsDevice {
    public void DoWork() {
        Console.WriteLine("GraphicsDevice.DoWork()");
    }
}

// with its interface
interface IGraphicsDevice {
    void DoWork();
}

// You can't just override DoWork in a child class,
// but if you replace usage of GraphicsDevice to IGraphicsDevice,
// then you can override this method (and, actually, the whole interface).

class MyDevice: GraphicsDevice, IGraphicsDevice {
    public new void DoWork() {
        Console.WriteLine("MyDevice.DoWork()");
        base.DoWork();
    }
}

І ось демо

class Program {
    static void Main(string[] args) {

        IGraphicsDevice real = new GraphicsDevice();
        var myObj = new MyDevice();

        // demo that interface override works
        GraphicsDevice myCastedToBase = myObj;
        IGraphicsDevice my = myCastedToBase;

        // obvious
        Console.WriteLine("Using real GraphicsDevice:");
        real.DoWork();

        // override
        Console.WriteLine("Using overriden GraphicsDevice:");
        my.DoWork();

    }
}

У випадку, якщо ви успадковуєте від непохідного класу, ви можете просто створити абстрактний супер клас і натомість успадкувати його від нього.

Чи є спосіб замінити невіртуальний метод? або щось, що дає подібні результати (крім створення нового методу для виклику бажаного методу)?

Ви не можете замінити невіртуальний метод. Однак ви можете використовувати newключове слово модифікатор, щоб отримати подібні результати:

class Class0
{
    public int Test()
    {
        return 0;
    }
}

class Class1 : Class0
{
    public new int Test()
    {
        return 1;
    }
}
. . .
// result of 1
Console.WriteLine(new Class1().Test());

Ви також хочете переконатися, що модифікатор доступу також однаковий, інакше ви не отримаєте спадщину по лінії. Якщо інший клас успадковує від Class1по newключовим словами в Class1не впливатиме на об'єкти , наслідуючи від нього, якщо модифікатор доступу не одне і те ж.

Якщо модифікатор доступу НЕ те ж саме:

class Class0
{
    protected int Test()
    {
        return 0;
    }
}

class Class1 : Class0
{
    // different access modifier
    new int Test()
    {
        return 1;
    }
}

class Class2 : Class1
{
    public int Result()
    {
        return Test();
    }
}
. . .
// result of 0
Console.WriteLine(new Class2().Result());

... проти , якщо модифікатор доступу є те ж саме:

class Class0
{
    protected int Test()
    {
        return 0;
    }
}

class Class1 : Class0
{
    // same access modifier
    protected new int Test()
    {
        return 1;
    }
}

class Class2 : Class1
{
    public int Result()
    {
        return Test();
    }
}
. . .
// result of 1
Console.WriteLine(new Class2().Result());

Як зазначалося в попередній відповіді, це не є хорошим принципом дизайну.

Існує спосіб досягти цього за допомогою абстрактного класу та абстрактного методу.

Поміркуйте

Class Base
{
     void MethodToBeTested()
     {
        ...
     }

     void Method1()
     {
     }

     void Method2()
     {
     }

     ...
}

Тепер, якщо ви хочете мати різні версії методу MethodToBeTested (), то змініть Class Base на абстрактний клас і метод MethodToBeTested () як абстрактний метод

abstract Class Base
{

     abstract void MethodToBeTested();

     void Method1()
     {
     }

     void Method2()
     {
     }

     ...
}

З абстрактним методом void MethodToBeTested () виникає проблема; впровадження зникло.

Отже, створити a, class DefaultBaseImplementation : Baseщоб мати реалізацію за замовчуванням.

І створіть інший, class UnitTestImplementation : Baseщоб мати реалізацію модульного тесту.

За допомогою цих 2 нових класів функціональність базового класу може бути замінена.

Class DefaultBaseImplementation : Base    
{
    override void MethodToBeTested()    
    {    
        //Base (default) implementation goes here    
    }

}

Class UnitTestImplementation : Base
{

    override void MethodToBeTested()    
    {    
        //Unit test implementation goes here    
    }

}

Зараз у вас є 2 класи реалізації (перевизначення) MethodToBeTested().

Ви можете створити екземпляр (похідного) класу за необхідності (тобто з базовою реалізацією або з реалізацією модульного тесту).