Monogame using Raylib like update loop?

is there a way to abstract away the game class in monogame so it looks more like this…

`

public static class Game
{
     public static Main()
     {
         //init with title, width, height, and framerate
         MyMonoGameAbstraction.Init("my game", 128,128,60)

         //DoInit & DoLoad
         while(MyMonoGameAbstraction.IsRunning()) //Handles everything
         {
             //DoUpdate
            
             MyMonoGameAbstraction.BeginDraw()
             //DoRender
             MyMonoGameAbstraction.EndDraw()
         }
         //Unload
         MyMonoGameAbstraction.Quit()
     }
}

`

here is a example of something I would like to do…
sadly I don’t think asynchronous or synchronous programming would do much without redefining the game loop
`

#region Using Statements
using System;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Storage;
using Microsoft.Xna.Framework.Input;

#endregion

namespace ZeroFramework
{

	public static class Win
	{
		WinInst inst;
		public static void Init()
		{
			inst = new WinInst();
			while(!Initalized())
			{

			}
		}

		private async bool Initalized()
		{
			return Task.Run(() => DoInitalized());
		}
		private async Task<bool> DoInitalized()
		{
			while (!inst.loaded)
			{
				await false;
			}
			await true;
		}

		public bool IsRunning()
		{
			return inst.running;
		}

		public void DrawBegin()
		{
			inst.BeginDraw();
		}
		public void DrawEnd()
		{
			inst.EndDraw();
		}

		public void Exit()
		{
			inst.Quit();
		}
	}

	/// <summary>
	/// This is the main type for your game.
	/// </summary>
	internal class WinInst : Game
	{
		public bool loaded = false;
		public bool running = false;
		GraphicsDeviceManager graphics;
		SpriteBatch spriteBatch;

		public Game1()
		{
			graphics = new GraphicsDeviceManager(this);
			Content.RootDirectory = "Content";
			graphics.IsFullScreen = true;
		}

		/// <summary>
		/// Allows the game to perform any initialization it needs to before starting to run.
		/// This is where it can query for any required services and load any non-graphic
		/// related content.  Calling base.Initialize will enumerate through any components
		/// and initialize them as well.
		/// </summary>
		protected override void Initialize()
		{
			// TODO: Add your initialization logic here
			base.Initialize();
		}

		/// <summary>
		/// LoadContent will be called once per game and is the place to load
		/// all of your content.
		/// </summary>
		protected override void LoadContent()
		{
			// Create a new SpriteBatch, which can be used to draw textures.
			spriteBatch = new SpriteBatch(GraphicsDevice);
			loaded = true;

			//TODO: use this.Content to load your game content here 
		}

		protected override void UnloadContent()
		{
			running = false;
		}
		/// <summary>
		/// Allows the game to run logic such as updating the world,
		/// checking for collisions, gathering input, and playing audio.
		/// </summary>
		/// <param name="gameTime">Provides a snapshot of timing values.</param>
		protected override void Update(GameTime gameTime)
		{
			if (!running) running = true;
			// For Mobile devices, this logic will close the Game when the Back button is pressed
			// Exit() is obsolete on iOS
#if !__IOS__ && !__TVOS__
			if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed ||
				Keyboard.GetState().IsKeyDown(Keys.Escape))
			{
				Exit();
			}
#endif
			// TODO: Add your update logic here			
			base.Update(gameTime);
		}

		/// <summary>
		/// This is called when the game should draw itself.
		/// </summary>
		/// <param name="gameTime">Provides a snapshot of timing values.</param>
		protected override void Draw(GameTime gameTime)
		{
			GraphicsDevice.Clear(Color.CornflowerBlue);

			//TODO: Add your drawing code here

			base.Draw(gameTime);
		}

		public void BeginDraw()
		{
			SpriteBatch.Begin();
		}

		public void EndDraw()
		{
			spriteBatch.End();
		}
		public void Quit()
		{
			this.Exit();
		}
	}
}

`