Trying to fight circular dependency with injections of functions

FunctionalInjection.cs

    public class Program
    {
        public static void Main(string[] args)
        {
            Func<IBar> barFunc = () =>
            {
                var barr = new Bar();
                return barr;
            };

            Func<IFoo> fooFunc = () =>
            {
                var fooo = new Foo(barFunc);
                return fooo;
            };

            var foo = fooFunc.Invoke();
            var bar = new Bar()
                            {
                                FooFunc = fooFunc,
                            };

            bar.DoBar();
        }
    }

    public interface IFoo
    {
        void DoFoo();
    }

    public class Foo : IFoo
    {
        private readonly Func<IBar> barFunc;

        public Foo(Func<IBar> barFunc)
        {
            this.barFunc = barFunc;
        }


        public void DoFoo()
        {
            var bar = barFunc.Invoke();
            bar.DoBar();

            Thread.Sleep(1000);
            Console.WriteLine("Executing Foo.DoFoo");
        }
    }
    
    
    public interface IBar
    {
        void DoBar();
    }

    public class Bar : IBar
    {
        public Func<IFoo> FooFunc { get; set; }

        public Bar()
        {
        }
        
        public void DoBar()
        {
            var foo = FooFunc.Invoke();
            foo.DoFoo();

            Thread.Sleep(1000);
            Console.WriteLine("Executing Foo.DoFoo");
        }
    }