两个日期作为C＃中的属性

Question

I want to have two simple properties: the start date and the end date. I want to put a constraint that the start date must be before the end date. The problem arises when modifying both values - they may (together!) make a new, correct pair, but at the moment of adding them, there is an error. Simple example:

start = 5;
end = 10;

new_start = 20;
new_end = 30;

start = new_start; // error!
end = new_end;

That is why I introduced the third property. The thing is - the code looks terrible (especially the .Item1, .Item2 thing).

Is there a way to do it in a better way in C#?

    private DateTime start;
    private DateTime end;

    public DateTime Start { get { return start; } }
    public DateTime End { get { return end; } }


    public Tuple<DateTime, DateTime> Dates
    {
        get
        {
            return new Tuple<DateTime, DateTime>(Start, End);
        }
        set
        {
            if (value.Item1 <= value.Item2)
            {
                start = value.Item1;
                end = value.Item2;
            }
            else
                throw new InvalidDates();
        }
    }

Answer 1

Well, you might think about whether it would make sense to have a type which represents a start/end combination. A sort of... Interval . (Yes, this is a not-so-subtle plug for Noda Time , which makes date/time handling generally better anyway. But you could create your own Interval struct for DateTime if you wanted...) Then you can have a single property to combine the start/end times, in a way which is guaranteed to be valid.

But if you really want to keep them as separate properties, I'd go with a simple setter. I wouldn't create a separate exception for this though - just use ArgumentException :

public void SetDates(DateTime start, DateTime end)
{
    if (end < start)
    {
        throw new ArgumentException("End must be at or after start", "end");
    }
    this.start = start;
    this.end = end;
}

Answer 2

Wow. Lots of answers. Well, here's my take.

Create two public properties for the start and end dates, and then add a SetStartAndEndDates method that does the validation. The public properties should have private setters. Since the SetStartAndEndDates method throws an error if invalid dates are set, you'll want to create methods allowing you to test potential dates. To illustrate this methodology, I'll create a fictional CalendarEvent class:

public class CalendarEvent
{
    public DateTime StartDate { get; private set; }
    public DateTime EndDate { get; private set; }

    public SetStartAndEndDates(DateTime start, DateTime end)
    {
        if (start <= end)
        {
            StartDate = start;
            EndDate = end;
        }
        else
        {
            throw new InvalidDates();
        }
    }

    public bool IsValidEndDate(DateTime end)
    {
        return StartDate <= end;
    }

    public bool IsValidStartDate(DateTime start)
    {
        return start <= EndDate;
    }

    public bool IsValidStartAndEndDate(DateTime start, DateTime end)
    {
        return start <= end;
    }
}

And to use it without throwing exceptions:

var event = new Event();
var start = DateTime.Now;
var end = start.AddDays(7);

if (event.IsValidStartAndEndDate(start, end))
{
    event.SetStartAndEndDates(start, end);
}

Answer 3

Use a method to set them together:

public void SetDates(DateTime start, DateTime end)
{
    if(start >= end)
        throw new ArgumentException("start must be before end");
    this.start = start;
    this.end = end;
}

Answer 4

Use a method as a setter:

public void SetDates(DateTime startDate, EndDate endDate)
{
    if (startDate <= endDate)
    {
        start = startDate;
        end = endDate;
    }
    else
    {
        throw new InvalidDates();
    }
}

Answer 5

Instead of having two underlying DateTime , I would write a class that contains one DateTime for the start and one TimeSpan for the difference between the start and end. The setter for the start would only change the DateTime and the setter for the end would only change the TimeSpan (giving an exception if it would make the TimeSpan negative).

You see behaviour like this in Google calendar and Outlook's calendar already, as I recall. There changing the start time of an event changes the end time too, but keeps the duration constant.

public class TimeWindow
{
    private TimeSpan duration;

    public DateTime StartTime { get; set; }

    public DateTime EndTime
    {
        get
        {
            return this.StartTime.Add(this.duration);
        }

        set
        {
            // this will throw a ArgumentOutOfRangeException if value is smaller than StartTime
            this.duration = value.Subtract(this.StartTime);
        }
    }

    public void SetStartAndEnd(DateTime start, DateTime end)
    {
        this.StartTime = start;
        this.EndTime = end;
    }
}

Answer 6

OO encapsulation isn't always about pretty implementation, it's often about pretty interfaces that provide consistent "black box" behavior. If writing the code that "looks terrible" provides a smooth interface with behavior consistent with the design, then what's the big deal? I think the solution you have is perfectly valid to keep the internals of the class consistent.

Answer 7

Take the validation checks out of the setters and add a validate method. You can then set them in any order without exception and check the final outcome once you think they are ready by calling validate.

private DateTime start;
private DateTime end;

public DateTime Start { get { return start; } }
public DateTime End { get { return end; } }

public void Validate()
{
    if (end.Ticks < start.Ticks)
        throw new InvalidDates();
}

Answer 8

Another way which is not listed in answers is to implement ISupportInitialize interface. Before modifying dates you call BeginInit method and after - EndInit . On EndInit validate dates.

public class SomeClass : ISupportInitialize
{
    private bool initializing;
    private DateTime start;
    private DateTime end;

    public DateTime Start
    {
        get { return start; }
        set { CheckInitializing(); start = value; }
    }

    public DateTime End
    {
        get { return end; }
        set { CheckInitializing(); end = value; }
    }

    private void CheckInitializing()
    {
        if (!initializing)
        { throw new InvalidOperationException("Can not execute this operation outside a BeginInit/EndInit block."); }
    }

    public void BeginInit()
    {
        if (initializing)
        { throw new InvalidOperationException("Can not have nested BeginInit calls on the same instance."); }

        initializing = true;
    }

    public void EndInit()
    {
        if (!initializing)
        { throw new InvalidOperationException("Can not call EndInit without a matching BeginInit call."); }

        if (start <= end)
        { throw new InvalidDates(); }

        initializing = false;
    }
}