Déterminer quelle fonction appeler en fonction de la longueur de la décimale

Question

En C#, j'ai deux situations possibles dans un contrôle de zone de texte.

Les chiffres peuvent être:

a) .xxxx

ou

b) .XX

Comment puis-je écrire une condition qui dit: « Si la zone de texte a 4 décimales, puis appelez cette fonction, sinon, si la zone de texte a 2 décimales, appelez cette fonction. "

Cela semble facile, mais je ne sais pas comment évaluer les décimales.

Merci beaucoup!

Answer 1

Vous pouvez utiliser Regex

new Regex(@"\.\d{2}$").IsMatch(input.Value) 

Answer 2

Etat évaluera true sur deux, mais pas quatre décimales:

Math.Round(100*x) == 100*x 

EDIT: condition ci-dessus ne fonctionne que pour le type décimal. Eh bien, suite à des travaux pour les nombres réels de tous les types:

(Math.Ceiling(100 * x) - 100 * x) < 10e-8) 

EDIT: Eh bien, si vous êtes intéressé par les chaînes puis utilisez suivantes (chaîne d'extension contient dernier point et chiffres suivants/numéros):

System.IO.Path.GetExtension(input).Length 

Answer 3

if(txtNumber.Text.Split(new[]{'.'})[1].Length == 2) 
{ 
    //case b 
} 
else 
{ 
    //case a 
} 

Vous pouvez utiliser le séparateur décimal de la culture actuelle du système au lieu de coder en dur le point.

Answer 4

Vous pourriez profiter d'une caractéristique très obscure du type décimal. Sa représentation interne est un nombre de 96 bits avec un exposant. L'exposant est égal au nombre de chiffres de la fraction, même si les chiffres fractionnaires sont nuls. Ainsi:

public static int GetFractionalDigits(string txt) { 
    decimal value = decimal.Parse(txt); 
    return (decimal.GetBits(value)[3] >> 16) & 0x7fff; 
} 

Utilisez decimal.TryParse() si vous avez besoin de valider l'entrée utilisateur.

Answer 5

Cela peut ne pas fonctionner parfaitement en fonction de vos besoins, mais il fonctionne à mes fins et pourrait être utile à quelqu'un d'autre.

static class MathCustom 
{ 
    static public byte NumberOfDecimals(decimal value) 
    { 
     sbyte places = -1; 
     decimal testValue; 

     do 
     { 
      places++; 
      testValue = Math.Round(value, places); 
     } while (testValue != value); 

     return (byte)places; 
    } 

    static public byte NumberOfDecimals(float value) 
    { 
     sbyte places = -1; 
     float testValue; 

     do 
     { 
      places++; 
      testValue = (float)Math.Round((decimal)value, places); 
     } while (testValue != value); 

     return (byte)places; 
    } 

    /// <summary> 
    /// This version of NumberOfDecimals allows you to provide a Maximum 
    /// for allowable decimals. This method will allow for the correction 
    /// of floating point errors when it is less than 10 or passed in as null. 
    /// </summary> 
    /// <param name="value">Value to check the number of held decimal places</param> 
    /// <param name="knownMaximum"></param> 
    /// <returns>The number of decimal places in Value.</returns> 
    static public byte NumberOfDecimals(decimal value, byte? knownMaximum) 
    { 
     byte maximum; 
     decimal localValue; 
     sbyte places = -1; 
     decimal testValue; 

     if (knownMaximum == null) 
     { 
      maximum = 9; 
     } 
     else 
     { 
      maximum = (byte)knownMaximum; 
     } 

     localValue = Math.Round(value, maximum); 

     do 
     { 
      places++; 
      testValue = Math.Round(localValue, places); 
     } while (testValue != localValue); 

     return (byte)places; 
    } 

}