[C#] Format spécial

Version imprimable

22/01/2009, 16h42
JOBiJOBa3

[C#] Format spécial

Bonjour tous le monde, j'ai besoin de votre aide

Dans un textBox je voudrai avoir un format du type : 1 124 142,00144.
J'ai trouvé pour le séparateur de millier. Mais le problème est que ce format m'arrondis à deux chiffres après la virgule.

Code:

txtBox.Text = string.Format("{0:n}", double.Parse(txtBox.Text));

Avez vous une idée?

Merci d'avance.
22/01/2009, 16h55
Greybird

"{0:n5}" pour 5 décimales ?

Attention néanmoins, si le poste sur lequelle tu exécute ton application a une culture anglaise, ce format donnera quelque chose comme

Citation:

1'124'142.00144

Si ça te pose un problème, il va falloir gérer ça autrement.
22/01/2009, 17h07
JOBiJOBa3

Okey merci beaucoup, je n'avez pas pensé a cette subtilité.

Sinon je rajoute une petite contrainte.
Je voudrai que mon utilisateur ne passe que des chiffres, donc lettre et caractère spéciaux exclus, dans ma textBox.
Je ne sais pas si cela ce fait avec un system.format().

^^

Voici un usercontrol qui accept uniquement des caractère numérique positif ou négatif.

Il accepte les , et les . comme séparateur de décimal

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Globalization;
using System.Windows.Forms;
 
namespace PrestigeGestion
{
    public class NumericTextBox : TextBox
    {
        bool allowSpace = false;
 
        // Restricts the entry of characters to digits (including hex), the negative sign,
        // the decimal point, and editing keystrokes (backspace).
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            base.OnKeyPress(e);
 
            NumberFormatInfo numberFormatInfo = System.Globalization.CultureInfo.CurrentCulture.NumberFormat;
            string decimalSeparator = numberFormatInfo.NumberDecimalSeparator;
            string groupSeparator = numberFormatInfo.NumberGroupSeparator;
            string negativeSign = numberFormatInfo.NegativeSign;
 
            string keyInput = e.KeyChar.ToString();
 
            if (Char.IsDigit(e.KeyChar))
            {
                // OK
            }
            else if (keyInput.Equals(decimalSeparator) || keyInput.Equals(groupSeparator) ||
             keyInput.Equals(negativeSign) || keyInput.Equals("."))
            {
                // Decimal separator is OK
            }
            else if (e.KeyChar == '\b')
            {
                // Backspace key is OK
            }
            //    else if ((ModifierKeys & (Keys.Control | Keys.Alt)) != 0)
            //    {
            //     // Let the edit control handle control and alt key combinations
            //    }
            else if (this.allowSpace && e.KeyChar == ' ')
            {
 
            }
            else
            {
                // Swallow this invalid key and beep
                e.Handled = true;
                //    MessageBeep();
            }
        }
 
        public int IntValue
        {
            get
            {
                return Int32.Parse(this.Text);
            }
        }
 
        public decimal DecimalValue
        {
            get
            {
                return Decimal.Parse(this.Text);
            }
        }
 
        public bool AllowSpace
        {
            set
            {
                this.allowSpace = value;
            }
 
            get
            {
                return this.allowSpace;
            }
        }
    }
 
}

22/01/2009, 18h20
Greybird

Citation:

Envoyé par Roach-

Voici un usercontrol qui accept uniquement des caractère numérique positif ou négatif.

Désolé, mais ce contrôle ne remplit pas totalement son rôle. En effet, à mon sens et sans l'avoir testé en live, je dirais qu'on peut toujours coller du texte non numérique dedans.

Et par ailleurs ton commentaire dit que tu acceptes les digits hexa (ie A-F je suppose), ce qui ne me semble pas vrai :P
22/01/2009, 18h29
Roach-

D'après tout les test que j,ai fait pas possible de mettre du texte dans ce numtxtbox.

Pour l'hex je vais vérifier mais je croix avoir enlever cela mais j'ai oublier le comment.
22/01/2009, 18h37
Greybird

Citation:

Envoyé par Roach-

D'après tout les test que j,ai fait pas possible de mettre du texte dans ce numtxtbox.

Si c'est possible, j'insiste. Je n'ai toujours pas exécuté le code, mais je suis sûr à 100 % qu'un clic droit > Coller dans le contrôle colle des caractères alphanumériques.
Par ailleurs, on ne peut pas coller des chiffres non plus via le clavier, ni copier depuis ce contrôle, ni faire quoi que ce soit qui implique des touches non numériques (plus les quelques touches +-, ...), car tu les avales dans le contrôle via e.Handled = true.

J'ai quelque part dans mes sources un TextBox que j'avais développé et qui gère correctement tout ça, si j'ai le temps ce soir, je la posterai ici.
22/01/2009, 18h42
Roach-

ok oui dans ce cas tu a raison j'ai pas penssé à la souris. Je vais devoir travailler ca :)
22/01/2009, 18h59
Roach-

J'aimerais bien voir ta source pour que je puisse améliorer la mienne :)

Voilà, j'ai du épurer un peu autour, mais ça doit fonctionner.

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
public class NumericTextBox : TextBox
{
  private const int WM_PASTE = 0x0302;
 
  protected override void WndProc(ref Message msg)
  {
    switch (msg.Msg)
    {
      case WM_PASTE:
        // received a paste event, handle it here
        HandlePasteData();
        break;
      default:
        // let the event continue its way
        base.WndProc(ref msg);
        break;
    }
  }
 
  protected override void OnKeyPress(KeyPressEventArgs e)
  {
    char c = e.KeyChar;
    // Char.IsControl let Copy/Paste pass
    if (Char.IsControl(c) || IsValidChar(c))
    {
      base.OnKeyPress(e);
    }
    else
    {
      // suppress the key press
      e.Handled = true;  
    }
  }
 
  private void HandlePasteData()
  {
    // retrieve clipboard data 
    IDataObject clipboard = Clipboard.GetDataObject();
 
    // check if the clipboard contains text data
    if (clipboard.GetDataPresent(DataFormats.Text))
    {
      string copyStr = (string)clipboard.GetData(DataFormats.Text);
 
      // clean the text from unwanted characters
      copyStr = RemoveUnWantedChars(copyStr);
 
      // initializes a StringBuilder with ...
      StringBuilder sb = new StringBuilder();
      // ... the text before the selection ...
      sb.Append(Text.Substring(0, SelectionStart));
      // ... the cleaned text ...
      sb.Append(copyStr);
      // ... and the text after the selection
      sb.Append(Text.Substring(SelectionStart + SelectionLength));
 
      // truncate the text length to MaxLength of the TextBox
      sb.Length = Math.Min(sb.Length, MaxLength);
 
      // mimics the paste behavior for windows TextBox : the caret is moved after the pasted data
      int newSelStart = SelectionStart + copyStr.Length;
      // set the nex text
      Text = sb.ToString();;
      // ensure the caret is not after MaxLength, to avoir ArgumentOutOfRangeException
      SelectionStart = Math.Min(newSelStart, MaxLength);
 
      // no selection
      SelectionLength = 0;
    }
  }
 
  private static string RemoveUnWantedChars(string s)
  {
    StringBuilder sb = new StringBuilder();
    foreach (char c in s)
    {
      if (IsValidChar(c))
      {
        sb.Append(c);
      }
    }
    return sb.ToString();
  }
 
  private static bool IsValidChar(char c)
  {
    if (Char.IsLetterOrDigit(c))
    {
      if (((c >= '0' && c <= '9')))
      {
        return true;
      }
    }
    return false;
  }
}

Oui vraiment génial et beaucoup mieux.

J'ai ajouter ceci pour accepter les , et . pour pouvoir écrire un nombre avec décimal.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            char c = e.KeyChar;
            // Char.IsControl let Copy/Paste pass
            if (Char.IsControl(c) || IsValidChar(c) || c == ',' || c == '.')
            {
                base.OnKeyPress(e);
            }
            else
            {
                // suppress the key press
                e.Handled = true;
            }
        }

Merci, je viens d'améliorer mon application grace a toi.

22/01/2009, 21h40
Greybird

Content que ça puisse te servir.
22/01/2009, 22h04
Roach-

le tout focntionne très bien cependant les , ou . sont enlever lors d'un copy paste (clavier et souris).

Dès que j'ai l solution je vous la donne.

Voila la modif pour ne pas enlever les , ou . lors d'un copy paste de souris ou clavier.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
        private static string RemoveUnWantedChars(string s)
        {
            StringBuilder sb = new StringBuilder();
            foreach (char c in s)
            {
                if (IsValidChar(c) || c == ',' || c == '.')
                {
                    sb.Append(c);
                }
            }
            return sb.ToString();
        }

Il suffit d'ajouter un class a votre projet copier ce code et changer le namespace pour le votre et voila vous avez un textbox numéric.

Dite merci Greybird :king:

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Globalization;
using System.Windows.Forms;
 
namespace [Votre NameSpace]
{
    public class NumericTextBox : TextBox
    {
        private const int WM_PASTE = 0x0302;
 
        protected override void WndProc(ref Message msg)
        {
            switch (msg.Msg)
            {
                case WM_PASTE:
                    // received a paste event, handle it here
                    HandlePasteData();
                    break;
                default:
                    // let the event continue its way
                    base.WndProc(ref msg);
                    break;
            }
        }
 
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            char c = e.KeyChar;
            // Char.IsControl let Copy/Paste pass
            if (Char.IsControl(c) || IsValidChar(c) || c == ',' || c == '.')
            {
                base.OnKeyPress(e);
            }
            else
            {
                // suppress the key press
                e.Handled = true;
            }
        }
 
        private void HandlePasteData()
        {
            // retrieve clipboard data 
            IDataObject clipboard = Clipboard.GetDataObject();
 
            // check if the clipboard contains text data
            if (clipboard.GetDataPresent(DataFormats.Text))
            {
                string copyStr = (string)clipboard.GetData(DataFormats.Text);
 
                // clean the text from unwanted characters
                copyStr = RemoveUnWantedChars(copyStr);
 
                // initializes a StringBuilder with ...
                StringBuilder sb = new StringBuilder();
                // ... the text before the selection ...
                sb.Append(Text.Substring(0, SelectionStart));
                // ... the cleaned text ...
                sb.Append(copyStr);
                // ... and the text after the selection
                sb.Append(Text.Substring(SelectionStart + SelectionLength));
 
                // truncate the text length to MaxLength of the TextBox
                sb.Length = Math.Min(sb.Length, MaxLength);
 
                // mimics the paste behavior for windows TextBox : the caret is moved after the pasted data
                int newSelStart = SelectionStart + copyStr.Length;
                // set the nex text
                Text = sb.ToString(); ;
                // ensure the caret is not after MaxLength, to avoir ArgumentOutOfRangeException
                SelectionStart = Math.Min(newSelStart, MaxLength);
 
                // no selection
                SelectionLength = 0;
            }
        }
 
        private static string RemoveUnWantedChars(string s)
        {
            StringBuilder sb = new StringBuilder();
            foreach (char c in s)
            {
                if (IsValidChar(c) || c == ',' || c == '.')
                {
                    sb.Append(c);
                }
            }
            return sb.ToString();
        }
 
        private static bool IsValidChar(char c)
        {
            if (Char.IsLetterOrDigit(c))
            {
                if (((c >= '0' && c <= '9')))
                {
                    return true;
                }
            }
            return false;
        }
    }
}

**** Aller voir plus loins il y a un code mise a jour ****

22/01/2009, 22h24
Greybird

Euh... Pourquoi tu n'inclus pas . et , dans la méthode IsValidChar ?

Ca évite de dupliquer le code et c'est justement le but de cette méthode de déterminer quels caractères sont autorisés, comme son nom l'indique...
22/01/2009, 22h38
Roach-

j'ai esseyé cependant il me l'enlevais pareil, j'ai pe mal procéder je vais revérifier demain matin je suis dans le rush maintenant.
22/01/2009, 22h53
Roach-

Petite question ... pourquoi 3 parenthèse ???

(((c >= '0' && c <= '9')))
22/01/2009, 23h15
Greybird
Citation:

Envoyé par Roach-

Petite question ... pourquoi 3 parenthèse ???

(((c >= '0' && c <= '9')))

On peut en enlever deux paires. C'est le reste du nettoyage que j'ai effectué, mes contrôles géraient bien plus que du simple numérique.

Pour ton problème de point et de virgule, je pense que ton erreur a été de mettre le test sur . et , à l'intérieur du bloc if (Char.IsLetterOrDigit(c)). Il faut le traiter en dehors, car point et virgule ne sont pas des lettres ou chiffres.

Enfin (je suis allé un peu vite dans mon nettoyage) :
Code:

1 2 3 4 5 6 7 8 9 10 11 private static bool IsValidChar(char c) { if (Char.IsLetterOrDigit(c)) { if (((c >= '0' && c <= '9'))) { return true; } } return false; }
est avantageusement remplacé par :
Code:

1 2 3 4 5 6 7 8 private static bool IsValidChar(char c) { if (Char.IsDigit(c)) { return true; } return false; }
Je gérais une entrée hexadécimale, et j'avais donc besoin d'accepter a-f et A-F dans mon contrôle original. Dans la précipitation cette simplification m'a échappé, désolé.
23/01/2009, 09h24
JOBiJOBa3

Merci pour votre débat ^^
Ce la va beaucoup m'aider.
:king:

J'ai vu un truc de ce genre :
Code:

1 2 3 4 5 6 7 8 private void KeyPress(object sender, KeyPressEventArgs e) { // N'accepte que du numérique et aussi le charactère : si vous voulez accepter seulement les chiffres mettre 57 au lieu de 58 if (e.KeyChar < 48 || e.KeyChar > 57 ) { e.Handled = true; } }
Cela n'accepte que les numériques. Les points et la virgules ne sont pas encore accepté, les backspace et le supr n'ont plus.
Je pense que les chiffre viennent de la table ASCII.
Voila, a creuser.

^^

23/01/2009, 10h30
Greybird

Il n'y a rien à creuser... On vient de te livrer une solution bien plus complète et tu t'acharnes sur la solution de départ ?!

Ce sont juste les équivalents numériques des caractères. Et encore une fois, ca ne gèrera que les frappes clavier.

Effectivement mon erreur provient du fait que je testais dans le bloc if. Pour les parenthèse c'est ce que je pensais car cela ne faisait pas la différence lorsque je les enlevais. Cependant j'aimais mieux demander car on ne sais jamais :)

Bob -> Je te conseil vivement d'utiliser le unsercontrol que nous te proposons.

Voici les dernier modif :

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Globalization;
using System.Windows.Forms;
 
namespace PrestigeGestion
{
    public class NumericTextBox : TextBox
    {
        private const int WM_PASTE = 0x0302;
 
        protected override void WndProc(ref Message msg)
        {
            switch (msg.Msg)
            {
                case WM_PASTE:
                    // received a paste event, handle it here
                    HandlePasteData();
                    break;
                default:
                    // let the event continue its way
                    base.WndProc(ref msg);
                    break;
            }
        }
 
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            char c = e.KeyChar;
            // Char.IsControl let Copy/Paste pass
            if (Char.IsControl(c) || IsValidChar(c))
            {
                base.OnKeyPress(e);
            }
            else
            {
                // suppress the key press
                e.Handled = true;
            }
        }
 
        private void HandlePasteData()
        {
            // retrieve clipboard data 
            IDataObject clipboard = Clipboard.GetDataObject();
 
            // check if the clipboard contains text data
            if (clipboard.GetDataPresent(DataFormats.Text))
            {
                string copyStr = (string)clipboard.GetData(DataFormats.Text);
 
                // clean the text from unwanted characters
                copyStr = RemoveUnWantedChars(copyStr);
 
                // initializes a StringBuilder with ...
                StringBuilder sb = new StringBuilder();
                // ... the text before the selection ...
                sb.Append(Text.Substring(0, SelectionStart));
                // ... the cleaned text ...
                sb.Append(copyStr);
                // ... and the text after the selection
                sb.Append(Text.Substring(SelectionStart + SelectionLength));
 
                // truncate the text length to MaxLength of the TextBox
                sb.Length = Math.Min(sb.Length, MaxLength);
 
                // mimics the paste behavior for windows TextBox : the caret is moved after the pasted data
                int newSelStart = SelectionStart + copyStr.Length;
                // set the nex text
                Text = sb.ToString(); ;
                // ensure the caret is not after MaxLength, to avoir ArgumentOutOfRangeException
                SelectionStart = Math.Min(newSelStart, MaxLength);
 
                // no selection
                SelectionLength = 0;
            }
        }
 
        private static string RemoveUnWantedChars(string s)
        {
            StringBuilder sb = new StringBuilder();
            foreach (char c in s)
            {
                if (IsValidChar(c))
                {
                    sb.Append(c);
                }
            }
            return sb.ToString();
        }
 
        private static bool IsValidChar(char c)
        {
            if (Char.IsDigit(c))
            {
                return true;
            }
            else if (c == ',' || c == '.')
            {
                return true;
            }
            else
                return false;
        }
    }
}