CallOnce My slution

 public class OnceFlag
 {
        private const int NotCalled = 0;
        private const int Called = 1;
        private int _state = NotCalled;

        public ManualResetEvent _resetHanlde = new ManualResetEvent(false);

        internal void SetHandle()
        {
            _resetHanlde.Set();
        }

        internal void WaitHandle()
        {
            _resetHanlde.WaitOne();
        }

        internal void ResetHandle()
        {
            _resetHanlde.Reset();
        }

        internal bool CheckIfNotCalledAndSet
        {
            get
            {
                var prev = Interlocked.Exchange(ref _state, Called);

                return prev == NotCalled;
            }
        }

        internal void Reset()
        {
            Interlocked.Exchange(ref _state, NotCalled);
            _resetHanlde.Reset();
        }

 }

 public static class Call
 {   public static void Once(OnceFlag flag, Action action)
        {
            if (flag.CheckIfNotCalledAndSet)
            {
                action.Invoke();

                flag.SetHandle();
            }

            flag.WaitHandle();
        }
 }

/***********************************
Testing the performance:
**////////////////////////////////
class Program
{
        static OnceFlagSimple _drorFlag = new OnceFlagSimple();
        static OnceFlag _mineFlag = new OnceFlag();

        static void Main(string[] args)
        {
            var watch = new Stopwatch();

            watch.Start();
            DrorTest();
            watch.Stop();

            Console.WriteLine("It took to Dror: " + watch.Elapsed);

            watch.Reset();

            watch.Start();
            MineTest();
            watch.Stop();

            Console.WriteLine("It took to me  : " + watch.Elapsed);
        }

        static void MineTest()
        {
            var t1 = new Thread(() => MineDoOnce(1));
            var t2 = new Thread(() => MineDoOnce(2));
            var t3 = new Thread(() => MineDoOnce(3));
            var t4 = new Thread(() => MineDoOnce(4));

            t1.Start();
            t2.Start();
            t3.Start();
            t4.Start();

            t1.Join();
            t2.Join();
            t3.Join();
            t4.Join();
        }

        static void MineDoOnce(int index)
        {
            Call.Once(_mineFlag, () => Console.WriteLine("Callled (" + index + ")"));
        }

        static void DrorTest()
        {
            var t1 = new Thread(() => DrorDoOnce(1));
            var t2 = new Thread(() => DrorDoOnce(2));
            var t3 = new Thread(() => DrorDoOnce(3));
            var t4 = new Thread(() => DrorDoOnce(4));

            t1.Start();
            t2.Start();
            t3.Start();
            t4.Start();

            t1.Join();
            t2.Join();
            t3.Join();
            t4.Join();

        }

        static void DrorDoOnce( int index)
        {
            Call.Once(_drorFlag, () => Console.WriteLine("Callled (" + index + ")"));
        }
}

/***************************************
Results:
Callled (1)
It took to Dror: 00:00:00.0034065
Callled (1)
It took to me  : 00:00:00.0018291
Press any key to continue . . .
**//////////////////////////////////