Pourquoi utiliser le constructeur décimal (int [])?

Question

Je suis le maintien d'une application de bureau C#, windows 7, à l'aide de Visual Studio 2013. Et quelque part dans le code il y a la ligne suivante, qui tente de créer une 0.01 valeur décimale, à l'aide d'une Virgule(Int32[]) constructeur:

decimal d = new decimal(new int[] { 1, 0, 0, 131072 });

La première question est, est-elle différente de la suivante?

decimal d = 0.01M;

Si elle n'est pas différent, pourquoi le réalisateur a pris la peine de codage comme ça?

J'ai besoin de changer cette ligne dans le but de créer des valeurs dynamiques. Quelque chose comme:

decimal d = (decimal) (1 / Math.Pow(10, digitNumber));

Vais-je la cause de certains comportement indésirable de cette façon?

Answer 1

Il semble utile de moi quand la source de la virgule se compose de bits.

Le nombre utilisé dans .NET est une application qui est basée sur une séquence de bits de paramètres (pas seulement un flux de bits comme avec un int), de sorte qu'il peut être utile de construire un décimal à l'aide de bits lorsque vous communiquez avec d'autres systèmes de retour d'un décimal par un blob d'octets (un socket à partir d'un morceau de la mémoire, etc).

Il est maintenant facile de convertir l'ensemble de bits à virgule maintenant. Pas besoin de fantaisie code de conversion. Aussi, vous pouvez construire une virgule depuis les entrées définies dans la norme, ce qui le rend pratique pour le test de la .NET framework trop.

Answer 2

L' decimal(int[] bits) constructeur permet de donner un bit à bit de définition de la décimale vous êtes à la création de bits doit être un 4 int tableau où:

les bits 0, 1, et 2 les 96 bits nombre entier.

bits 3 contient le facteur d'échelle et de signer

Il permet simplement à être vraiment précis dans la définition de la virgule, à en juger par votre exemple, je ne pense pas que vous avez besoin de ce niveau de précision.

Voir ici pour plus de détails sur l'utilisation que constructeur ou ici pour les autres constructeurs qui pourrait être plus approprié pour vous

Pour plus de répondre spécifiquement à votre question, si digitNumberest un 16 bits de l'exposant ensuite, decimal d = new decimal(new int[] { 1, 0, 0, digitNumber << 16 }); fait ce que vous voulez depuis l'exposant va dans les bits 16 à 23 de la dernière int dans le tableau

Answer 3

La définition dans le xml est

     //
    // Summary:
    //     Initializes a new instance of System.Decimal to a decimal value represented
    //     in binary and contained in a specified array.
    //
    // Parameters:
    //   bits:
    //     An array of 32-bit signed integers containing a representation of a decimal
    //     value.
    //
    // Exceptions:
    //   System.ArgumentNullException:
    //     bits is null.
    //
    //   System.ArgumentException:
    //     The length of the bits is not 4.-or- The representation of the decimal value
    //     in bits is not valid.
 

Donc, pour une raison inconnue, le développeur d'origine voulait initialiser sa décimale de cette façon. Peut-être qu'il voulait juste confondre quelqu'un à l'avenir.

Cela ne peut pas affecter votre code si vous le changez en

 decimal d = 0.01m;
 

car

 (new decimal(new int[] { 1, 0, 0, 131072})) == 0.01m
 

Answer 4

Vous devez savoir exactement comment les décimales sont stockées en mémoire.

vous pouvez utiliser cette méthode pour générer la valeur souhaitée

 public static decimal Base10FractionGenerator(int digits)
{
    if (digits < 0 || digits > 28)
        throw new ArgumentException($"'{nameof(digits)}' must be between 0 and 28");

    return new decimal(new[] { 1, 0, 0, digits << 16 });
}
 

Utilisez-le comme

 Console.WriteLine(Base10FractionGenerator(0));
Console.WriteLine(Base10FractionGenerator(2));
Console.WriteLine(Base10FractionGenerator(5));
 

Voici le résultat

1
0,01
0,00001

Answer 5

Le constructeur particulier vous parlez génère un nombre décimal à partir de quatre valeurs de 32 bits. Malheureusement, les nouvelles versions de la Common Language Infrastructure (CLI) de quitter son format exact non précisé (sans doute pour permettre des implémentations pour prendre en charge différents formats décimaux) et maintenant, simplement à garantir au moins une précision spécifique et de la gamme de nombres décimaux. Toutefois, les versions antérieures de la CLI de définir ce format exactement comme Microsoft mise en œuvre du fait, donc c'est probablement le rester dans l'implémentation Microsoft pour des raisons de compatibilité descendante. Cependant, il n'est pas exclu que d'autres implémentations de la CLI interpréter les quatre valeurs de 32 bits de la Décimale constructeur différemment.