Developpez.com

Une très vaste base de connaissances en informatique avec
plus de 100 FAQ et 10 000 réponses à vos questions

FAQ C#Consultez toutes les FAQ

Nombre d'auteurs : 41, nombre de questions : 272, dernière mise à jour : 16 août 2017  Ajouter une question

 

Cette FAQ a été réalisée pour répondre aux questions les plus fréquemment posées concernant C# sur le forum Développement DotNET

Je tiens à souligner qu'elle ne garantit en aucun cas que les informations qu'elle contient sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci .

Sur ce, je vous souhaite une bonne lecture.

Commentez cette FAQ : Commentez


SommaireWinFormsWinForms Divers (27)
précédent sommaire suivant
 

On peut donner le style Windows XP à son application de deux manières distinctes selon que l'on utilise le Framework.NET 1.0 ou une version ultérieure

Avec le Framework 1.0, il faut procéder ainsi :

  • créer un fichier nommé WindowsApplication1.exe.manifest à l'aide d'un éditeur de texte (WindowsApplication1 étant le nom de votre application) ;
  • copier, dans celui-ci, le texte suivant et sauvegarder le dans le répertoire où se trouve l'exécutable de votre application.


Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?> 
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> 
	<assemblyIdentity version="1.0.0.0" processorArchitecture="X86" 
					  name="Microsoft.Winweb.MantaRay" type="win32" /> 
	<description>.NET control deployment tool</description> 
	<dependency> 
		<dependentAssembly> 
			<assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" 
				processorArchitecture="X86" publicKeyToken="6595b64144ccf1df" language="*" /> 
		</dependentAssembly> 
	</dependency> 
</assembly>
On peut aussi procéder de la façon suivante (Framework 1.1 et versions ultérieures) :

  • ajouter un appel à Application.EnableVisualStyles dans votre code avant la création de tout contrôle ;
  • Mettre la propriété FlatStyle de tous les contrôles WinForms qui en possèdent une à System.


Code c# : Sélectionner tout
1
2
3
4
5
6
7
// Soit dans la fonction  Main de démarrage de votre projet 
[STAThread] 
static void Main() 
{ 
    Application.EnableVisualStyles(); 
    Application.Run(new Form1()); 
}

Mis à jour le 2 novembre 2004 abelman keita

Lors de la réalisation d'applications, il peut être utile de montrer à l'utilisateur que le traitement demandé est en cours (et qu'il faut patienter).
Un bon moyen de réaliser ceci est de changer la forme du curseur, pendant la durée du traitement.
Pour ce faire, vous devez utiliser la classe Cursors.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
// Fonction du code d'un bouton de notre Form 
private void Button1_Click(object sender, System.EventArgs e) 
{ 
    // On passe le curseur en sablier 
    Cursor = Cursors.WaitCursor; 
  
    // On affiche une boite de dialogue 
    MessageBox.Show("Le curseur est maintenant un sablier"); 
  
    // On repasse le curseur en normal 
    Cursor = Cursors.Default; 
}
N'hésitez pas à vous référer à la classe Cursors pour voir les types de curseurs disponibles et utilisables par votre application.

Mis à jour le 2 novembre 2004 Thomas Lebrun

L'évènement SystemEvents.SessionEnding permet de détecter et d'annuler la fermeture de session :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using Microsoft.Win32; 
// ... 
  
static void Main(string[] args) 
{ 
    // Abonnement à l'évènement SessionEnding 
    SystemEvents.SessionEnding += SessionEnding; 
  
  
    // Suite du programme 
    // ... 
} 
  
private void SessionEnding(object sender, SessionEndingEventArgs e) 
{ 
    DialogResult r = MessageBox.Show("Voulez vous annuler la fermeture de session ?", "Fermeture de session", MessageBoxButtons.YesNo, MessageBoxIcons.Question); 
    if (r == DialogResult.Yes) 
    { 
        e.Cancel = true; 
    } 
}
Pour tester ce code, compilez l'application et exécutez la hors de l'environnement de votre IDE.

Mis à jour le 2 novembre 2004 Swoög tomlev

On utilise le composant FolderBrowserDialog pour cela.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
private void button3_Click(object sender, System.EventArgs e) 
{ 
    folderBrowserDialog1.Description = "Choisissez votre répertoire"; 
    if (folderBrowserDialog1.ShowDialog(this) == DialogResult.OK) 
    { 
        MessageBox.Show(this, 
        "Vous aves choisi " + folderBrowserDialog1.SelectedPath, 
        "Repertoire", 
        MessageBoxButtons.OK, 
        MessageBoxIcon.Information); 
    } 
  
}

Mis à jour le 2 novembre 2004 abelman

Le composant System.Windows.Form.OpenFileDialog permet à l'utilisateur de choisir interactivement un fichier afin d'y lire des données.
Créez une Form et placez-y un bouton nommé button2, un composant RichTextBox nommé richTextBox1 et un composant OpenFileDialog nommé openFileDialog1 Un clic sur le bouton2 permet de lire le fichier choisi et d'afficher son contenu dans le RichTextBox

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
private void button2_Click(object sender, System.EventArgs e) 
{ 
    // Titre 
    openFileDialog1.Title = "Chargement"; 
    // Extension par défaut 
    openFileDialog1.DefaultExt = "txt"; 
    // Filtre sur les fichiers 
    openFileDialog1.Filter = "fichiers textes (*.txt)|*.txt|Tous les fichiers (*.*)|*.*"; 
    openFileDialog1.FilterIndex = 1; 
    // Ouverture boite de dialogue OpenFile 
    if (openFileDialog1.ShowDialog(this) == DialogResult.OK) 
    { 
        // On vide le TextBox 
        richTextBox1.Text = string.Empty; 
        // Ouverture du fichier sélectionné 
        // son nom est dans openFileDialog1.FileName 
        StreamReader sr = new StreamReader(openFileDialog1.OpenFile(), Encoding.Default); 
        try 
        { 
            string data = sr.ReadLine(); 
            while (data != null) 
            { 
                richTextBox1.AppendText(data + "\r\n"); 
                data = sr.ReadLine(); 
            } 
        } 
        finally 
        { 
            if (sr != null) 
                sr.Close(); 
        } 
    } 
}

Mis à jour le 2 novembre 2004 abelman

Le composant System.Windows.Form.SaveFileDialog permet à l'utilisateur de choisir interactivement un fichier afin d'y écrire des données.
Créez une Form et placez-y un bouton nommé button1, un composant RichTextBox nommé richTextBox1 et un composant SaveFileDialog nommé saveFileDialog1.
Un clic sur le bouton1 permet de sauvegarder le contenu du RichTextBox vers le fichier choisi.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
private void button1_Click(object sender, System.EventArgs e) 
{ 
    // Demande de confirmation 
    if (MessageBox.Show(this, 
    "Sauvegarder le document?", 
    "Sauvegarde", 
    MessageBoxButtons.YesNo, 
    MessageBoxIcon.Question) == DialogResult.No) 
        return; 
    // Sauvegarde du document 
    saveFileDialog1.Title = "Sauvegarde"; 
    saveFileDialog1.DefaultExt = "txt"; 
    saveFileDialog1.Filter = "fichiers textes (*.txt)|*.txt|Tous les fichiers (*.*)|*.*"; 
    saveFileDialog1.FilterIndex = 1; 
    // Ouverture boite de dialogue Enregistrer 
    if (saveFileDialog1.ShowDialog(this) == DialogResult.OK) 
    { 
        // StreamWriter pour écrire dans le fichier sélectionné 
        StreamWriter sw = new StreamWriter(saveFileDialog1.OpenFile(), Encoding.Default); 
        try 
        { 
            for (int i = 0; i < richTextBox1.Lines.Length; i++) 
                sw.WriteLine(richTextBox1.Lines[i]); 
        } 
        finally 
        { 
            // Fermeture writer 
            if (sw != null) 
                sw.Close(); 
        } 
    } 
}

Mis à jour le 2 novembre 2004 abelman

Afin de pouvoir communiquer à partir d'une Form nouvellement ouverte vers la Form créatrice vous devez passer la Form créatrice à la nouvelle Form.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//Dans Form1 
public void TraitementForm1() 
{ 
  
} 
  
public void OuvertureForm2() 
{ 
  
    MaForm2 maForm2 = new MaForm2(); 
    maForm2.Owner = this; 
    maForm2.Show(); 
} 
  
//Dans MaForm2 
  
private void ButtonOk_Click(object sender, System.EventArgs e) 
{ 
    MaForm1 maForm1 = (MaForm1)this.Owner; 
    maForm1.TraitementForm1(); 
}

Mis à jour le 10 avril 2006 dev01

Suite à une action utilisateur sur le clavier, nous devons parfois effectuer un long traitement. Et nous souhaiterions que les actions clavier ne soient pas enregistrées pendant ce traitement. Cette suspension peut être implémentée de la façon suivante :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using System; 
using System.Windows.Forms; 
//... 
  
private void maSaisie_KeyUp(object sender, KeyEventArgs e) 
{ 
    //Exemple après l'appui de la touche "Enter" 
    if (e.KeyCode == Keys.Enter) 
    { 
        //Arrêter la capture d'evenements clavier sur le contrôle 
        this.maSaisie.KeyUp -= new KeyEventHandler(this.maSaisie_KeyUp); 
  
        //Traitements longs 
  
        //Reprendre la capture d'evenements clavier sur le contrôle 
        this.maSaisie.KeyUp += new KeyEventHandler(this.maSaisie_KeyUp); 
    } 
}

Mis à jour le 10 avril 2006 neguib

Dans le constructeur, il suffit d'ajouter

Code c# : Sélectionner tout
1
2
this.SetStyle(ControlStyles.SupportsTransparentBackColor, true); 
this.BackColor = Color.Transparent;
après le InitializeComponents().

Mis à jour le 10 avril 2006 Ditch

Parfois, nous avons besoin de distinguer si la fenêtre de l'application a été fermée par un clic sur un contrôle prévu à cet effet, ou si le clic a été effectué sur la petite croix en haut à droite de la fenêtre. Pour ce faire, nous avons juste besoin de savoir que l'évènement concerné est lié à l'Application et non au contrôle Form. Voici un exemple de code test, qui vous démontrera que seule la fermeture intempestive de l'application déclenchera le MessageBox.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
Application.ApplicationExit  += new EventHandler(Application_Exit); 
  
//... 
private static void Application_Exit(object sender, System.EventArgs e) 
{ 
    MessageBox.Show("Adieu vilaine brute"); 
} 
  
private void button1_Click(object sender, System.EventArgs e) 
{ 
    Application.Exit(); 
}

Mis à jour le 10 avril 2006 neguib

Il suffit de traiter l'évènement OnClosing du formulaire et de positionner Cancel à true

Code c# : Sélectionner tout
1
2
3
4
private void MainForm_FormClosing(object sender, FormClosingEventArgs e) 
{ 
    e.Cancel = true; //On annule la fermeture 
}

Mis à jour le 22 août 2006 dev01

Ce code permet de remplir rapidement un contrôle ComboBox avec un DataReader. Il nécessite un contrôle ComboBox nommé ici ComboBox1

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
using System; 
using System.Data; 
using System.Data.SqlClient; 
using System.Windows.Forms; 
... 
  
SqlConnection con = null; 
SqlCommand command = null; 
String cs = " la chaine de connexion SQL"; 
SqlDataReader dr = null; 
  
try 
{ 
    con = new SqlConnection(cs); 
    command = new SqlCommand("SELECT champ FROM Table", con); 
    con.Open(); 
    dr = command.ExecuteReader(); 
  
    ComboBox1.Items.Clear(); 
  
    if (dr.HasRows) 
    { 
        while (dr.Read()) 
        { ComboBox1.Items.Add(dr.GetValue(0)); } 
    } 
    else 
    { 
        MessageBox.Show("No result for your Data", "Infos", 
            MessageBoxButtons.OK, MessageBoxIcon.Information); 
    } 
} 
catch (Exception ex) 
{ 
    MessageBox.Show(ex.Message); 
} 
finally 
{ 
    if (dr != null) { dr.Close(); } 
    if (con != null) { con.Close(); } 
}

Mis à jour le 22 août 2006 saline

L'intérêt est ici de pouvoir modifier le NotifyIcon de notre application afin, par exemple, d'y faire apparaître un texte en fonction de différentes circonstances. L'exemple implémenté se contentera de faire ici défiler dans l'objet notifyIcon1 les secondes d'un objet DateTime. La procédure est assez simple puisqu'il s'agit de travailler via un objet Bitmap pour la modification et de le convertir en Icon à assigner à la propriété notifyIcon1.Icon. Ce qu'il ne faut absolument pas oublier est de détruire au fur et à mesure les icônes en mémoire. Le code suivant ne montre que l'essentiel, il vous faut bien sûr en plus déclarer et instancier les objets Font, Brush, Color et StringFormat souhaités

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
///<summary> 
/// Méthode privée timer1_Tick 
/// gestionnaire de l'évènement Tick de timer1 
///</summary> 
private void timer1_Tick(object sender, EventArgs e) 
{ 
    // lancer la mise à jour de NotifyIcon1 
    this.UpdateNotiFyIcon(DateTime.Now.Second.ToString()); 
} 
  
///<summary> Méthode privée UpdateNotiFyIcon 
/// chargée de mofifier notifyIcon1 dynamiquement 
///</summary> 
///<param name="texte">String : représente le texte à afficher 
///</param> 
private void UpdateNotiFyIcon(String texte) 
{ 
    // redessiner iconBitmap 
    this.UpdateBitmap(texte); 
    // récupérer un icone à patir de iconBitmap 
    Icon newIcon = Icon.FromHandle(this.iconBitmap.GetHicon()); 
    // assigner le nouvel icône de NotifyIcon1 
    this.notifyIcon1.Icon = newIcon; 
    // détruire en mémoire le nouvel icône 
    newIcon.Dispose(); 
} 
  
///<summary> Méthode privée UpdateBitmap 
/// chargée de redessiner iconBitmap en fonction d'un texte 
///</summary> 
///<param name="texte">String : représente le texte à afficher 
///</param> 
private void UpdateBitmap(String texte) 
{ 
    Graphics g = Graphics.FromImage(this.iconBitmap); 
    // assigner la couleur de fond 
    g.Clear(this.iconBackColor); 
    // dessiner le texte 
    g.DrawString(texte, this.iconFont, this.iconForeBrush, 14, 14, this.iconStringFormat); 
    // libérer l'objet Graphics 
    g.Dispose(); 
}

Mis à jour le 22 août 2006 neguib

Pour accéder aux composants graphiques d'un formulaire à partir d'un autre thread que celui de la forme vous devez utiliser la fonction invoke des composants

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private void LanceThread(object sender, EventArgs e) 
{ 
    ThreadStart operation = new ThreadStart(Fonction1); 
  
    Thread LeThread = new Thread(operation); 
  
    LeThread.Start(); 
} 
  
private void Fonction1() 
{ 
    if (textBox1.InvokeRequired) 
        textBox1.Invoke(new TextBoxInvokeHandler(FonctionTextBox)); 
    else 
        FonctionTextBox(); 
} 
  
private delegate void TextBoxInvokeHandler(); 
  
private void FonctionTextBox() 
{ 
    textBox1.Text = "dans le thread"; 
}
Dans cet exemple nous créons notre propre délégué. Ceci est utile si vous avez des informations particulières à passer à votre fonction.

Mis à jour le 2 janvier 2007 dev01

Pour déplacer un PictureBox, nous avons besoin de 2 informations :

  • Le bouton gauche vient-il d'être enfoncé ?
  • La souris se déplace-t-elle en étant au dessus du PictureBox ?

Le Framework met justement à notre disposition 2 évènements nous permettant de connaître ces 2 informations :

  • MouseDown : notifie si le bouton de la souris a été enfoncé mais aussi à quel endroit ;
  • MouseMove : notifie si la souris se déplace.

Il suffit donc de traiter le premier évènement afin de connaître la position d'origine du clic et dans le second évènement, nous repositionnerons le PictureBox par rapport au déplacement de la souris.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/// <summary> Position de la souris lorsque le bouton a été enfoncé </summary> 
Point positionClick; 
  
/// <summary> 
/// Notifie si le bouton de la souris a été enfoncé sur le PictuBox 
/// </summary> 
private void pictureBox1_MouseDown(object sender, MouseEventArgs e) 
{ 
    // Vérification si bouton gauche de la souris est bien enfoncé 
    if (e.Button == MouseButtons.Left) 
        positionClick = e.Location; 
} 
  
/// <summary> 
/// Notifie si le curseur se déplace au dessus du PictureBox 
/// </summary> 
private void pictureBox1_MouseMove(object sender, MouseEventArgs e) 
{ 
    // Vérification si bouton gauche de la souris est bien enfoncé 
    if (e.Button == MouseButtons.Left) 
    { 
        // Calcul de la nouvelle position du PictureBox 
        pictureBox1.Location = new Point(pictureBox1.Location.X + e.X - positionClick.X, pictureBox1.Location.Y + e.Y - positionClick.Y); 
    } 
}

À noter que ce code peut être utilisé pour les autres contrôles qui proposent les évènements MouseDown et MouseMove.

Mis à jour le 2 janvier 2007 Jérôme Lambert

On utilise la propriété MonitorCount de la classe SystemInformation :

Code c# : Sélectionner tout
1
2
3
// Nombre d'écrans connectés 
int MonitorCount = SystemInformation.MonitorCount; 
Console.WriteLine("Nombre d'écrans connectés à l'ordinateur = {0}", MonitorCount);

Mis à jour le 2 janvier 2007 Jérôme Lambert

Pour forcer l'évènement Paint, il suffit d'appeler la méthode Invalidate liée à la classe de la fenêtre :

Code c# : Sélectionner tout
1
2
// Forcer l'évènement Paint 
this.Invalidate();

Cependant et pour des raisons de performances, on spécifiera le rectangle à rafraîchir :

Code c# : Sélectionner tout
1
2
// Forcer l'évènement Paint en spécifiant le rectangle à raffraichir 
this.Invalidate(new Rectangle(0, 0, 10, 10));

Mis à jour le 2 janvier 2007 Jérôme Lambert

Pour une application Windows, c'est la propriété Text de la classe Form qui contient le texte de la barre de titre :

Code c# : Sélectionner tout
this.Text = "Mon titre";

Mis à jour le 20 mars 2007 Jérôme Lambert

Lorsqu'un processus prend du temps, il est utile d'afficher le curseur notifiant à l'utilisateur qu'il faut patienter :

Code c# : Sélectionner tout
1
2
3
4
5
6
// Affiche le curseur d'attente 
Cursor.Current = Cursors.WaitCursor; 
// Pause de 5 secondes 
Thread.Sleep(5000); 
// Efface le curseur par défaut 
Cursor.Current = Cursors.Default;

Mis à jour le 20 mars 2007 Jérôme Lambert

Il suffit tout simplement de mettre à true la propriété TopMost de la fenêtre :

Code c# : Sélectionner tout
this.TopMost = true;

Mis à jour le 10 juin 2008 Jérôme Lambert

Il est facile de fermer un formulaire en fondu avec C#. Il suffit d'insérer ce code dans un bouton pour permettre au formulaire de fermer en fondu :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
/* Cette boucle va se charger de rendre le formulaire transparent graduellement 
grâce à this.Opacity */ 
for (double dblOpacity = 1; dblOpacity > 0; dblOpacity += -0.05) 
{ 
    this.Opacity = dblOpacity; 
    //laisse le formulaire se recolorer 
     this.Refresh(); 
     //crée un délai 
     System.Threading.Thread.Sleep(50); 
} 
  
// Insérez ici le code supplémentaire pour que le bouton effectue d'autres actions si nécessaire 
Form.ActiveForm.Close();

Mis à jour le 10 juin 2008 Jean-Philippe Dubé

Il existe la propriété ShowKeyboardCues héritée de Control qui permet de déterminer si soulignement du caractère de raccourci clavier d'un Button doit être affiché ou pas. Cette propriété étant ReadOnly, il est nécessaire de créer un Button personnalisé qui la substitue (via overrides).

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
public class NonKeyboardCuesButton : Button 
{ 
    protected overrides bool ShowKeyboardCues 
    { 
		get 
        { 
            return false; 
        } 
	} 
}

Mis à jour le 10 juin 2008 olsimare

Il existe la propriété ShowFocusCues héritée de Control qui permet de déterminer si le rectangle de focus doit être affiché ou pas. Cette propriété étant ReadOnly, il est nécessaire de créer un Button personnalisé qui la substitue (via Overrides).

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
public class NonFocusCuesButton : Button 
{ 
  
    protected override bool ShowFocusCues 
    { 
        get 
        { 
        	return false; 
        } 
    } 
}

Mis à jour le 10 juin 2008 olsimare

Il faut mettre en préambule l'attribut KeyPreview de la form à true, pour dire que la form doit traiter tous les évènements clavier en premier et ensuite surcharger le KeyDown de la form.
Exemple pour faire un raccourci CTRL+M :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
private void Form1_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e) 
{ 
        if( e.Control != null && e.KeyCode == Keys.M ) 
		{ 
            MsgBox("Vous avez appuyé sur Ctrl + M"); 
        } 
}

Mis à jour le 10 juin 2008 nico-pyright(c)

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private ArrayList ListerForms() 
{ 
        ArrayList resultat = new ArrayList(); 
  
        Reflection.Assembly a = System.Reflection.Assembly.GetAssembly(this.GetType()); 
        foreach(Type t in a.GetTypes) 
        { 
            if(typeof(Form).IsAssignableFrom(t)) 
            { 
                Form f = (Form)Activator.CreateInstance(t); 
                resultat.Add(f); 
            } 
        } 
  
        return resultat; 
}

Mis à jour le 10 juin 2008 Aspic

La plupart des messages Windows envoyés à la fenêtre déclenchent un évènement .NET. Si vous devez intercepter un message qui ne correspond à aucun évènement .NET, il suffit de redéfinir la méthode WndProc de la classe Control :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
      protected override void WndProc(ref Message m) 
      { 
          switch (m.Msg) 
          { 
              // Fenêtre activée (WM_ACTIVATEAPP) 
              case 0x001C:  
                  // Traiter le message 
                  // ... 
                  break; 
              default: 
                  break; 
          } 
          // On appele l'implémentation de base 
          base.WndProc(ref m); 
      }

Mis à jour le 20 mars 2007 Jérôme Lambert tomlev

L'objet application offre la possibilité de s'abonner à l'évènement ThreadException permettant d'être notifié lorsqu'un thread génère une exception non interceptée. Étant donné que la fenêtre est gérée par un thread, vous pourrez ainsi éviter le « plantage » de votre application ou effectuer un traitement adapté avant la fermeture de votre application.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
static class Program 
{ 
    /// <summary> 
    /// The main entry point for the application. 
    /// </summary> 
    [System.STAThread] 
    static void Main() 
    { 
        System.Windows.Forms.Application.EnableVisualStyles(); 
        System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false); 
  
        // S'abonne à l'évènement permettant d'être averti qu'un thread génère une exception 
        System.Windows.Forms.Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException); 
  
        System.Windows.Forms.Application.Run(new Form1()); 
    } 
  
    /// <summary> 
    /// Lancé lorsque un thread n'intercepte pas une exception qu'il a généré 
    /// </summary> 
    static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e) 
    { 
        System.Windows.Forms.MessageBox.Show("L'exeption générée est : " + e.Exception.Message); 
    } 
}

Mis à jour le 10 juin 2008 Jérôme Lambert tomlev

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Microsoft DotNET : Hinault Romaric -