[C# - VS2005]Menu riusabile ed eventi buttons

[RaouL_BennetH]

Ciao a tutti

Ho fatto una piccola classe che mi serve per avere sempre a portata di mano un menu da riutilizzare nei miei programmini. Quello che non riesco a capire, è come associare ai button presenti nel menu, i vari eventi come ad esempio il "click".

Il codice della classe è questo:

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace ReusableCode
{
    partial class ReusableMenu
    {
        
        
        private ToolStrip generalMenu;
        private ToolStripMenuItem prepareNew;
        private ToolStripMenuItem prepareSave;
        private ToolStripMenuItem prepareUpdate;
        private ToolStripMenuItem prepareDelete;
        private ToolStripMenuItem prepareCancel;
        private ToolStripMenuItem preparePrint;
        private ToolStripMenuItem prepareExit;
        private ToolStripSeparator[] sep;
        

        public ToolStrip MyMenu()
        {
            this.generalMenu = new ToolStrip();
            this.prepareNew = new ToolStripMenuItem();
            this.prepareSave = new ToolStripMenuItem();
            this.prepareUpdate = new ToolStripMenuItem();
            this.prepareDelete = new ToolStripMenuItem();
            this.prepareCancel = new ToolStripMenuItem();
            this.preparePrint = new ToolStripMenuItem();
            this.prepareExit = new ToolStripMenuItem();
            this.sep = new ToolStripSeparator[6];
            this.sep[0] = new ToolStripSeparator();
            this.sep[1] = new ToolStripSeparator();
            this.sep[2] = new ToolStripSeparator();
            this.sep[3] = new ToolStripSeparator();
            this.sep[4] = new ToolStripSeparator();
            this.sep[5] = new ToolStripSeparator();
            
            this.generalMenu.SuspendLayout();
            this.generalMenu.Dock = DockStyle.Top;
            this.generalMenu.GripStyle = ToolStripGripStyle.Visible;
            this.generalMenu.Items.AddRange(new ToolStripItem[] { this.prepareNew, 
                this.sep[0],
                this.prepareSave, 
                this.sep[1],
                this.prepareUpdate,
                this.sep[2],
                this.prepareDelete,
                this.sep[3],
                this.prepareCancel,
                this.sep[4],
                this.preparePrint,
                this.sep[5],
                this.prepareExit });
            
            this.generalMenu.Location = new Point(3, 0);
            this.generalMenu.Name = "mainMenu";
            this.generalMenu.Size = new Size(1000, 25);
            this.generalMenu.TabIndex = 0;


            this.prepareNew.DisplayStyle = ToolStripItemDisplayStyle.Text;
            this.prepareNew.Name = "AddNew";
            this.prepareNew.Size = new Size(66, 22);
            this.prepareNew.Text = "&Nuovo";
            this.prepareNew.Font = new Font("Verdana", 9F);
            this.prepareNew.ForeColor = Color.SteelBlue;

            this.prepareSave.DisplayStyle = ToolStripItemDisplayStyle.Text;
            this.prepareSave.Name = "SaveIt";
            this.prepareSave.Size = new Size(66, 22);
            this.prepareSave.Text = "&Salva";
            this.prepareSave.Font = new Font("Verdana", 9F);
            this.prepareSave.ForeColor = Color.SteelBlue;

            this.prepareUpdate.DisplayStyle = ToolStripItemDisplayStyle.Text;
            this.prepareUpdate.Name = "Update";
            this.prepareUpdate.Size = new Size(66, 22);
            this.prepareUpdate.Text = "&Modifica";
            this.prepareUpdate.Font = new Font("Verdana", 9F);
            this.prepareUpdate.ForeColor = Color.SteelBlue;

            this.prepareDelete.DisplayStyle = ToolStripItemDisplayStyle.Text;
            this.prepareDelete.Name = "Delete";
            this.prepareDelete.Size = new Size(66, 22);
            this.prepareDelete.Text = "&Elimina";
            this.prepareDelete.Font = new Font("Verdana", 9F);
            this.prepareDelete.ForeColor = Color.SteelBlue;

            this.prepareCancel.DisplayStyle = ToolStripItemDisplayStyle.Text;
            this.prepareCancel.Name = "Cancel";
            this.prepareCancel.Size = new Size(66, 22);
            this.prepareCancel.Text = "&Annulla";
            this.prepareCancel.Font = new Font("Verdana", 9F);
            this.prepareCancel.ForeColor = Color.SteelBlue;
            
            this.preparePrint.DisplayStyle = ToolStripItemDisplayStyle.Text;
            this.preparePrint.Name = "Print";
            this.preparePrint.Size = new Size(66, 22);
            this.preparePrint.Text = "Stam&pa";
            this.preparePrint.Font = new Font("Verdana", 9F);
            this.preparePrint.ForeColor = Color.SteelBlue;

            this.prepareExit.DisplayStyle = ToolStripItemDisplayStyle.Text;
            this.prepareExit.Name = "Exit";
            this.prepareExit.Size = new Size(66, 22);
            this.prepareExit.Text = "Esci";
            this.prepareExit.Font = new Font("Verdana", 9F);
            this.prepareExit.ForeColor = Color.SteelBlue;
            this.prepareExit.Click += new EventHandler(this.prepareExit_Click);

            this.generalMenu.ResumeLayout(false);
            this.generalMenu.PerformLayout();
            
            return generalMenu;
        }

        void prepareExit_Click(object sender, EventArgs e)
        {
            //come associo ad esempio la chiusura del form dove andrò a mettere il mio menu?
            
            
        }

        

    }
}

Supponendo di avere un form chiamato FormTest, il codice che io vado a scrivere è:

ReusableMenu rm = new ReusableMenu();
menuContainer.Controls.Add(rm.MyMenu());

Come associo ai vari bottoni (come nell'esempio del codice della classe) come devono comportarsi all'interno del form nel quale il menu verrà piazzato?

Grazie mille

RaouL.

[isAlreadyInUse]

bottone.Click += new EventHandler(this.prepareExit_Click);
Intendi questo?

[RaouL_BennetH]

Originariamente inviato da isAlreadyInUse

bottone.Click += new EventHandler(this.prepareExit_Click);
Intendi questo?

Si

Il fatto è che non capisco come associargli l'uscita dal o dai form.

Cioè, cosa ci dovrebbe andare nel metodo prepareExit_Click ?

Al momento, riesco a chiuderlo perchè conosco il nome del form e faccio:

foreach(Form f in Application.OpenForms)
{
   if(f is FormProva)
   { 
      f.Close();
      break;
    }
}

Ovviamente questo metodo non mi serve a nulla perchè se piazzo a runtime il menu su decine di forms...... ti lascio immaginare ..

Idee?

Grazie.

Raoul.

[isAlreadyInUse]

Secondo me dopo aver aggiunto il menu alla form devi settare nella stessa gli eventi che vuoi impostare a i bottoni in modo da avere eventi diverdi a ogni form

[RaouL_BennetH]

Originariamente inviato da isAlreadyInUse

Secondo me dopo aver aggiunto il menu alla form devi settare nella stessa gli eventi che vuoi impostare a i bottoni in modo da avere eventi diverdi a ogni form

mmm...

ma dal form io non ho modo di accedere ai bottoni.

Per uno in particolare però l'evento sarebbe uguale per tutti i form, riferendomi proprio al bottone "Exit", che non dovrebbe far altro che chiudermi il form corrente.

[ReaToMe]

Passa l'istanza della WinForm al costruttore della classe e memorizzala in una variabile membro privata.

[RaouL_BennetH]

Originariamente inviato da ReaToMe

Passa l'istanza della WinForm al costruttore della classe e memorizzala in una variabile membro privata.

perdonami, ma potresti farmi un esempio?

Non ci ho capito molto

[fek]

Ma la domanda sorge spontanea? Perche' stai cercando di scrivere una classe riusabile? Non puoi semplicemente scrivere una classe che risolve il tuo problema nel programma che stai scrivendo in questo momento?

[RaouL_BennetH]

Originariamente inviato da fek

Ma la domanda sorge spontanea? Perche' stai cercando di scrivere una classe riusabile? Non puoi semplicemente scrivere una classe che risolve il tuo problema nel programma che stai scrivendo in questo momento?

O_o ma ciao!!

ehm.. perdonate l'ot...

Di solito faccio così. Il fatto è che ultimamente sto lavorando molto su accoppiata interfaccia grafica + database per programmi diversi, e mi ritrovo a dover disegnare praticamente sempre gli stessi menu e gli stessi forms, perciò stavo cercando di risolvere il problema alla radice. Ovvero, avere un paio di forms "generici" ed un menu standard per le operazioni classiche che si fanno su un database.

Ciao

[ReaToMe]

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace ReusableCode {
  public class ReusableMenu : ToolStrip {

    private System.Windows.Forms.Form _container;

    public ReusableMenu(System.Windows.Forms.Form container) {

      this._container = container;

      this.SuspendLayout();

      this.Dock = DockStyle.Top;
      this.GripStyle = ToolStripGripStyle.Visible;
      this.Location = new Point(3, 0);
      this.Name = "mainMenu";
      this.Size = new Size(1000, 25);
      this.TabIndex = 0;

      this.AddNewButton("NewMenuItem", "&Nuovo", null);
      this.AddNewSeparator();
      this.AddNewButton("SaveMenuItem", "&Salva", null);
      this.AddNewSeparator();
      this.AddNewButton("UpdateMenuItem", "&Modifica", null);
      this.AddNewSeparator();
      this.AddNewButton("DeleteMenuItem", "&Elimina", null);
      this.AddNewSeparator();
      this.AddNewButton("CancelMenuItem", "&Annulla", null);
      this.AddNewSeparator();
      this.AddNewButton("PrintMenuItem", "Stam&pa", null);
      this.AddNewSeparator();
      this.AddNewButton("ExitMenuItem", "Esci", ExitMenuItem_Click);

      this.ResumeLayout(false);
      this.PerformLayout();

    }

    void AddNewButton(string name, string text, EventHandler eventHandler) {
      ToolStripMenuItem newButton = new ToolStripMenuItem();

      newButton.DisplayStyle = ToolStripItemDisplayStyle.Text;
      newButton.Name = text;
      newButton.Size = new Size(66, 22);
      newButton.Text = name;
      newButton.Font = new Font("Verdana", 9F);
      newButton.ForeColor = Color.SteelBlue;

      if(eventHandler != null)
        newButton.Click += new EventHandler(eventHandler);

      this.Items.Add(newButton);

      newButton = null;

    }

    void AddNewSeparator() {

      ToolStripSeparator newSeparator = new ToolStripSeparator();

      this.Items.Add(newSeparator);

      newSeparator = null;

    }

    void ExitMenuItem_Click(object sender, EventArgs e) {

      this.MyContainer.Close();

    }

    System.Windows.Forms.Form MyContainer {
      get {
        return this._container;
      }
    }

  }
}

[ReaToMe]

Nella form scriverai

menuContainer.Controls.Add(new ReusableMenu(this));

[fek]

Originariamente inviato da RaouL_BennetH

O_o ma ciao!!

ehm.. perdonate l'ot...

Di solito faccio così. Il fatto è che ultimamente sto lavorando molto su accoppiata interfaccia grafica + database per programmi diversi, e mi ritrovo a dover disegnare praticamente sempre gli stessi menu e gli stessi forms, perciò stavo cercando di risolvere il problema alla radice. Ovvero, avere un paio di forms "generici" ed un menu standard per le operazioni classiche che si fanno su un database.

Ciao

Allora prova ad approcciare il discorso cosi' invece: una volta che hai scritto quella classe due volte in maniera simile, prova a tirare fuori una classe comune ai due casi e poi quella diventa una classe di partenza che "proverai" ad usare in futuro.

Non partire cercando di scrivere la classe riusabile subito, perche' nove volte su dieci ti ritrovi con una classe troppo generica che ti fa perdere piu' tempo di quanto te ne fa risparmiare.

[RaouL_BennetH]

Originariamente inviato da fek

Allora prova ad approcciare il discorso cosi' invece: una volta che hai scritto quella classe due volte in maniera simile, prova a tirare fuori una classe comune ai due casi e poi quella diventa una classe di partenza che "proverai" ad usare in futuro.

Non partire cercando di scrivere la classe riusabile subito, perche' nove volte su dieci ti ritrovi con una classe troppo generica che ti fa perdere piu' tempo di quanto te ne fa risparmiare.

Mi sto confondendo allora

Cioè, nel mio percorso di studio verso i linguaggi orientati agli oggetti (in particolare quelli che sto studiando io sono Java e C#... e quest'ultimo mi piace un pelino di più .. ) una delle cose che cercano di passare come "dogma" è quello del riutilizzo del codice. Come devo considerare quindi questa cosa?

Grazie

RaouL.

[RaouL_BennetH]

@ReaToMe:

Grazie mille Il tuo codice mi è stato di grandissimo aiuto !

[ReaToMe]

Di nulla, alla prossima!!!

[isAlreadyInUse]

Che ne dici di questa soluzione?

[ReaToMe]

Che spero sia uno scherzo...
Contiene due form che non fanno nulla.

[isAlreadyInUse]

Il form CRUDForm definisce la struttura, l'altro la eredita, nell'esempio sono dei bottoni ma nel caso di raoul puo essere un menu nel quale va solo a ridefinire gli eventi

[fek]

Originariamente inviato da RaouL_BennetH

Mi sto confondendo allora

Cioè, nel mio percorso di studio verso i linguaggi orientati agli oggetti (in particolare quelli che sto studiando io sono Java e C#... e quest'ultimo mi piace un pelino di più .. ) una delle cose che cercano di passare come "dogma" è quello del riutilizzo del codice. Come devo considerare quindi questa cosa?

Considerala una fesseria
Il CoCoMo model (nome stupidissimo per altro) per la stima del costo del software ha calcolato che scrivere codice per essere riusabile costa mediamente il 30% in piu' (in termini di tempo e denaro) e solo il 10% delle volte e' effettivamente riutilizzato. In pratica, scrivendo codice riutilizzabile paghi in termini di tempo e complessita' della soluzione senza ricevere nulla in cambio nella maggior parte dei casi.
Inoltre, riutilizzare codice non e' facile e impone una maggiore complessita' anche nel codice cliente.

E' molto meglio cercare di "estrarre" codice da riutilizzare da una soluzione gia' funzionante ed estrarre solo il codice gia' diventato semplice, stabile e generico dopo il refactoring.

[ReaToMe]

...dove codice riusabile è riferito per lo più a sotto-sistemi.
Creare classi riusabili come quella del topic, non è una perdita di tempo.
In fondo si tratta essenzialmente di un control custom.