如何在标签上表示二进制数字？

Question

I converted decimal to binary number however i dont know how to represent on label. I have a list of numbers 0 and 1,Now, how do I display the information on labels.In fact, i dont know how to represent on label.

   private void btnRun_Click(object sender, EventArgs e)
        {
               var decimaltoBinary = fnDecimalToBinary(Convert.ToInt32(txtenterNumber.Text));

    }

 private List<int> fnDecimalToBinary(int number)
    {

        int[] decimalNumbers = new int[] { 1, 2, 4, 8, 16, 32, 64, 128, 256 };
        List<int> binaryNumbers = new List<int>();
        int locDecimalArray = 0;
        int sumNumber = 0;

        for (int i = 0; i < decimalNumbers.Length; i++)
        {
            if (number < decimalNumbers[i])
            {
                sumNumber = number;
                locDecimalArray = i - 1;
                for (int j = locDecimalArray; j >= 0; j--)
                {
                    if (sumNumber == 0)
                    {
                        binaryNumbers.Add(0);
                        return binaryNumbers;
                    }
                    else if (sumNumber >= decimalNumbers[j])
                    {
                        sumNumber = sumNumber - decimalNumbers[j];
                        binaryNumbers.Add(1);
                    }
                    else if (sumNumber < decimalNumbers[j])
                    {
                        binaryNumbers.Add(0);
                    }
                }
                return binaryNumbers;

            }

        }
        return binaryNumbers;
    }

Answer 1

It seems that you've received a comment that explains how you can convert your List<int> to the string value you need for the Label control. However, it seems to me that for the purposes of this exercise, you might benefit from some help with the decimal-to-binary conversion itself. There are already a number of similar questions on Stack Overflow dealing with this scenario (as you can guess, converting to binary text is a fairly common programming exercise), but of course none will start with your specific code, so I think it's worth writing yet another answer. :)

Basing the conversion on a pre-computed list of numeric values is not a terrible way to go, especially for the purposes of learning. But your version has a bunch of extra code that's just not necessary:

1. Your outer loop doesn't accomplish anything except verify that the number passed is within the range permitted by your pre-computed values. But this can be done as part of the conversion itself.
2. Furthermore, I'm not convinced that returning an empty list is really the best way to deal with invalid input. Throwing an exception would be more appropriate, as this forces the caller to deal with errors, and allows you to provide a textual message for display to the user.
3. The value 0 is always less than any of the digit values you've pre-computed, so there's no need to check for that explicitly. You really only need the if and a single else inside the inner loop.
4. Since you are the one populating the array, and since for loops are generally more readable when they start at 0 and increment the index as opposed to starting at the end and decrement, it seems to me that you would be better off writing the pre-computed values in reverse.
5. Entering numbers by hand is a pain and it seems to me that the method could be more flexible (ie support larger binary numbers) if you allowed the caller to pass the number of digits to produce, and used that to compute the values at run-time (though, if for performance reasons that's less desirable, pre-computing the largest digits that would be used and storing that in a static field, and then just using whatever subset of that you need, would be yet another suitable approach).

With those changes, you would get something like this:

private List<int> DecimalToBinary(int number, int digitCount)
{
    // The number can't itself have more than 32 digits, so there's
    // no point in allowing the caller to ask for more than that.
    if (digitCount < 1 || digitCount > 32)
    {
        throw new ArgumentOutOfRangeException("digitCount",
            "digitCount must be between 1 and 32, inclusive");
    }

    long[] digitValues = Enumerable.Range(0, digitCount)
        .Select(i => (long)Math.Pow(2, digitCount - i - 1)).ToArray();
    List<int> binaryDigits = new List<int>(digitCount);

    for (int i = 0; i < digitValues.Length; i++)
    {
        if (digitValues[i] <= number)
        {
            binaryDigits.Add(1);
            number = (int)(number - digitValues[i]);
        }
        else
        {
            binaryDigits.Add(0);
        }
    }

    if (number > 0)
    {
        throw new ArgumentOutOfRangeException("digitCount",
            "digitCount was not large number to accommodate the number");
    }

    return binaryDigits;
}

And here's an example of how you might use it:

private void button1_Click(object sender, EventArgs e)
{
    int number;

    if (!int.TryParse(textBox1.Text, out number))
    {
        MessageBox.Show("Could not convert user input to an int value");
        return;
    }

    try
    {
        List<int> binaryDigits = DecimalToBinary(number, 8);

        label3.Text = string.Join("", binaryDigits);
    }
    catch (ArgumentOutOfRangeException e1)
    {
        MessageBox.Show("Exception: " + e1.Message, "Could not convert to binary");
    }
}

Now, the above example fits the design you originally had, just cleaned it up a bit. But the fact is, the computer already knows binary. That's how it stores numbers, and even if it didn't, C# includes operators that treat the numbers as binary (so if the computer didn't use binary, the run-time would be required to translate for you anyway). Given that, it's actually a lot easier to convert just by looking at the individual bits. For example:

private List<int> DecimalToBinary2(int number, int digitCount)
{
    if (digitCount < 1 || digitCount > 32)
    {
        throw new ArgumentOutOfRangeException("digitCount",
            "digitCount must be between 1 and 32, inclusive");
    }

    if (number > Math.Pow(2, digitCount) - 1)
    {
        throw new ArgumentOutOfRangeException("digitCount",
            "digitCount was not large number to accommodate the number");
    }

    List<int> binaryDigits = new List<int>(digitCount);

    for (int i = digitCount - 1; i >= 0; i--)
    {
        binaryDigits.Add((number & (1 << i)) != 0 ? 1 : 0);
    }

    return binaryDigits;
}

The above simply starts at the highest possible binary digit (given the desired count of digits), and checks each individual digit in the provided number, using the "bit-shift" operator << and the logical bitwise "and" operator & . If you're not already familiar with binary arithmetic, shift operations, and these operators, this might seem like overkill. But it's actually a fundamental aspect of how computers work, worth knowing, and of course as shown above, can dramatically simplify code required to deal with binary data (to the point where parameter validation code takes up half the method :) ).

One last thing: this entire discussion ignores the fact that you're using a signed int value, rather than the unsigned uint type. Technically, this means your code really ought to be able to handle negative numbers as well. However, doing so is a bit trickier when you also want to deal with binary digit counts that are less than the natural width of the number in the numeric type (eg 32 bits for an int ). Conversely, if you don't want to support negative numbers, you should really be using the uint type instead of int .

I figured that trying to address that particular complication would dramatically increase the complexity of this answer and take away from the more fundamental details that seemed worth conveying. So I've left that out. But I do encourage you to look more deeply into how computers represent numbers, and why negative numbers require more careful handling than the above code is doing.