How to group custom events
Review Solution 1
Sacrificing usability for the common consumer of your API in order to gain some usability for specific consumers that happen to subscribe on a multitude of events, should never be considered best practice.

Action&lt;Game1, EventArgs&gt; InitializeEvent;
public virtual void Initialize(object o, EventArgs e) 
{ 
    // the average consumer does not want to cast here 
    // if he only wants to be subscribed to this event -&gt;
    InitializeEventArgs initializeEventArgs = (InitializeEventArgs)e; 
}


Review Solution 2
Grouping events together is a better approach, since the common consumer is not impacted. It is an augmentation, rather than a substitution, of the event pattern. Though your implementation using a struct is viable, I would opt to use a more common approach - the Callback Interface.

public struct Events
{
    public Action&lt;Game1, MoveEventArgs&gt; MoveEvent { get; set; }
    public Action&lt;Game1, InitializeEventArgs&gt; InitializeEvent { get; set; }
    public Action&lt;Game1, DrawEventArgs&gt; DrawEvent { get; set; }
    public Action&lt;Game1, LoadContentEventArgs&gt; LoadContentEvent { get; set; }
}



Proposed Solution
You should determine whether to use either events, a callback interface or a mixture of both.
Let's assume you would like consumers to be able to subscribe to single events, and allow specific consumers to subscribe to all of them. The mixture of events and a callback interface could be implemented as follows.
Create event arguments
public class MoveEventArgs : EventArgs { /* .. impl */ }
public class InitializeEventArgs : EventArgs { /* .. impl */ }
public class DrawEventArgs : EventArgs { /* .. impl */ }
public class LoadContentEventArgs : EventArgs { /* .. impl */ }

Create a callback interface that bundles handlers for all the relevant events.
 public interface IGameListener
 {
      void OnMove(Game1 game, MoveEventArgs e);
      void OnInitialize(Game1 game, InitializeEventArgs e);
      void OnDraw(Game1 game, DrawEventArgs e);
      void OnLoadContent(Game1 game, LoadContentEventArgs e);
 }

As discussed, you may want to create an adapter. This allows derived classes to decide which event handlers to override.
public abstract class GameAdapter : IGameListener
{
      public virtual void OnMove(Game1 game, MoveEventArgs e) {}
      public virtual void OnInitialize(Game1 game, InitializeEventArgs e) {}
      public virtual void OnDraw(Game1 game, DrawEventArgs e) {}
      public virtual void OnLoadContent(Game1 game, LoadContentEventArgs e) {}
}

Game1 uses events and allows for registration of specific listeners. If you don't like to 'pollute' the game with these actions, you could let a mediator perform the registration of the callback interface. Argument checks are omitted for brevity.
 public class Game1
 {
        public event Action&lt;Game1, MoveEventArgs&gt; MoveEvent;
        public event Action&lt;Game1, InitializeEventArgs&gt; InitializeEvent;
        public event Action&lt;Game1, DrawEventArgs&gt; DrawEvent;
        public event Action&lt;Game1, LoadContentEventArgs&gt; LoadContentEvent;

        public void Register(IGameListener listener)
        {
            MoveEvent += listener.OnMove;
            InitializeEvent += listener.OnInitialize;
            DrawEvent += listener.OnDraw;
            LoadContentEvent += listener.OnLoadContent;
        }

        public void Unregister(IGameListener listener)
        {
            MoveEvent -= listener.OnMove;
            InitializeEvent -= listener.OnInitialize;
            DrawEvent -= listener.OnDraw;
            LoadContentEvent -= listener.OnLoadContent;
        }

        // other instance code ..
 }