Limits: Boundary inclusion in rect.Intersects and rect.Contains

Answer to the three core questions

• 1) rect.Contains for a point on the edges: rect.Contains returns true for points whose X equals the rectangle’s Left or Y equals Top, but returns false when X equals Right or Y equals Bottom. The right and bottom edges are exclusive.
• 2) rect.Intersects for touching rectangles: rect.Intersects returns true when two rectangles share any boundary – an edge or a single corner point – because the intersection test uses inclusive comparisons on the left/top and exclusive on the right/bottom, which still counts a shared line or point as an overlap.
• 3) Version history: The inclusive/exclusive rule has been stable since the original .NET Framework implementation (pre‑.NET 5). No release has altered the boundary logic for Rectangle in the System.Drawing namespace. If you are using a different geometry library (e.g., SkiaSharp, Unity, or a custom Rect struct), check that library’s documentation – the rule can differ.

Confirmed facts (based on the .NET System.Drawing.Rectangle implementation)

• Left/Top edges are inclusive: X <= point.X < X+Width and Y <= point.Y < Y+Height.
• Right/Bottom edges are exclusive: a point exactly on X+Width or Y+Height is considered outside.
• Intersects uses the same inclusive/exclusive logic and therefore treats shared edges or corner points as intersecting.
• The behavior has not changed across .NET Framework, .NET Core, and .NET 5/6/7.

Minimal test steps to verify in your environment

1. Define two rectangles that touch along an edge:

   var r1 = new Rectangle(0, 0, 10, 10);
   var r2 = new Rectangle(10, 0, 10, 10); // shares right edge of r1
   Console.WriteLine(r1.IntersectsWith(r2)); // expected true
   

2. Test point containment on the boundary:

   Console.WriteLine(r1.Contains(new Point(0, 5)));  // true (left edge)
   Console.WriteLine(r1.Contains(new Point(10, 5))); // false (right edge)
   Console.WriteLine(r1.Contains(new Point(5, 0)));  // true (top edge)
   Console.WriteLine(r1.Contains(new Point(5, 10))); // false (bottom edge)
   

3. Test rectangle containment respecting exclusivity:

   var inner = new Rectangle(1, 1, 8, 8); // fits inside r1
   Console.WriteLine(r1.Contains(inner)); // true
   var edgeTouch = new Rectangle(0, 0, 10, 10); // identical to r1
   Console.WriteLine(r1.Contains(edgeTouch)); // true
   var overEdge = new Rectangle(0, 0, 11, 10); // extends beyond right
   Console.WriteLine(r1.Contains(overEdge)); // false
   

What to do if you’re using a different library

• Check the library’s source or docs for the comparison operators used in Contains and Intersects.
• Run the same minimal tests above; adapt the code to the library’s API.
• If the library treats right/bottom as inclusive, you may need to adjust your collision logic to avoid off‑by‑one gaps.

Summary

In the standard .NET Rectangle type, points on the left or top edges are considered inside, while points on the right or bottom edges are outside. Two rectangles that touch only along an edge or at a corner are treated as intersecting. These rules have been consistent across all recent .NET releases. If you rely on strict geometric definitions, always verify the specific library’s implementation before assuming inclusive behavior on all sides.