Mine

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;

using xna_Fegelein.Sources.ServiceProviders;
using xna_Fegelein.Sources.GameComponents;
using xna_Fegelein.Sources.Utilities;

namespace xna_Fegelein
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Game, IContentManagerService
    {
        /// <summary>
        /// Private members
        /// </summary>
        private GraphicsDeviceManager graphics;
        private ContentManager content;

        /// <summary>
        /// Properties
        /// </summary>
        public ContentManager ContentManager
        {
            get
            {
                return this.content;
            }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public Game1()
        {
            // Init the graphics device and content pipeline
            this.graphics = new GraphicsDeviceManager(this);
            this.content = new ContentManager(Services);

            // Init the camera manager
            CameraManager cameraManager = new CameraManager(this);
            this.Components.Add(cameraManager);

            // Init the input component
            InputManager inputManager = new InputManager(this);
            this.Components.Add(inputManager);

            // Init the measureFPS component
            MeasureFPS measureFPS = new MeasureFPS(this);
            // this.Components.Add(measureFPS);

            // Init the MySpaceWarShip component
            MySpaceWarShip mySpaceWarShip = new MySpaceWarShip(this);
            // this.Components.Add(mySpaceWarShip);

            // Init the DrawPrimitives component
            DrawPrimitives drawPrimitives = new DrawPrimitives(this);
            // this.Components.Add(drawPrimitives);

            DrawTriangle drawTriangle = new DrawTriangle(this, 1000);
            //this.Components.Add(drawTriangle);

            DrawTorus drawTorus = new DrawTorus(this, 1000, 500, 25, 25);
            this.Components.Add(drawTorus);

            Grid gridComponent = new Grid(this, 16, 1000, GridLayout.DirectionZ, Color.Yellow);
            //this.Components.Add(gridComponent);

            // Add the contentManager service
            this.Services.AddService(typeof(IContentManagerService), this);
        }

        /// <summary>
        /// Method that handles the update event of the FPS counter,
        /// updates the window title to display the number of frames
        /// </summary>
        /// <param name="totalFrames">integer number of total frames</param>
        private void component_OnUpdate(int totalFrames)
        {
            this.Window.Title = String.Format("FPS: {0}", totalFrames);
        }


        /// <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>
        /// Load your graphics content.  If loadAllContent is true, you should
        /// load content from both ResourceManagementMode pools.  Otherwise, just
        /// load ResourceManagementMode.Manual content.
        /// </summary>
        /// <param name="loadAllContent">Which type of content to load.</param>
        protected override void LoadGraphicsContent(bool loadAllContent)
        {
            if (loadAllContent)
            {
            }

            // TODO: Load any ResourceManagementMode.Manual content
        }


        /// <summary>
        /// Unload your graphics content.  If unloadAllContent is true, you should
        /// unload content from both ResourceManagementMode pools.  Otherwise, just
        /// unload ResourceManagementMode.Manual content.  Manual content will get
        /// Disposed by the GraphicsDevice during a Reset.
        /// </summary>
        /// <param name="unloadAllContent">Which type of content to unload.</param>
        protected override void UnloadGraphicsContent(bool unloadAllContent)
        {
            if (unloadAllContent == true)
            {
                this.content.Unload();
            }
        }


        /// <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)
        {
            // Allows the default game to exit on Xbox 360 and Windows
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            // 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)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

            base.Draw(gameTime);
        }
    }
}