"Ereditare" una classe Statica

Diciamo che per concetto è una cosa che non si può fare.

In questo esempio propongo un interessante workaround per poter ovviare alla potenziale "intenzione" di ereditare una classe statica.

public static class RealWriter
 {
     public static void Write(string text)
     {        
         Console.WriteLine(text);         
     }
 }

 public class BaseWriter
 {
     public virtual void VirtualWrite(string text)
     {
         RealWriter.Write(text);
         WriteToLog(text);
     }

     private void WriteToLog(string text)
     {
         TextWriter tw = new StreamWriter(@"c:\Logfile.txt",true);
         tw.WriteLine(
                         DateTime.Now.ToShortDateString() + "|" +
                         DateTime.Now.ToShortTimeString() + "|" +
                         text
                     );
         tw.Close();
     }
 }


 public class LineWriter:BaseWriter
 {
     public override void  VirtualWrite(string text)
     {        
         base.VirtualWrite(text);
     }
 }

Qualche piccola delucidazione:



RealWriter è una classe statica "la cui provenienza potrebbe essere ignota" ossia una classe che proviene da un assembly esterno. Una reference per intenderci.

BaseWriter è nel nostro assembly, tecnicamente lo scopo di questa classe è di incapsulare/wrappare quanto è già stato realizzato per "eseguire delle altre cose in aggiunta"
In questo esempio il log...

LineWriter estende base writer in modo da non dover creare un legame troppo rigido con RealWriter.

L'esempio è decisamente banale e sono più che convinto che vi siano molti altri modi per rendere questa situazione.

public class BaseWriterDelegate
  {
      delegate void _RealWriter(string text);

      _RealWriter handlersToRW;

      public BaseWriterDelegate()
      {
          handlersToRW = WriteToConsole;
          handlersToRW += WriteToLog;

      }

      public virtual void VirtualWrite(string text)
      {
          handlersToRW(text);          
      }

      private void WriteToConsole(string text)
      {
          RealWriter.Write(text);
      }

      private void WriteToLog(string text)
      {
          TextWriter tw = new StreamWriter(@"c:\Logfile.txt", true);
          tw.WriteLine(
                          DateTime.Now.ToShortDateString() + "|" +
                          DateTime.Now.ToShortTimeString() + "|" +
                          text
                      );
          tw.Close();
      }
  }



  public class LineWriter:BaseWriterDelegate
  {
      public override void VirtualWrite(string text)
      {         
          base.VirtualWrite(text);
      }
  }

Si può anche far così ... volendo sfruttando i delegati, il discorso non cambia.

Di concetto rimane il fatto che il chiamante utilizzerà LineWriter senza aver percezione di ciò che avverà sotto!