class Goodbye
{
  public Goodbye()
  {
     Console.WriteLine("hello");
  }

  ~Goodbye()
  {
     Console.WriteLine("goodbye");
  }
}

static void Main()
{
   new Goodbye();
   GC.Collect();
   GC.WaitForPendingFinalizers();
}

hello
goodbye

class Goodbye

class Goodbye : DontSayGoodbye

hello

 public class DontSayGoodbye
    {
        public DontSayGoodbye()
        {
            GC.SuppressFinalize(this);
        }
    }

class Base
{
    public Base()
    {
        GC.SuppressFinalize(this);
    }
}

class DontSayGoodbye : Base
{
}

class Goodbye : DontSayGoodbye
{
    public Goodbye()
    {
        Console.WriteLine("hello");
    }
    ~Goodbye()
    {
        Console.WriteLine("goodbye");
    }
}

class DontSayGoodbye 
{
    public DontSayGoodbye(params object[] objs)
    {
        GC.SuppressFinalize(this);
    }
}

    class DontSayGoodbye
    {
        protected class Console
        {
            static int writeCalls = 0;

            public static void WriteLine(string s)
            {
                if (writeCalls > 0)
                {
                    return;
                }

                System.Console.WriteLine(s);
                ++writeCalls;
            }
        }
    }

    abstract class DontSayGoodbye
    {
        protected abstract void Finalize();
    }

[DontSayGoodbye]
class DontSayGoodbye : ContextBoundObject
{
  internal sealed class DontSayGoodbyeAttribute : ProxyAttribute
  {
    private static object value;

    public override MarshalByRefObject CreateInstance(Type type) {
      var instance = value ?? (value = base.CreateInstance(type));
      return (MarshalByRefObject)instance;
    }
  }
}

    class DontSayGoodbye
    {
      ~DontSayGoodbye()
      {
        Console.Clear();
        Console.WriteLine("hello");
      }
    }

A>>    abstract class DontSayGoodbye
A>>    {
A>>        protected abstract void Finalize();
A>>    }
A>>

protected override void Finalize()
{
    try
    {
        Console.WriteLine("goodbye");
    }
    finally
    {
        base.Finalize();
    }
}

.method family hidebysig virtual instance void Finalize() cil managed
{
    .maxstack 1
    L_0000: nop 
    L_0001: ldstr "goodbye"
    L_0006: call void [mscorlib]System.Console::WriteLine(string)
    L_000b: nop 
    L_000c: nop 
    L_000d: leave.s L_0017
    L_000f: ldarg.0 
    L_0010: call instance void DontSayGoodbye::Finalize()
    L_0015: nop 
    L_0016: endfinally 
    L_0017: nop 
    L_0018: ret 
    .try L_0000 to L_000f finally handler L_000f to L_0017
}

Microsoft (R) .NET Framework PE Verifier.  Version  4.0.30319.1
Copyright (c) Microsoft Corporation.  All rights reserved.

[IL]: Error: [ConsoleApplication1.exe : Goodbye::Finalize][offset 0x00000010] Call not allowed on abstract methods.
1 Error(s) Verifying bin\Debug\ConsoleApplication1.exe

using System;
using System.Runtime.Remoting.Activation;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;

[DontSayGoodbye]
class DontSayGoodbye : ContextBoundObject
{
    sealed class DontSayGoodbyeRealProxy : RealProxy
    {
        public DontSayGoodbyeRealProxy(Type type) : base(type) { }

        public override IMessage Invoke(IMessage msg)
        {
            var ctorMsg = msg as IConstructionCallMessage;
            if (ctorMsg == null) throw new NotSupportedException();

            var o = InitializeServerObject(ctorMsg);
            GC.SuppressFinalize(GetUnwrappedServer());
            return o;
        }
    }

    sealed class DontSayGoodbyeAttribute : ProxyAttribute
    {
        public override MarshalByRefObject CreateInstance(Type type)
        {
            return (MarshalByRefObject) new DontSayGoodbyeRealProxy(type).GetTransparentProxy();
        }
    }
}

10.13 Destructors
...
Destructors are implemented by overriding the virtual method Finalize on System.Object. C# programs are not permitted to override this method or call it (or overrides of it) directly. For instance, the program
class A
{
override protected void Finalize() {} // error
public void F() {
this.Finalize(); // error
}
}
contains two errors.
The compiler behaves as if this method, and overrides of it, do not exist at all. Thus, this program:
class A
{
void Finalize() {} // permitted
}
is valid, and the method shown hides System.Object’s Finalize method.

class DontSayGoodbye 
{
    protected virtual void Finalize() {}
}