Нужно ли для события создавать отдельный класс?

 class Class1  
    {
        public double a; 
        public double b; 
        public double c;
    }
 
 class Program
    {    
        static void Main(string[] args)
        {
            Class C = new Class(); //экземпляр класса 
            C.a = 5.8;
            C.b = 10.2;
            C.c = 0.0;
}
}

using System;
 
namespace ConsoleApplication1
{
    public class Something
    {
        protected double _value;
 
        public Something(double @value)
        {
            _value = @value;
        }
 
        public event EventHandler<ValueEventArgs> ValueChanged;
 
        protected virtual void OnValueChanged(ValueEventArgs e)
        {
            EventHandler<ValueEventArgs> handler = ValueChanged;
            if (handler != null) handler(this, e);
        }
 
 
        public double Value
        {
            get { return _value; }
            set
            {
                double oldValue = _value;
                _value = value;
                OnValueChanged(new ValueEventArgs(oldValue, value));
            }
        }
    }
}

using System;
 
namespace ConsoleApplication1
{
    public class ValueEventArgs : EventArgs
    {
        public ValueEventArgs(double oldValue, double newValue)
        {
            OldValue = oldValue;
            NewValue = newValue;
        }
 
        public double OldValue { get; protected set; }
        public double NewValue { get; protected set; }
    }
}

using System;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Something something = new Something(10d);
            something.ValueChanged += Something_ValueChanged;
            something.Value = 5.8;
            something.Value = 45d;
            something.Value = 34.6;
 
            something.ValueChanged -= Something_ValueChanged;
            something.Value = 23d;
            something.Value = 16d;
            something.Value = 31.5;
 
            Console.ReadKey();
        }
 
        static void Something_ValueChanged(object sender, ValueEventArgs e)
        {
            var some = (Something)sender; //для наглядности
            Console.WriteLine("Старое значение класса {0} = {1},\t новое = {2}",
                some.GetType().Name, e.OldValue, e.NewValue);
        }
    }
}

class Class1
{
    public double a;
    public double b;
    public double c;
 
 
 
    public event MyEventHandler MyEvent;    /// вот это наше событие
}

delegate void MyEventHandler(object sender, MyEventArgs e);

class MyEventArgs : EventArgs
{
    public double NewValue { get; set; }
 
    public MyEventArgs(double NewValue)
    {
        this.NewValue = NewValue;
    }
}

//....
MyEvent(this, new MyEventArgs(0));
//...

class Program
{
 
    static void Main(string[] args)
    {
        Class1 c1 = new Class1();          //экземпляр класса Class1 
        c1.MyEvent += c1_MyEvent;      //так мы подписываемся на событие. Это значит, что при срабатывании события
                                                     //конкретно в экземпляре c1 класса Class1 будет вызван метод  c1_MyEvent
    }
 
 
 
////к этому методу довольно простые требования: он должен соответствовать делегату MyEventHandler, то есть иметь
////тот же возвращаемый тип и такой же набор параметров. Имя метода может быть любым, c1_MyEvent я взял для 
////наглядности. static не обязательно, но в данном примере необходимо, так как   c1.MyEvent += c1_MyEvent мы
////выполняем в статическом методе Main.
    static void c1_MyEvent(object sender, MyEventArgs e) 
    {
        
    }
}

class MyEventArgs : EventArgs
    {
        public double NewValue { get; set; }
 
        public MyEventArgs(double NewValue)
        {
            this.NewValue = NewValue;
        }
    }
 
    delegate void MyEventHandler(object sender, MyEventArgs e);
 
 
    class Class1
    {
        private double _a;    // переменную a я сделал private, что вне класса её можно было изменить только
// через свойство. 
                              // Так проще контролировать когда она изменяется а когда нет.
 
        public double a       //непосредственно свойство a
        {
            get                 // метод get вызывется когда а оказфвается в правай части выражения от знака равно.
            {
                return _a;
            }
            set                // set вызывается когда а встречается слева от знака равно, т.е. ты ему
// что-то присваеваешь.
            {
                _a = value;     // сохраняем новое значение а
                MyEvent(this, new MyEventArgs(a));  // вызываем событие, как метод MyEvent и все методы,
// кто на него подписан, будут вызваны по очереди. 
            }
        }
 
        public event MyEventHandler MyEvent;
    }
 
 
    class Program
    {
 
        static void Main(string[] args)
        {
            Class1 c1 = new Class1();
            c1.MyEvent += c1_MyEvent;
        }
 
        static void c1_MyEvent(object sender, MyEventArgs e)
        {
        }
    }