Использование паттерна “Команда”

      public
      abstract
      class AbstractCommand
{
  protectedstring _name;
  protectedstring _caption;
  protectedstring _description;
  protectedbool _enabled;
  protectedbool _visible;
  protected Image _icon;
  protected Shortcut _shortcut;

  public AbstractCommand()
  {
    _visible = true;
    _enabled = true;
    _shortcut = Shortcut.None;
  }
  
  publicstring Name
  {
    get
    {
      return _name;
    }
  }

  publicstring Caption
  {
    get
    {
      return _caption;
    }
  }

  publicstring Description
  {
    get
    {
      return _description;
    }
  }

  public Image Icon
  {
    get
    {
      return _icon;
    }
  }

  publicbool Enabled
  {
    get
    {
      return _enabled;
    }
    set
    {
      _enabled = value;
      OnChange();
    }
  }

  publicbool Visible
  {
    get
    {
      return _visible;
    }
    set
    {
      _visible = value;
      OnChange();
    }
  }

  public Shortcut Shortcut
  {
    get
    {
      return _shortcut;
    }
    set
    {
      _shortcut = value;
    }
  }

  publicevent EventHandler Changed;

  protectedvoid OnChange()
  {
    if (Changed != null)
      Changed(this, EventArgs.Empty);
  }

  publicabstractvoid Execute();
  
  publicvirtualvoid Execute(object argument)
  {
    Execute();
  }
}

      public MenuItemEx(AbstractCommand command)
{
  _command = command;
  Text = command.Caption;
  _icon = command.Icon;
  OwnerDraw = true;
  Update();
  command.Changed += new System.EventHandler(command_Changed);
}

privatevoid Update()
{
  Enabled = _command.Enabled;
  Visible = _command.Visible;
  Shortcut = _command.Shortcut;
}

privatevoid command_Changed(object sender, System.EventArgs e)
{
  Update();
}

      protected
      override
      void OnClick(System.EventArgs e)
{
  base.OnClick(e);
  if (_command != null)
  _command.Execute();
}

        public
        static Bitmap GetBitmap(string key, bool transparent)
{
  if (!_cache.ContainsKey(key))
  {
    try
    {
      Bitmap myBitmap = new Bitmap(GetStream(key));
      if (transparent)
      {
        Color backColor = myBitmap.GetPixel(0, 0);
        myBitmap.MakeTransparent(backColor);
      }
      _cache.Add(key, myBitmap);
    }
    catch(Exception)
    {
      returnnull;
    }
  }
  return (Bitmap)_cache[key];
}

      public
      class ExitApplication: AbstractCommand
{
  private Form _form;

  public ExitApplication(Form form)
  {
    _caption = "Exit";
    _form = form;
  }
  
  publicoverridevoid Execute()
  {
    if (MessageBox.Show("Are you really want to exit?", "Exit", MessageBoxButtons.OKCancel, 
          MessageBoxIcon.Warning) == DialogResult.OK)
      _form.Close();
  }
}

      public
      abstract
      class EditCommand: AbstractCommand
{
  protected IEditable _subject;

  public IEditable Subject
  {
    get
    {
      return _subject;
    }
    set
    {
      _subject = value;
    }
  }
}

      public
      class Delete: EditCommand
{
  public Delete()
  {
    _caption = "Delete";
    _name = CommandNames.Delete;
    _icon = ResourceHolder.GetBitmap("delete.bmp");
    _shortcut = Shortcut.Del;
    _enabled = false;
  }
  
  publicoverridevoid Execute()
  {
    if (_subject != null)
      _subject.Delete();
  }
}

      public
      void Register(AbstractCommand command)
{
  _commands[command.Name] = command;
}

public AbstractCommand GetCommand(string name)
{
  return (AbstractCommand)_commands[name];
}

      private
      void CreateMenu()
{
  this.Menu = new MainMenu();

  MenuItem file = Menu.MenuItems.Add("File");
  AddMenuItem(file, new NewProject(), true, false);
  AddMenuItem(file, new OpenProject(), true, false);
  AddMenuItem(file, new SaveProject(), true, false);
  file.MenuItems.Add( new MenuItem("-") );
  AddMenuItem(file, new ShowExplorer(), false, false);
  file.MenuItems.Add( new MenuItem("-") );
  AddMenuItem(file, new ExitApplication(this), false, false);

  MenuItem edit = Menu.MenuItems.Add("Edit");
  AddMenuItem(edit, new Delete(), true, true);
  AddMenuItem(edit, new Cut(), true, true);
  AddMenuItem(edit, new Copy(), true, true);
  AddMenuItem(edit, new Paste(), true, true);

  MenuItem project = Menu.MenuItems.Add("Project");
  AddMenuItem(project, new AddTextItem(), false, true);
  AddMenuItem(project, new AddImageItem(), false, true);
}

privatevoid AddMenuItem(
  MenuItem parent, AbstractCommand command, bool toolBar, bool register)
{
  parent.MenuItems.Add(new MenuItemEx(command));
  if (toolBar)
    AddToolBarButton(command);

  if (register)
    CommandManager.Instance.Register(command);
}

privatevoid AddToolBarButton(AbstractCommand command)
{
  ToolBarButton button = new ToolBarButton();
  button.Tag = command;
  button.ToolTipText = command.Description;
  button.Enabled = command.Enabled;
  button.Visible = command.Visible;
  if (command.Icon != null)
  {
    _toolBarImages.Images.Add(command.Icon);
    button.ImageIndex = _toolBarImages.Images.Count-1;
  }
  else
    button.Text = command.Caption;

  _toolBar.Buttons.Add( button );
  command.Changed += new EventHandler(command_Changed);
}

privatevoid _toolBar_ButtonClick(
  object sender, ToolBarButtonClickEventArgs e)
{
  AbstractCommand command = e.Button.Tag as AbstractCommand;
  if (command != null)
    command.Execute();
}

privatevoid command_Changed(object sender, EventArgs e)
{
  foreach(ToolBarButton button in _toolBar.Buttons)
    if (button.Tag == sender)
    {
      button.Enabled = ((AbstractCommand)sender).Enabled;
      button.Visible = ((AbstractCommand)sender).Visible;
    }
}

      public ExplorerForm()
{
  InitializeComponent();
  
  _contextMenu.MenuItems.Add( new MenuItemEx(CommandManager.Instance.
    GetCommand(CommandNames.AddText)) );
  _contextMenu.MenuItems.Add( new MenuItemEx(CommandManager.Instance.
    GetCommand(CommandNames.AddImage)) );
  _contextMenu.MenuItems.Add( new MenuItem("-") );
  _contextMenu.MenuItems.Add( new MenuItemEx(CommandManager.Instance.
    GetCommand(CommandNames.Delete)) );
}

      private
      void UpdateCommands(IEditable subject)
{
  EditCommand com = (EditCommand)CommandManager.Instance.
    GetCommand(CommandNames.Delete);
  com.Subject = subject;
  com.Enabled = subject != null;
}

      private
      void ExplorerForm_Enter(object sender, System.EventArgs e)
{
  if (SelectedItem != null)
    UpdateCommands(this);
  else
    UpdateCommands(null);
}

privatevoid ExplorerForm_Leave(object sender, System.EventArgs e)
{
  UpdateCommands(null);
}

privatevoid _treeView_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
  if (SelectedItem != null)
    UpdateCommands(this);
  else
    UpdateCommands(null);
}

      private
      void _treeView_DoubleClick(object sender, System.EventArgs e)
{
  if (SelectedItem != null)
  {
    AbstractCommand com = CommandManager.Instance.
      GetCommand(CommandNames.EditProjectItem);
    com.Execute(SelectedItem);
  }
}