Why use decimal(int [ ]) constructor?

Question

I am maintaining a C# desktop application, on windows 7, using Visual Studio 2013. And somewhere in the code there is the following line, that tries to create a 0.01 decimal value, using a Decimal(Int32[]) constructor:

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

First question is, is it different from the following?

decimal d = 0.01M;

If it is not different, why the developer has gone through the trouble of coding like that?

I need to change this line in order to create dynamic values. Something like:

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

Am I going to cause some unwanted behavior this way?

Answer 1

It seems useful to me when the source of the decimal consists of bits.

The decimal used in .NET has an implementation that is based on a sequence of bit parameters (not just one stream of bits like with an int), so it can be useful to construct a decimal with bits when you communicate with other systems which return a decimal through a blob of bytes (a socket, from a piece of memory, etc).

It is easy now to convert the set of bits to a decimal now. No need for fancy conversion code. Also, you can construct a decimal from the inputs defined in the standard, which makes it convenient for testing the .NET framework too.

Answer 2

The decimal(int[] bits) constructor allows you to give a bitwise definition of the decimal you're creating bits must be a 4 int array where:

bits 0, 1, and 2 make up the 96-bit integer number.

bits 3 contains the scale factor and sign

It just allows you to get really precise with the definition of the decimal judging from your example I don't think you need that level of precision.

See here for more detail on using that constructor or here for other constructors that may be more appropriate for you

To more specifically answer your question if digitNumberis a 16bit exponent then decimal d = new decimal(new int[] { 1, 0, 0, digitNumber << 16 }); does what you want since the exponent goes in bits 16 - 23 of last int in the array

Answer 3

The definition in the xml is

    //
    // 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.

So for some unknown reason the original developer wanted to initialize his decimal this way. Maybe he was just wanted to confuse someone in the future.

It cant possibly affect your code if you change this to

decimal d = 0.01m;

because

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

Answer 4

You should exactly know how decimal stored in memory.

you can use this method to generate the desired value

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 });
}

Use it like

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

Here is the result

1
0.01
0.00001