current community

your communities

more stack exchange communities

Stack Exchange
tour help
Take the 2-minute tour ×
Code Review Stack Exchange is a question and answer site for peer programmer code reviews. It's 100% free, no registration required.
up vote 3 down vote favorite

Today I needed to implement a class for representing rectangular regions with some binary operations such as merging or intersection.

public class Region
{
    // Properties, such as top-left and bottom-right corner ...
    // Ctors ...

    public Region Merge(Region other)
    {
        // ...
    }

    public Region Insersect(Region other)
    {
        // ...
    }
}

Intersecting two instances of Region unfortunately does not always have a useful result. So my next step was to implement the notion of a NullRegion. It is no problem to implement the NullRegion itself. However, this would require Region to check against NullRegion, as those binary operations are commutative and the order should not matter. (i.e. nullRegion.Intersect(nonNullRegion)should yield the same result as nonNullRegion.Intersect(nullRegion), which is a NullRegion)

The first solution I can think of is to move the implementation of those methods into a seperate class. That way, I only the new class needs to know the NullRegion.

public class Region
{
    // Properties, such as top-left and bottom-right corner ...
    // Ctors ...

    public virtual bool IsNull { get { return false; } }

    public Region Merge(Region other)
    {
        return RegionMethods.Merge(this, other);
    }

    public Region Intersect(Region other)
    {
        return RegionMethods.Intersect(this, other);
    }

    private class NullRegion
    {
        public override bool IsNull { get { return true; } }
    }

    private static class RegionMethods
    {
        public static Region Merge(Region Region, Region otherRegion)
        {
            // ...
        }

        public static Region Intersect(Region Region, Region otherRegion)
        {
            // ...
        }
    }
}

Is this a good way to tackle the problem? What would be my alternatives?

share|improve this question
    
Maybe I'm just having a hard time following because the implementation is missing, but how come you need a NullArea at all? Isn't the intersection of two non-overlapping rectangles just a 0x0 Area and not a "lack" of an Area? This could mean it's just a problem of Area != RectangleCoordinates and the need for different representations of each. –  Ocelot20 Dec 8 '14 at 2:08
    
Probably the name is not as clear as it should be. The mere area itself is not important, but the coordinates (top-left corner and bottom-right corner) are. I will rename it to Region. –  conrad Dec 8 '14 at 2:27
    
Can you please clarify, what a NullRegion semantically means? Why are its coordinates 0|0|0|0? Is one supposed to work with it as a result or is it rather used for always checking if the result is a normal Region or a NullRegion? I think even though you accept an answer here, there is still some light to bring into this issue. –  valenterry Dec 8 '14 at 17:42
    
In my domain, a NullRegion is a region not having an area and not having any coordinates. Probably the best example is the intersection of two non-intersecting Regions. Users of my class should always be able to check if the given Region is a NullRegion by calling region.IsNull. The coordinates do not really matter, possibly one should even throw an InvalidOperationException when trying to access the coordinates of the NullRegion, as it does not have defined coordinates. However, users should still be able to perform reasonable computations with the NullRegion, such as merging. –  conrad Dec 8 '14 at 19:43
    
To describe it in a more mathematical way: Regions are made up of points and the NullRegion is the Region containing no points at all. –  conrad Dec 8 '14 at 19:47

1 Answer 1

up vote 3 down vote accepted

The implementation of a NullRegion, shouldn't be done by a separate class, but by a static property of the same class.
If you overide Equals() and GetHashCode() you can just compare the objects to Region.NullRegion like 

public class Region
{
    private static readonly Region nullRegion = new Region();

    private Region()
    {
        Left = 0;
        Top = 0;
        Width = 0;
        Height = 0;
    }
    public Region(Point point, Size size)
    {
        Left = point.X;
        Top = point.Y;
        Width = size.Width;
        Height = size.Height;
    }
    public static Region NullRegion
    {
        get
        {
            return nullRegion;
        }

    }
    public int Left { get; set; }
    public int Top { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }

    public Region Merge(Region other)
    {
        if (this == Region.NullRegion || other == Region.NullRegion)
        {
            return Region.NullRegion;
        }
        // default Merge() implementation here
    }
    public Region Intersects(Region other)
    {
        if (this == Region.NullRegion || other == Region.NullRegion)
        {
            return Region.NullRegion;
        }
        // default Intersects() implementation here

    }
    public override bool Equals(object obj)
    {
        //Implementation of your Equals() here
        return base.Equals(obj);
    }
    public override int GetHashCode()
    {
        //Implementation of your GetHashCode() here
        return base.GetHashCode();
    }
}
share|improve this answer
    
That is almost exactly how I solved it in the end, aside from the properties and the immutability of my Regions. I added an IsNull-property, so my NullRegion-check reads like this.IsNull or even just IsNull. And just to mention it: in my domain merging the NullRegion with another region will return the latter one. –  conrad Dec 8 '14 at 13:15

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.