C # Vérifier si une décimale a plus de 3 décimales?

J'ai une situation que je ne peux pas changer: une table de base de données (tableau A) accepte les 6 chiffres après la virgule, tandis qu'une colonne liée dans un autre tableau (tableau B) a seulement 3 décimales.

J'ai besoin de copier de A à B, mais si l'Un a plus de 3 décimales supplémentaires, les données seront perdues. Je ne peux pas changer la définition de la table mais je peux ajouter une solution de contournement. Donc j'essaie de trouver comment faire pour vérifier si un nombre décimal a plus de 3 décimales ou pas?

par exemple

Table A
Id, Qty,  Unit(=6dp)
1,  1,     0.00025
2,  4000,  0.00025

Table B
Id, TotalQty(=3dp)

Je veux être en mesure de savoir si Qté * Unité à partir de la Table Un a plus de 3 décimales (ligne 1 serait un échec, ligne 2 pass):

if (CountDecimalPlaces(tableA.Qty * tableA.Unit) > 3)
{
    return false;
}
tableB.TotalQty = tableA.Qty * tableA.Unit;

Comment pourrais-je mettre en œuvre les CountDecimalPlaces(decimal value) {} fonction?

source d'informationauteur JK.

c#decimal

Cela fonctionne pour les 3 décimales, et il peut être adapté pour une solution générique:

static bool LessThan3DecimalPlaces(decimal dec)
{
    decimal value = dec * 1000;
    return value == Math.Floor(value);
}
static void Test()
{
    Console.WriteLine(LessThan3DecimalPlaces(1m * 0.00025m));
    Console.WriteLine(LessThan3DecimalPlaces(4000m * 0.00025m));
}

Pour une vraie solution générique, vous aurez besoin de "déconstruire" la valeur décimale dans ses parties, de prendre un coup d'oeil à Décimal.GetBits pour plus d'informations.

Mise à jour: c'est une simple mise en œuvre d'une solution générique qui fonctionne pour toutes les décimales dont la partie entière est moins long.MaxValue (vous auriez besoin de quelque chose comme un "grand entier" pour un trully fonction générique).

static decimal CountDecimalPlaces(decimal dec)
{
    int[] bits = Decimal.GetBits(dec);
    int exponent = bits[3] >> 16;
    int result = exponent;
    long lowDecimal = bits[0] | (bits[1] >> 8);
    while ((lowDecimal % 10) == 0)
    {
        result--;
        lowDecimal /= 10;
    }

    return result;
}
static void Foo()
{
    Console.WriteLine(CountDecimalPlaces(1.6m));
    Console.WriteLine(CountDecimalPlaces(1.600m));
    Console.WriteLine(CountDecimalPlaces(decimal.MaxValue));
    Console.WriteLine(CountDecimalPlaces(1m * 0.00025m));
    Console.WriteLine(CountDecimalPlaces(4000m * 0.00025m));
}

45

Vous pouvez comparer la valeur du nombre arrondi à 3 décimales avec la valeur d'origine.
```
if (Decimal.Round(valueDecimal, 3) != valueDecimal)
{
   //Too many decimals
}
```
3

Les bases est de savoir comment faire pour tester si il y a des décimales, ce qui est fait en comparant la valeur de son arrondissement
```
double number;
bool hasDecimals = number == (int) number;
```
Puis, à compter de 3 décimales, vous avez juste besoin de faire la même chose pour votre nombre multiplié par 1000:
```
bool hasMoreThan3decimals = number*1000 != (int) (number * 1000)
```

Toutes les solutions proposées jusqu'à présent ne sont pas extensibles ... amende si vous n'allez jamais à vérifier une valeur autre que 3, mais je préfère cela, car si l'exigence modifie le code de poignée, il est déjà écrit. Aussi cette solution habitude de débordement.

int GetDecimalCount(decimal val)
{
    if(val == val*10)
    {
        return int.MaxValue; //no decimal.Epsilon I don't use this type enough to know why... this will work
    }

    int decimalCount = 0;
    while(val != Math.Floor(val))
    {
        val = (val - Math.Floor(val)) * 10;
        decimalCount++;
    }
    return decimalCount;
}

carlosfigueira solution aurez besoin de vérifier pour 0 sinon "while ((lowDecimal % 10) == 0)" sera de produire une infinité de boucle lorsqu'elle est appelée avec dec = 0

static decimal CountDecimalPlaces(decimal dec)
    {
        if (dec == 0)
            return 0;
        int[] bits = Decimal.GetBits(dec);
        int exponent = bits[3] >> 16;
        int result = exponent;
        long lowDecimal = bits[0] | (bits[1] >> 8);
        while ((lowDecimal % 10) == 0)
        {
            result--;
            lowDecimal /= 10;
        }
        return result;
    }

    Assert.AreEqual(0, DecimalHelper.CountDecimalPlaces(0m));      
    Assert.AreEqual(1, DecimalHelper.CountDecimalPlaces(0.5m));
    Assert.AreEqual(2, DecimalHelper.CountDecimalPlaces(10.51m));
    Assert.AreEqual(13, DecimalHelper.CountDecimalPlaces(10.5123456978563m));

2

La multiplication d'un nombre à 3 décimales par 10 à la puissance de 3 vous donnera un certain nombre sans décimale. C'est un nombre entier lorsque le module % 1 == 0. Donc, je suis venu avec cette...
```
bool hasMoreThanNDecimals(decimal d, int n)
{
    return !(d * (decimal)Math.Pow(10, n) % 1 == 0);
}
```
Renvoie true lorsque n est moins (pas égal à) le nombre de décimales.

C'est très simple ligne de code pour obtenir des nombre de décimales d'un nombre Décimal:

decimal myDecimal = 1.000000021300010000001m;
byte decimals = (byte)((Decimal.GetBits(myDecimal)[3] >> 16) & 0x7F);

1

Il y a probablement un moyen plus élégant de le faire, mais du haut de ma tête que je voudrais essayer
1. a = multiplier par 1000
2. b = tronquer un
3. if (b != a) puis il y a davantage de précision qui a été perdu

    bool CountDecimalPlaces(decimal input)
    {
        return input*1000.0 == (int) (input*1000);
    }

0

pourriez-vous convertir en une chaîne et il suffit de faire une fonction len ou ne serait-ce pas couvrir votre situation?

question de suivi:
serait 300.4 être ok?

Public Function getDecimalCount(decWork As Decimal) As Integer

    Dim intDecimalCount As Int32 = 0
    Dim strDecAbs As String = decWork.ToString.Trim("0")

    intDecimalCount = strDecAbs.Substring(strDecAbs.IndexOf(".")).Length -1

    Return intDecimalCount

End Function

Une option de plus basé sur @RodH257 de la solution, mais retravaillé comme une extension de la méthode:

public static bool HasThisManyDecimalPlacesOrLess(this decimal value, int noDecimalPlaces)
{
    return (Decimal.Round(value, noDecimalPlaces) == value);
}

Vous pouvez ensuite appeler ça comme:

If !(tableA.Qty * tableA.Unit).HasThisManyDecimalPlacesOrLess(3)) return;

Vous devez vous connecter pour publier un commentaire.