Организация событий между классами

 public delegate void LOGHandler(TypeLog a, string mes);
class A
{  
   event LOGHandler LogEvent;
        public void SaveLOG(TypeLog type, string mes)
        {
                if (LogEvent == null)
                {
                LOGING log1 = new LOGING();
                    LogEvent += new LOGHandler(log1.LOGevent);
                }
                LogEvent(type, mes);
        }
}
 
class B
{
event LOGHandler LogEvent;
        public void SaveLOG(TypeLog type, string mes)
        {
                if (LogEvent == null)
                {
                LOGING log2 = new LOGING();
                    LogEvent += new LOGHandler(log2.LOGevent);
                }
                LogEvent(type, mes);
        }
 
}
 
class MAIN
{
  A _a;  B _b;   
  LOGING log3 = new LOGING();
}
 
class LOGING
{
  public void LOGevent(TypeLog type, string mes)
  {
  //код записи в файл
  }
}

public class A
{
    public void Foo()
    {
        SomeStaticClass.Foo();
    }
}
 
public class B
{
    public void Foo()
    {
        SomeStaticClass.Foo();
    }
}
 
public static class SomeStaticClass
{
    public static void Foo()
    {
        //some functional code
    }
}

public class HostClass
{
    public delegate void MyDelegate(int someValue);
    public event MyDelegate OnSomthingChanged;
 
    public void ChangeSomething()
    {
        var a = 123;
        OnSomthingChanged?.Invoke(a);
    }
}
 
public class UserClass
{
    public UserClass()
    {
         var hostClassObject = new HostClass();
         hostClassObject.OnSomthingChanged += OnEventFired;
    }
 
    public void OnEventFired(int someValue)
    {
         var a = someValue; //123;
     }
}

OnSomthingChanged?.Invoke(a);

if(OnSomthingChanged != null)
    OnSomthingChanged(1);

public class MyClass
    {
        public static event EventHandler MyEvent;
 
        public void RaiseEvent()
        {
            MyEvent?.Invoke(this, EventArgs.Empty);
        } 
    }
 
.....
......
MyClass.MyEvent += (sender, args) => { Debug.WriteLine("RISED"); };
 
var object1 = new MyClass();
var object2 = new MyClass();
 
object1.RaiseEvent();
object2.RaiseEvent();

 public class LOGGING
    {
        public static event EventHandler LOGEvent;
        public void podpis()
        {
            LOGGING.LOGEvent += (sender, args) => { Console.WriteLine("Logging"); };
        }     
        public void savelog()
        {
            LOGEvent?.Invoke(this, EventArgs.Empty);
        }
    }
 
    public class MAIN
    {
        LOGGING log;
        void init_log()
        {
            log.podpis();
        }
       void  work()
        {
            log.savelog();//печать лога
 
        }
 
    }

    public delegate void LOGHandler(TypeLog a, string mes);
 
    public class LOGGING
    {
        public static event EventHandler LOGEvent;
        public void podpis()
        {
            LOGGING.LOGEvent += (sender, args) => { Console.WriteLine("Logging"); };
        }     
        public void savelog()
        {
            LOGEvent?.Invoke(this, EventArgs.Empty);
        }
    }
 
    public class MAIN
    {
        LOGGING log;
        void init_log()
        {
            log.podpis();
        }
      
    }
 
 
    public class work
    {
        void Save(TypeLog type, string mes)
        {
            LOGGING.LogEvent(type, mes);
        }
 
    }

public static event EventHandler MyEvent;

public static void RiseEvent(object sender)
        {
            MyEvent?.Invoke(sender, EventArgs.Empty);
        }
 
.....
 
MyClass.RiseEvent(something); //rise from everywhere

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy =
        new Lazy<Singleton>(() => new Singleton());
    
    public static Singleton Instance { get { return lazy.Value; } }
 
    private Singleton()
    {
    }
}