为什么我不能在c＃中定义一下？

Question

为什么C＃中没有一点结构？

Answer 1

For what's worth, here is a full-fledged bit structure, complete with int and bool casting and arithmetic operations. Probably not perfect, but works fine for me. Enjoy!

/// <summary>
/// Represents a single bit that can be implicitly cast to/from and compared
/// with booleans and integers.
/// </summary>
/// <remarks>
/// <para>
/// An instance with a value of one is equal to any non-zero integer and is true,
/// an instance with a value of zero is equal to the integer zero and is false.
/// </para>
/// <para>
/// Arithmetic and logical AND, OR and NOT, as well as arithmetic XOR, are supported.
/// </para>
/// </remarks>
public struct Bit
{
    /// <summary>
    /// Creates a new instance with the specified value.
    /// </summary>
    /// <param name="value"></param>
    public Bit(int value) : this()
    {
        Value = value == 0 ? 0 : 1;
    }

    /// <summary>
    /// Gets the value of the bit, 0 or 1.
    /// </summary>
    public int Value { get; private set; }

    #region Implicit conversions

    public static implicit operator Bit(int value)
    {
        return new Bit(value);
    }

    public static implicit operator int(Bit value)
    {
        return value.Value;
    }

    public static implicit operator bool(Bit value)
    {
        return value.Value == 1;
    }

    public static implicit operator Bit(bool value)
    {
        return new Bit(value ? 1 : 0);
    }

    #endregion

    #region Arithmetic operators

    public static Bit operator |(Bit value1, Bit value2)
    {
        return value1.Value | value2.Value;
    }

    public static Bit operator &(Bit value1, Bit value2)
    {
        return value1.Value & value2.Value;
    }

    public static Bit operator ^(Bit value1, Bit value2)
    {
        return value1.Value ^ value2.Value;
    }

    public static Bit operator ~(Bit value)
    {
        return new Bit(value.Value ^ 1);
    }

    public static Bit operator !(Bit value)
    {
        return ~value;
    }

    #endregion

    #region The true and false operators

    public static bool operator true(Bit value)
    {
        return value.Value == 1;
    }

    public static bool operator false(Bit value)
    {
        return value.Value == 0;
    }

    #endregion

    #region Comparison operators

    public static bool operator ==(Bit bitValue, int intValue)
    {
        return 
          (bitValue.Value == 0 && intValue == 0) || 
          (bitValue.Value == 1 && intValue != 0);
    }

    public static bool operator !=(Bit bitValue, int intValue)
    {
        return !(bitValue == intValue);
    }

    public override bool Equals(object obj)
    {
        if(obj is int)
            return this == (int)obj;
        else
            return base.Equals(obj);
    }

    #endregion
}

Answer 2

It is called a boolean. At least, it would serve the basic function, right? You don't twiddle bits that often in C# (at least, I don't), and if you need to you can use the built in operations.

Answer 3

有一个BitArray类..

Answer 4

What would you want to do with it? Bear in mind that the CLR isn't going to try to pack multiple variables into a byte, so having one on its own would be no more useful than boolean. If you wanted to have a collection of them - well, that's what BitArray is for, as David pointed out.

If we did have a Bit structure, I suspect people would expect multiple Bit variables to be packed efficiently in memory - by not having the type in the first place, we avoid that expectation and lead people towards other solutions such as BitArray.

Answer 5

如果你有一个位标志的集合，那么使用枚举（使用falgs属性）和整数工作很长。

Answer 6

Though maybe there are rare exceptions, computers are not designed or intended to manipulate or allocate individual bits. Even at the lowest levels (assembly or pure machine language), you will not be able to allocate or access an individual bit. You have the same tools available in this regard as you have from any programming level: bytes and bitwise operations.

Answer 7

Along with the BitArray class already mentioned there is a also the more efficient BitVector32 Structure .

BitVector32 is more efficient than BitArray for Boolean values and small integers that are used internally. A BitArray can grow indefinitely as needed, but it has the memory and performance overhead that a class instance requires. In contrast, a BitVector32 uses only 32 bits.

Keep in mind you are limited to 32 values.

Examples of BitVector32 usage at Dotnetpearls.com

Answer 8

You can do this now in C# 7.0!

public const int One = 0b0001;

https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-7#numeric-literal-syntax-improvements