Question - mapping to value-types

[bslbckr]

We recently observed some strange behavior when it comes to mapping to members of type DateTime. We have to deal a lot with protobuf-messages where time-values are represented by the Google.Protobuf.WellKnownTypes.Timestamp (cf https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/timestamp) class.

It is straight forware to map from DateTime to Timestamp using the CreateInstancesUsing(...)-Method. However, for mapping in the opposite direction we fail to specify the mapping.

What is the preferred way to create new instances of DateTime if we don't want to map them to and from strings?

Our mappings:

Mapper.WhenMapping.From<Timestamp>().To<DateTime>()
    .CreateInstancesUsing(c => c.Source.ToDateTime())
    .And.IgnoreTargetMembersWhere(_ => true);
Mapper.WhenMapping.From<DateTime>().To<Timestamp>()
    .CreateInstancesUsing(c => Timestamp.FromDateTime(c.Source.ToUniversalTime()))
    .And.IgnoreTargetMembersWhere(_ => true);

What yields the following execution plans:

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
// Map Program.ProtoA -> Program.A
// Rule Set: CreateNew
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

paToAData =>
{
    try
    {
        var a = new Program.A();
        // No data source for Date

        return a;
    }
    catch (Exception ex)
    {
        throw MappingException.For(
            "CreateNew",
            "Program.ProtoA",
            "Program.A",
            ex);
    }
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
// Map Program.A -> Program.ProtoA
// Rule Set: CreateNew
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

aToPaData =>
{
    try
    {
        var protoA = aToPaData.Target = new Program.ProtoA();
        protoA.Date =
        {
            IObjectMappingData<DateTime, Timestamp> dtToTData;
            try
            {
                dtToTData = MappingDataFactory.ForChild(
                    aToPaData.Source.Date,
                    protoA.Date,
                    aToPaData.EnumerableIndex,
                    "Date",
                    0,
                    aToPaData);

                var timestamp = dtToTData.Target ?? (dtToTData.Target = Timestamp.FromDateTime(dtToTData.Source.ToUniversalTime()));
                // Seconds is ignored by filter:
// true
                // Nanos is ignored by filter:
// true

                return timestamp;
            }
            catch (Exception ex)
            {
                throw MappingException.For(
                    "CreateNew",
                    "Program.A.Date",
                    "Program.ProtoA.Date",
                    ex);
            }
        };

        return protoA;
    }
    catch (Exception ex)
    {
        throw MappingException.For(
            "CreateNew",
            "Program.A",
            "Program.ProtoA",
            ex);
    }
}

with Protoa and A being:

        public class ProtoA
	{
		public Timestamp Date{get; set;}
	}

	public class A
	{
		public DateTime Date {get; set; }
	}

The complete example could be found in this fiddle: https://dotnetfiddle.net/Nm8Bz1

[SteveWilkes]

Hi!

Thanks for raising the issues you've found - rest assured I'm working on them :)

For this one, I never implemented using CreateInstancesUsing for 'simple' types - it works for classes and user-defined structs, it errors if you try to use it for primitives, but things like DateTime (and Guid, and string) fell through the gaps. I'm implementing it, and will have it in a preview in due course.

All the best,

Steve

[bslbckr]

That's great news (btw. i'd already seen your commit 😉)

If you say that CreateInstancesUsing isn't intended for this use case what about limiting it to reference types and introduce a new api-method that allows for explicit value-conversion.
E.g.

WhenMapping.From<Timestamp>().To<DateTime>().UseConversion(ctxt => ctxt.Source.ToDateTime());

[SteveWilkes]

It used to be limited to reference types, but it also supports user structs, so the constraint had to go. It's no problem - intuitively it should work for DateTimes, so I'm sorting that out.

I'm considering having the mapper auto-detect public [TargetType] To[TargetType]() methods the same way it detects static factory methods, so this case shouldn't need configuration in the end :)

[SteveWilkes]

This is implemented in the latest v1.6 branch - release to follow! Cheers! :)

[bslbckr]

Great, we will give it a try once the preview version is available on nuget.

[SteveWilkes]

This is included in v1.6-preview5, which is now available on NuGet. Thanks again!

[SteveWilkes]

The fix for this is included in v1.6, which is now available on NuGet.

Thanks again for the feedback!