C# Signature:

[StructLayout(LayoutKind.Sequential)]
public struct RECT
{
   public int Left, Top, Right, Bottom;
    [StructLayout(LayoutKind.Sequential)]
    public struct RECT
    {
        public int left;
        public int top;
        public int right;
        public int bottom;
        //
        public RECT(RECT Rectangle)
        : this(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom)
        {
        }
        public RECT(int Left, int Top, int Right, int Bottom)
        {
        left = Left;
        top = Top;
        right = Right;
        bottom = Bottom;
        }
        //
        public int X
        {
        get
        {
            return left;
        }
        set
        {
            right -= (left - value);
            left = value;
        }
        }
        public int Y
        {
        get
        {
            return top;
        }
        set
        {
            bottom -= (top - value);
            top = value;
        }
        }
        public int Height
        {
        get
        {
            return bottom - top;
        }
        set
        {
            bottom = value + top;
        }
        }
        public int Width
        {
        get
        {
            return right - left;
        }
        set
        {
            right = value + left;
        }
        }
        //
        public int Left
        {
        get
        {
            return left;
        }
        set
        {
            left = value;
        }
        }
        public int Top
        {
        get
        {
            return top;
        }
        set
        {
            top = value;
        }
        }
        public int Right
        {
        get
        {
            return right;
        }
        set
        {
            right = value;
        }
        }
        public int Bottom
        {
        get
        {
            return bottom;
        }
        set
        {
            bottom = value;
        }
        }
        //
        public Point Location
        {
        get
        {
            return new Point(Left, Top);
        }
        set
        {
            right -= (left - value.X);
            bottom -= (top - value.Y);
            left = value.X;
            top = value.Y;
        }
        }
        public Size Size
        {
        get
        {
            return new Size(Width, Height);
        }
        set
        {
            right = value.Width + left;
            bottom = value.Height + top;
        }
        }
        //
        public static implicit operator Rectangle(RECT Rectangle)
        {
        return new Rectangle(Rectangle.Left, Rectangle.Top, Rectangle.Width, Rectangle.Height);
        }
        public static implicit operator RECT(Rectangle Rectangle)
        {
        return new RECT(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom);
        }
        //
        public static bool operator ==(RECT Rectangle1, RECT Rectangle2)
        {
        return Rectangle1.Equals(Rectangle2);
        }
        public static bool operator !=(RECT Rectangle1, RECT Rectangle2)
        {
        return !Rectangle1.Equals(Rectangle2);
        }
        //
        public bool Equals(RECT Rectangle)
        {
        return Rectangle.Left == left && Rectangle.Top == top && Rectangle.Right == right && Rectangle.Bottom == bottom;
        }
        public override bool Equals(object Object)
        {
        if (Object is RECT)
        {
            return Equals((RECT)Object);
        }
        else if (Object is Rectangle)
        {
            return Equals(new RECT((Rectangle)Object));
        }

   public RECT(int left, int top, int right, int bottom)
   {
     Left = left;
     Top = top;
     Right = right;
     Bottom = bottom;
   }
        return false;
        }
        //
        public override int GetHashCode()
        {
        return ToString().GetHashCode();
        }
        public override string ToString()
        {
        return "{Left: " + left + "; " + "Top: " + top + "; Right: " + right + "; Bottom: " + bottom + "}";
        }
    }

   public RECT(System.Drawing.Rectangle r) : this(r.Left, r.Top, r.Right, r.Bottom) { }

VB.NET Signature:

<StructLayout(LayoutKind.Sequential)> _
Public Structure RECT
    Private _Left As Integer, _Top As Integer, _Right As Integer, _Bottom As Integer

   public int X
   {
     get { return Left; }
     set { Right -= (Left - value); Left = value; }
   }
    Public Sub New(ByVal Rectangle As Rectangle)
        Me.New(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom)
    End Sub
    Public Sub New(ByVal Left As Integer, ByVal Top As Integer, ByVal Right As Integer, ByVal Bottom As Integer)
        _Left = Left
        _Top = Top
        _Right = Right
        _Bottom = Bottom
    End Sub

   public int Y
   {
     get { return Top; }
     set { Bottom -= (Top - value); Top = value; }
   }
    Public Property X As Integer
        Get
        Return _Left
        End Get
        Set(ByVal value As Integer)
        _Right = _Right - _Left + value
        _Left = value
        End Set
    End Property
    Public Property Y As Integer
        Get
        Return _Top
        End Get
        Set(ByVal value As Integer)
        _Bottom = _Bottom - _Top + value
        _Top = value
        End Set
    End Property
    Public Property Left As Integer
        Get
        Return _Left
        End Get
        Set(ByVal value As Integer)
        _Left = value
        End Set
    End Property
    Public Property Top As Integer
        Get
        Return _Top
        End Get
        Set(ByVal value As Integer)
        _Top = value
        End Set
    End Property
    Public Property Right As Integer
        Get
        Return _Right
        End Get
        Set(ByVal value As Integer)
        _Right = value
        End Set
    End Property
    Public Property Bottom As Integer
        Get
        Return _Bottom
        End Get
        Set(ByVal value As Integer)
        _Bottom = value
        End Set
    End Property
    Public Property Height() As Integer
        Get
        Return _Bottom - _Top
        End Get
        Set(ByVal value As Integer)
        _Bottom = value + _Top
        End Set
    End Property
    Public Property Width() As Integer
        Get
        Return _Right - _Left
        End Get
        Set(ByVal value As Integer)
        _Right = value + _Left
        End Set
    End Property
    Public Property Location() As Point
        Get
        Return New Point(Left, Top)
        End Get
        Set(ByVal value As Point)
        _Right = _Right - _Left + value.X
        _Bottom = _Bottom - _Top + value.Y
        _Left = value.X
        _Top = value.Y
        End Set
    End Property
    Public Property Size() As Size
        Get
        Return New Size(Width, Height)
        End Get
        Set(ByVal value As Size)
        _Right = value.Width + _Left
        _Bottom = value.Height + _Top
        End Set
    End Property

   public int Height
   {
     get { return Bottom - Top; }
     set { Bottom = value + Top; }
   }
    Public Shared Widening Operator CType(ByVal Rectangle As RECT) As Rectangle
        Return New Rectangle(Rectangle.Left, Rectangle.Top, Rectangle.Width, Rectangle.Height)
    End Operator
    Public Shared Widening Operator CType(ByVal Rectangle As Rectangle) As RECT
        Return New RECT(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom)
    End Operator
    Public Shared Operator =(ByVal Rectangle1 As RECT, ByVal Rectangle2 As RECT) As Boolean
        Return Rectangle1.Equals(Rectangle2)
    End Operator
    Public Shared Operator <>(ByVal Rectangle1 As RECT, ByVal Rectangle2 As RECT) As Boolean
        Return Not Rectangle1.Equals(Rectangle2)
    End Operator

   public int Width
   {
     get { return Right - Left; }
     set { Right = value + Left; }
   }
    Public Overrides Function ToString() As String
        Return "{Left: " & _Left & "; " & "Top: " & _Top & "; Right: " & _Right & "; Bottom: " & _Bottom & "}"
    End Function

   public System.Drawing.Point Location
   {
     get { return new System.Drawing.Point(Left, Top); }
     set { X = value.X; Y = value.Y; }
   }
    Public Overloads Function Equals(ByVal Rectangle As RECT) As Boolean
        Return Rectangle.Left = _Left AndAlso Rectangle.Top = _Top AndAlso Rectangle.Right = _Right AndAlso Rectangle.Bottom = _Bottom
    End Function
    Public Overloads Overrides Function Equals(ByVal [Object] As Object) As Boolean
        If TypeOf [Object] Is RECT Then
        Return Equals(DirectCast([Object], RECT))
        ElseIf TypeOf [Object] Is Rectangle Then
        Return Equals(New RECT(DirectCast([Object], Rectangle)))
        End If

   public System.Drawing.Size Size
   {
     get { return new System.Drawing.Size(Width, Height); }
     set { Width = value.Width; Height = value.Height; }
   }
        Return False
    End Function
End Structure

VB Signature

Public Type RECT
     Left As Long
     Top As Long
     Right As Long
     Bottom As Long
End Type

User-Defined Types:

None.

   public static implicit operator System.Drawing.Rectangle(RECT r)
   {
     return new System.Drawing.Rectangle(r.Left, r.Top, r.Width, r.Height);
   }

Notes:

The Win32 RECT structure is not compatible with the .NET System.Drawing.Rectangle structure.

   public static implicit operator RECT(System.Drawing.Rectangle r)
   {
     return new RECT(r);
   }

The RECT structure has left, top, right and bottom members,

but the System.Drawing.Rectangle structure has left, top, width and height members internally.

   public static bool operator ==(RECT r1, RECT r2)
   {
     return r1.Equals(r2);
   }

This import is required for VB.NET if missing:

Imports System.Runtime.InteropServices

   public static bool operator !=(RECT r1, RECT r2)
   {
     return !r1.Equals(r2);
   }

Add a reference to System.Drawing to use this.

   public bool Equals(RECT r)
   {
     return r.Left == Left && r.Top == Top && r.Right == Right && r.Bottom == Bottom;
   }

Tips & Tricks:

Please add some!

   public override bool Equals(object obj)
   {
     if (obj is RECT)
       return Equals((RECT)obj);
     else if (obj is System.Drawing.Rectangle)
       return Equals(new RECT((System.Drawing.Rectangle)obj));
     return false;
   }

Sample Code:

Please add some!

   public override int GetHashCode()
   {
     return ((System.Drawing.Rectangle)this).GetHashCode();
   }

Alternative Managed API:

TODO

   public override string ToString()
   {
     return string.Format(System.Globalization.CultureInfo.CurrentCulture, "{{Left={0},Top={1},Right={2},Bottom={3}}}", Left, Top, Right, Bottom);
   }
}

VB.NET Signature:

<StructLayout(LayoutKind.Sequential)> _
Public Structure RECT
    Private _Left As Integer, _Top As Integer, _Right As Integer, _Bottom As Integer

    Public Sub New(ByVal Rectangle As Rectangle)
        Me.New(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom)
    End Sub
    Public Sub New(ByVal Left As Integer, ByVal Top As Integer, ByVal Right As Integer, ByVal Bottom As Integer)
        _Left = Left
        _Top = Top
        _Right = Right
        _Bottom = Bottom
    End Sub

    Public Property X As Integer
        Get
        Return _Left
        End Get
        Set(ByVal value As Integer)
        _Right = _Right - _Left + value
        _Left = value
        End Set
    End Property
    Public Property Y As Integer
        Get
        Return _Top
        End Get
        Set(ByVal value As Integer)
        _Bottom = _Bottom - _Top + value
        _Top = value
        End Set
    End Property
    Public Property Left As Integer
        Get
        Return _Left
        End Get
        Set(ByVal value As Integer)
        _Left = value
        End Set
    End Property
    Public Property Top As Integer
        Get
        Return _Top
        End Get
        Set(ByVal value As Integer)
        _Top = value
        End Set
    End Property
    Public Property Right As Integer
        Get
        Return _Right
        End Get
        Set(ByVal value As Integer)
        _Right = value
        End Set
    End Property
    Public Property Bottom As Integer
        Get
        Return _Bottom
        End Get
        Set(ByVal value As Integer)
        _Bottom = value
        End Set
    End Property
    Public Property Height() As Integer
        Get
        Return _Bottom - _Top
        End Get
        Set(ByVal value As Integer)
        _Bottom = value + _Top
        End Set
    End Property
    Public Property Width() As Integer
        Get
        Return _Right - _Left
        End Get
        Set(ByVal value As Integer)
        _Right = value + _Left
        End Set
    End Property
    Public Property Location() As Point
        Get
        Return New Point(Left, Top)
        End Get
        Set(ByVal value As Point)
        _Right = _Right - _Left + value.X
        _Bottom = _Bottom - _Top + value.Y
        _Left = value.X
        _Top = value.Y
        End Set
    End Property
    Public Property Size() As Size
        Get
        Return New Size(Width, Height)
        End Get
        Set(ByVal value As Size)
        _Right = value.Width + _Left
        _Bottom = value.Height + _Top
        End Set
    End Property

    Public Shared Widening Operator CType(ByVal Rectangle As RECT) As Rectangle
        Return New Rectangle(Rectangle.Left, Rectangle.Top, Rectangle.Width, Rectangle.Height)
    End Operator
    Public Shared Widening Operator CType(ByVal Rectangle As Rectangle) As RECT
        Return New RECT(Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom)
    End Operator
    Public Shared Operator =(ByVal Rectangle1 As RECT, ByVal Rectangle2 As RECT) As Boolean
        Return Rectangle1.Equals(Rectangle2)
    End Operator
    Public Shared Operator <>(ByVal Rectangle1 As RECT, ByVal Rectangle2 As RECT) As Boolean
        Return Not Rectangle1.Equals(Rectangle2)
    End Operator

    Public Overrides Function ToString() As String
        Return "{Left: " & _Left & "; " & "Top: " & _Top & "; Right: " & _Right & "; Bottom: " & _Bottom & "}"
    End Function

    Public Overloads Function Equals(ByVal Rectangle As RECT) As Boolean
        Return Rectangle.Left = _Left AndAlso Rectangle.Top = _Top AndAlso Rectangle.Right = _Right AndAlso Rectangle.Bottom = _Bottom
    End Function
    Public Overloads Overrides Function Equals(ByVal [Object] As Object) As Boolean
        If TypeOf [Object] Is RECT Then
        Return Equals(DirectCast([Object], RECT))
        ElseIf TypeOf [Object] Is Rectangle Then
        Return Equals(New RECT(DirectCast([Object], Rectangle)))
        End If

        Return False
    End Function
End Structure