using System;

namespace Lib
{
    public class Base
    {
        public virtual void Hello()
        {
            Console.WriteLine("Base::Hello()");
        }
    }

    public class Derived : Base
    {
        public override void Hello()
        {
            Console.WriteLine("Derived::Hello()");
        }
    }
}

// Program.cpp : main project file.

#include "stdafx.h"

using namespace System;
using namespace Lib;

int main(array<System::String ^> ^args)
{
    Derived^ derived = gcnew Derived();
    derived->Base::Hello();
    return 0;
}

public class Base
{
  public void DoWork()
  {
    CoreDoWork();
  }
  protected virtual void CoreDoWork() 
  {
    Console.WriteLine( "Base.DoWork()" );
  }
}
public class Derived : Base
{
  protected override void CoreDoWork() 
  {
    Console.WriteLine( "Derived.DoWork()" );
  }
}
//Применение шаблона NVI
public class EntryPoint
{
  static void Main() 
  {
    Base b = new Derived();
    b.DoWork();
  }
}

public class Base
{
  public virtual void DoWork() 
  {
     Console.WriteLine( "Base.DoWork()" );
  }
}
public class Derived : Base
{
  public override void DoWork() 
  {
    Console.WriteLine( "Derived.DoWork()" );
  }
}
public class EntryPoint
{
  static void Main() 
  {
    Base b = new Derived();
    b.DoWork();
  }
}

public class Base
{
  public void Work()
  {
    DoWork();
  }
  protected virtual void DoWork() 
  {
    Console.WriteLine( "Base.Work()" );
  }
}
public class Derived : Base
{
  public void Job()
    {
    }
  protected override void DoWork() 
  {
    Console.WriteLine( "Derived.Work()" );
  }
}

public class Derived : Base
{
  public virtual void Job() 
  {
     Console.WriteLine( "Derived.Job()" );
  }
}

А>public class Base
А>{
А>  public virtual void DoWork() 
А>  {
А>     Console.WriteLine( "Base.DoWork()" );
А>  }
А>}
А>public class Derived : Base
А>{
А>  public override void DoWork() 
А>  {
А>    Console.WriteLine( "Derived.DoWork()" );
А>  }
А>}
А>public class EntryPoint
А>{
А>  static void Main() 
А>  {
А>    Base b = new Derived();
А>    b.DoWork();
А>  }
А>} 
А>

A>>public class Derived : Base
A>>{
A>>  public virtual void Job() 
A>>  {
A>>     Console.WriteLine( "Derived.Job()" );
A>>  }
A>>}
A>>

class File {};

class ILogger
    {
    public:
                void    Write( std::string const& a_line );
    private:
        virtual void    DoWrite( std::string const& a_line ) = 0;
    };

class FileLogger : public ILogger
    {
    public:
                void    SetFile( File const& );
    private:
        virtual void    DoWrite( std::string const& a_line );
    private:
                File    file_;
    };
    
class ILogger2
    {
    public:
        virtual void    Write( std::string const& a_line );
    };

class FileLogger2 : public ILogger2
    {
    public:
                void    SetFile( File const& );
        virtual void    Write( std::string const& a_line );
    };

А>public class Base
А>{
А>  public void DoWork()
А>  {
А>    CoreDoWork();
А>  }
А>  protected virtual void CoreDoWork() 
А>  {
А>    Console.WriteLine( "Base.DoWork()" );
А>  }
А>}
А>public class Derived : Base
А>{
А>  protected override void CoreDoWork() 
А>  {
А>    Console.WriteLine( "Derived.DoWork()" );
А>  }
А>}
А>//Применение шаблона NVI
А>public class EntryPoint
А>{
А>  static void Main() 
А>  {
А>    Base b = new Derived();
А>    b.DoWork();
А>  }
А>}
А>

А>public class Base
А>{
А>  public virtual void DoWork() 
А>  {
А>     Console.WriteLine( "Base.DoWork()" );
А>  }
А>}
А>public class Derived : Base
А>{
А>  public override void DoWork() 
А>  {
А>    Console.WriteLine( "Derived.DoWork()" );
А>  }
А>}
А>public class EntryPoint
А>{
А>  static void Main() 
А>  {
А>    Base b = new Derived();
А>    b.DoWork();
А>  }
А>} 
А>

public class BaseFormatter
    {
        public void DoWork()
        {
            string message;

            message = FormatHeader("Hello message") + FormatBody("Hello world!");
            Console.WriteLine(message);
        }
        protected virtual string FormatHeader(string aMessage) { return ""; }
        protected virtual string FormatBody(string aMessage) { return ""; }
    }

    public class HTMLFormatter : BaseFormatter
    {
        protected override string FormatHeader(string aMessage)
        {
            return "<html> <header>" + aMessage + "</header>";
        }

        protected override string FormatBody(string aMessage)
        {
            return "<body> <p>" + aMessage + "</p> </body> </html>";
        }
    }

    public class XMLFormatter : BaseFormatter
    {
        protected override string FormatHeader(string aMessage)
        {
            return "<?xml version='1.0' encoding='utf-8' ?> <header>" + aMessage + "</header>";
        }
        protected override string FormatBody(string aMessage)
        {
            return "<body> <line> " + aMessage + "</line> </body>";
        }
    }

    //Применение шаблона NVI
    class Program
    {
        static void Main(string[] args)
        {
            BaseFormatter b = new HTMLFormatter();
            b.DoWork();
        }
    }

The template method is strongly related to the NVI (Non-Virtual Interface) pattern. The NVI pattern recognizes the benefits of a non-abstract method invoking the subordinate abstract methods. This level of indirection allows for pre and post operations relative to the abstract operations both immediately and with future unforseen changes.

Открытая виртуальная функция вынуждена выполнять две работы…