运算符'！' 不能应用于long类型的操作数

Question

I am doing some conversion of some old VB code to C#. I am getting this error when converting a couple of properties.

"Operator '!' cannot be applied to operand of type long"

This is what the VB code looks like and hoping for some help with this.

Public Property Value() As Integer
    Get
        If (Me.m_Value < 32768) Then
            Return Me.m_Value
        Else
            Return -32768 + (Me.m_Value - 32768)
        End If
    End Get
    Set(ByVal PLCValue As Integer)
        Me.m_Value = PLCValue
    End Set
End Property

Public Property B0() As Boolean
    Get
        If ((Me.m_Value And &H1&) = &H1&) Then
            Return True
        Else
            Return False
        End If
    End Get
    Set(ByVal State As Boolean)
        If (State = True) Then
            Me.m_Value = Me.m_Value Or &H1&
        Else
            Me.m_Value = Me.m_Value And (Not &H1&)
        End If
    End Set
End Property
Public Property B1() As Boolean
    Get
        If ((Me.m_Value And &H2&) = &H2&) Then
            Return True
        Else
            Return False
        End If
    End Get
    Set(ByVal State As Boolean)
        If (State = True) Then
            Me.m_Value = Me.m_Value Or &H2&
        Else
            Me.m_Value = Me.m_Value And (Not &H2&)
        End If
    End Set
End Property

This is what it looks like when converting it. Both set conditions is where I am getting this error. The Or | I can change to casting to (int) and the error goes away but not sure on the else condition how to adjust that?

public int Value
    {
        get
        {
            if ((_value < 32768))
            {
                return _value;
            }
            else
            {
                return -32768 + (_value - 32768);
            }
        }
        set { _value = value; }
    }

    public bool B0
    {
        get
        {
            if (((_value & 0x1L) == 0x1L))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        set
        {
            if ((value == true))
            {
                _value = _value | 0x1L;
            }
            else
            {                    
                _value = _value & (!0x1L); 
            }
        }
    }
    public bool B1
    {
        get
        {
            if (((_value & 0x2L) == 0x2L))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        set
        {
            if ((value == true))
            {
                _value = _value | 0x2L;
            }
            else
            {
                _value = _value & (!0x2L);
            }
        }
    }

Thanks!

Answer 1

Complete code, hopefully correct:

public int Value
    {
        get
        {
            if ((_value < 32768))
            {
                return _value;
            }
            else
            {
                return -32768 + (_value - 32768);
            }
        }
        set { _value = value; }
    }

    public bool B0
    {
        get
        {
            if (((_value & 0x1) == 0x1))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        set
        {
            if ((value == true))
            {
                _value = _value | 0x1;
            }
            else
            {                    
                _value = _value & (~0x1); 
            }
        }
    }
    public bool B1
    {
        get
        {
            if (((_value & 0x2) == 0x2))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        set
        {
            if ((value == true))
            {
                _value = _value | 0x2;
            }
            else
            {
                _value = _value & (~0x2);
            }
        }
    }

As I pointed out in my comment and was confirmed by @mataps link, the Not on the numerical value should be interpreted as a bitwise negate ~ in C#. Also, I dropped the L literal everywhere, because Value is of type int , not long , so now the compiler hopefully doesn't compain about doing bitwise operations on different types ( int and long )