Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Normal, MenuItems retourne un objet de type MenuItem et non pas de
type MyMenuItem. Cet objet retourné ne peut donc pas être « casté »
sous la forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais
en plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même
objet mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet
pas de changer la nature réelle de cet objet.
S. L.
"Neoh59" wrote in message
news:41bc6dd4$0$12725$
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je
dérive MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Normal, MenuItems retourne un objet de type MenuItem et non pas de
type MyMenuItem. Cet objet retourné ne peut donc pas être « casté »
sous la forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais
en plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même
objet mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet
pas de changer la nature réelle de cet objet.
S. L.
"Neoh59" <neoh59@gratuit.fr> wrote in message
news:41bc6dd4$0$12725$626a14ce@news.free.fr...
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je
dérive MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Normal, MenuItems retourne un objet de type MenuItem et non pas de
type MyMenuItem. Cet objet retourné ne peut donc pas être « casté »
sous la forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais
en plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même
objet mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet
pas de changer la nature réelle de cet objet.
S. L.
"Neoh59" wrote in message
news:41bc6dd4$0$12725$
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je
dérive MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Merci beaucoup, la réponse est très claire.
Je vais chercher encore comment réaliser ce que je cherchais à faire.
(c'est comme ça qu'on apprend non ? ;-p )
Sylvain Lafontaine wrote:Normal, MenuItems retourne un objet de type MenuItem et non pas de
type MyMenuItem. Cet objet retourné ne peut donc pas être « casté »
sous la forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais
en plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même
objet mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet
pas de changer la nature réelle de cet objet.
S. L.
"Neoh59" wrote in message
news:41bc6dd4$0$12725$
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je
dérive MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Merci beaucoup, la réponse est très claire.
Je vais chercher encore comment réaliser ce que je cherchais à faire.
(c'est comme ça qu'on apprend non ? ;-p )
Sylvain Lafontaine wrote:
Normal, MenuItems retourne un objet de type MenuItem et non pas de
type MyMenuItem. Cet objet retourné ne peut donc pas être « casté »
sous la forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais
en plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même
objet mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet
pas de changer la nature réelle de cet objet.
S. L.
"Neoh59" <neoh59@gratuit.fr> wrote in message
news:41bc6dd4$0$12725$626a14ce@news.free.fr...
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je
dérive MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Merci beaucoup, la réponse est très claire.
Je vais chercher encore comment réaliser ce que je cherchais à faire.
(c'est comme ça qu'on apprend non ? ;-p )
Sylvain Lafontaine wrote:Normal, MenuItems retourne un objet de type MenuItem et non pas de
type MyMenuItem. Cet objet retourné ne peut donc pas être « casté »
sous la forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais
en plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même
objet mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet
pas de changer la nature réelle de cet objet.
S. L.
"Neoh59" wrote in message
news:41bc6dd4$0$12725$
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je
dérive MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Normal, MenuItems retourne un objet de type MenuItem et non pas de type
MyMenuItem. Cet objet retourné ne peut donc pas être « casté » sous la
forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais en
plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même objet
mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet pas
de changer la nature réelle de cet objet.
S. L.
"Neoh59" wrote in message
news:41bc6dd4$0$12725$
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Normal, MenuItems retourne un objet de type MenuItem et non pas de type
MyMenuItem. Cet objet retourné ne peut donc pas être « casté » sous la
forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais en
plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même objet
mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet pas
de changer la nature réelle de cet objet.
S. L.
"Neoh59" <neoh59@gratuit.fr> wrote in message
news:41bc6dd4$0$12725$626a14ce@news.free.fr...
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
Normal, MenuItems retourne un objet de type MenuItem et non pas de type
MyMenuItem. Cet objet retourné ne peut donc pas être « casté » sous la
forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais en
plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même objet
mais vu sous un angle différent.
Le casting permet de changer l'angle de vue d'un objet; il ne permet pas
de changer la nature réelle de cet objet.
S. L.
"Neoh59" wrote in message
news:41bc6dd4$0$12725$
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
"Sylvain Lafontaine" <sylvain aei ca (fill the blanks, no spam please)> a
écrit dans le message de news:Normal, MenuItems retourne un objet de type MenuItem et non pas de type
MyMenuItem. Cet objet retourné ne peut donc pas être « casté » sous la
forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais en
plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même objet
mais vu sous un angle différent.
Caster un MyMenuItem en MenuItem, c'est inutile et ça rend le code plus
confus. Lorsqu'on assigne un MyMenuItem à une variable de type MenuItem,
il ne faut pas mettre de cast. Dans l'autre sens, le cast est nécessaire.
Le problème avec ton code, c'est que tu crées un MyMenuItem (ton "new
MyMenuItem()") mais tu n'en fais rien ensuite. Juste après, tu recrées un
MenuItem en appelant Add avec un String (en interne, le menu créé un
MenuItem quand tu fais cet appel).
Il faut passer ton MyMenuItem à la méthode Add, il ne faut pas utiliser la
variante qui prend un string comme argument.
Bruno
Le casting permet de changer l'angle de vue d'un objet; il ne permet pas
de changer la nature réelle de cet objet.
S. L.
"Neoh59" wrote in message
news:41bc6dd4$0$12725$
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
"Sylvain Lafontaine" <sylvain aei ca (fill the blanks, no spam please)> a
écrit dans le message de news: e0HtaZH4EHA.2624@TK2MSFTNGP11.phx.gbl...
Normal, MenuItems retourne un objet de type MenuItem et non pas de type
MyMenuItem. Cet objet retourné ne peut donc pas être « casté » sous la
forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais en
plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même objet
mais vu sous un angle différent.
Caster un MyMenuItem en MenuItem, c'est inutile et ça rend le code plus
confus. Lorsqu'on assigne un MyMenuItem à une variable de type MenuItem,
il ne faut pas mettre de cast. Dans l'autre sens, le cast est nécessaire.
Le problème avec ton code, c'est que tu crées un MyMenuItem (ton "new
MyMenuItem()") mais tu n'en fais rien ensuite. Juste après, tu recrées un
MenuItem en appelant Add avec un String (en interne, le menu créé un
MenuItem quand tu fais cet appel).
Il faut passer ton MyMenuItem à la méthode Add, il ne faut pas utiliser la
variante qui prend un string comme argument.
Bruno
Le casting permet de changer l'angle de vue d'un objet; il ne permet pas
de changer la nature réelle de cet objet.
S. L.
"Neoh59" <neoh59@gratuit.fr> wrote in message
news:41bc6dd4$0$12725$626a14ce@news.free.fr...
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}
"Sylvain Lafontaine" <sylvain aei ca (fill the blanks, no spam please)> a
écrit dans le message de news:Normal, MenuItems retourne un objet de type MenuItem et non pas de type
MyMenuItem. Cet objet retourné ne peut donc pas être « casté » sous la
forme MyMenuItem puisqu'il n'a jamais été de type MyMenuItem.
Si vous prenez cependant un objet de type MyMenuItem, alors là non
seulement vous avez le droit de le caster sous la forme MenuItem mais en
plus, après cela, vous avez le droit de le recaster sous sa forme
MyMenuItem puisque dans tous ces cas, il s'agit toujours du même objet
mais vu sous un angle différent.
Caster un MyMenuItem en MenuItem, c'est inutile et ça rend le code plus
confus. Lorsqu'on assigne un MyMenuItem à une variable de type MenuItem,
il ne faut pas mettre de cast. Dans l'autre sens, le cast est nécessaire.
Le problème avec ton code, c'est que tu crées un MyMenuItem (ton "new
MyMenuItem()") mais tu n'en fais rien ensuite. Juste après, tu recrées un
MenuItem en appelant Add avec un String (en interne, le menu créé un
MenuItem quand tu fais cet appel).
Il faut passer ton MyMenuItem à la méthode Add, il ne faut pas utiliser la
variante qui prend un string comme argument.
Bruno
Le casting permet de changer l'angle de vue d'un objet; il ne permet pas
de changer la nature réelle de cet objet.
S. L.
"Neoh59" wrote in message
news:41bc6dd4$0$12725$
Bonjour,
D'abord désolé pour le sujet peu explicite mais je débute en C#.
J'ai un plantage à l'exécution que je n'arrive pas à comprendre.
Tout marche bien si je dérive seulement MainMenu, mais pas si je dérive
MenuItem.
Alors si quelqu'un avait une idée, voici mon code :
-------------------------------------------------------
// Fenêtre principale de l'application
public class MyMainForm : System.Windows.Forms.Form
{ public MyMainForm()
{ (...)
this.IsMdiContainer = true;
MyMainMenu myMainMenu = new MyMainMenu();
myMainMenu.InitMainMenu();
this.Menu = myMainMenu;
}
[STAThread]
public static void Main(string[] args)
{ Application.Run(new CCGestMainForm()); }
}
// Menu principal de l'application
public class MyMainMenu : MainMenu
{ public MyMainMenu():base(){}
public InitMainMenu() /// version qui ne mache pas
{ MyMenuItem myMenuItem = new MyMenuItem();
myMenuItem = (MyMenuItem)this.MenuItems.Add("&Fichier");
}
public InitMainMenu() /// version qui mache
{ MenuItem myMenuItem = new MenuItem();
myMenuItem = this.MenuItems.Add("&Fichier");
}
}
// Item de menu de l'application
public class MyMenuItem : MenuItem
{ public MyMenuItem():base(){}
}