Fastest way to serialize the Date portion of a DateTime into 4 bytes?

Question

I want to serialize the Date portion of a DateTime into 4 bytes (could be a Int32). What is the fastest way to do so?

Background: in order to serialize a full DateTime I have been using the ToBinary method so far. It returns a Int64 that I'm storing elsewhere. Now, I have the requirement to store only the Date part of the DateTime using only half the space. So, I was wondering how to achieve this in the fastest way as performance is crucial.

Options that come into my mind is:

• Encode Year, Month, Day into and int as YYYYMMDD by using some multiplications and property accesses with the nice side-effect that this encoding is human-readable.
• Keep using ToBinary and keep only "the upper or lower half" of the returned long. Don't know if that is possible.
• Check how DateTime are stored internally. Maybe the date portion can be accessed in other ways.

How would you do it?

Answer 1

DateTimes are stored as the number of ticks since 00:00:00, January 1, 0001. So if you take a DateTime's Ticks and divide it by TimeSpan.TicksPerDay, you end up with the number of days since January 1, 0001.

Reverse the operation (multiply by TimeSpan.TicksPerDay) When deserializing.

Since there are "only" 3,652,058 days in the range covered by DateTime, this will easily fit in an Int32

To Serialize:

System.DateTime toSerialize;
long longDays = toSerialize.Ticks / System.TimeSpan.TicksPerDay;

// Safe since (DateTime.MaxValue - DateTime.MinValue).Days << Int32.MaxValue
int days = (int)longDays; 
// Serializes `days` however you would serialize any other int

To Deserialize:

int days;
long ticks = days * System.TimeSpan.TicksPerDay;
System.DateTime deserialized = new DateTime(ticks);

Answer 2

Any Year which is supported by .net DateTime(0001-9999) would fit in short which is 2 bytes. Day and Month will take a byte each respectively.

So, you can simply create a custom struct with all three fields.

public struct Date
{
    public readonly short Year;//2 byte
    public readonly byte Month;//1 byte
    public readonly byte Day;  //1 byte
    ...
}

You can serialize this struct which would be 4 bytes(assuming no padding). You can just store the bytes representation of the struct since this struct is blittable.

If you can use unsafe code, then conversion can be done very fast. Otherwise use one of the .Net'ish way

private unsafe int DateToInt(Date date)
{
    int* d = (int*)&date;
    return *d;
}

private unsafe Date IntToDate(int date)
{
    Date* d = (Date*)(&date);
    return *d;
}

Or you can use BitVector32 which is designed specially to handle these kind of things.

private static BitVector32.Section yearSection = BitVector32.CreateSection(9999);
private static BitVector32.Section monthSection = BitVector32.CreateSection(12, yearSection);
private static BitVector32.Section daySection = BitVector32.CreateSection(31, monthSection);

private int DateToInt(DateTime date)
{
    BitVector32 bv = new BitVector32(0);
    bv[yearSection] = date.Year;
    bv[monthSection] = date.Month;
    bv[daySection] = date.Day;
    return bv.Data;
}

private DateTime IntToDate(int date)
{
    BitVector32 bv = new BitVector32(date);
    return new DateTime(bv[yearSection], bv[monthSection], bv[daySection]);
}

private void TestDateSerialization()
{
    DateTime date = new DateTime(2009, 6, 24);  
    int serialized = DateToInt(date);

    DateTime deserialized = IntToDate(serialized);
}