Fix issue #755 - Regression in interfaces mapping introduced by #649

[lofcz]

Fixes#755, @andrerav could you please take a look and potentially release a new pre-release version? This regression could've affected many customers (it did us at least) - but the pattern is common.

@DocSvartz CC, I want to verify this doesn't break your code (tests are passing).

[andrerav]

@DocSvartz Please take a look and let me know if this looks okay to you. I can make a speedy release this afternoon :)

[DocSvartz]

@lofcz
Your solution is suitable as a temporary one.
But there are still very strange things happening there :)

Please Do not Close Issue.

[lofcz]

@DocSvartz could you elaborate? I find it strange that if we add any props to the interface:

[TestMethod]publicvoidMappingToInterface_VerifyReadonlyPropsInterfaceAnyPropRule(){SampleInterfaceClsWithPropsource=newSampleInterfaceClsWithProp{ActivityData=newSampleActivityDataWithProp{Data=newSampleActivityParsedData{Steps=newList<string>{"A","B","C"}}}};SampleInterfaceClsWithProptarget=source.Adapt<SampleInterfaceClsWithProp>();target.ShouldNotBeNull();target.ShouldSatisfyAllConditions(()=>target.ActivityData.ShouldBe(source.ActivityData));}publicinterfaceIActivityDataWithProp{intTest{get;set;}}publicclassSampleInterfaceClsWithProp{publicIActivityDataWithProp?ActivityData{get;set;}publicSampleInterfaceClsWithProp(){}publicSampleInterfaceClsWithProp(IActivityDataWithPropdata){SetActivityData(data);}publicvoidSetActivityData(IActivityDataWithPropdata){ActivityData=data;}}publicclassSampleActivityDataWithProp:IActivityDataWithProp{publicintTest{get;set;}=42;publicSampleActivityParsedDataData{get;set;}}publicclassSampleActivityParsedData{publicList<string>Steps{get;set;}=newList<string>();}

When mapping with default config we run into:

// BaseAdapter.cs://if mapping to interface, create dynamic type implementing itelseif(arg.DestinationType.GetTypeInfo().IsInterface){
...

And we synthesize a new type implementing just Test.

[DocSvartz]

As far as I understand, this is done in order to create an instance class that can be filled with values ​​from the source.
because it is impossible to create an interface instance

[lofcz]

That's right but wouldn't it be better to do something like https://github.com/lofcz/DeepCloner/blob/9abf692a58da2e76b4dac6a266f45fbd573dc621/DeepCloner.Core/Helpers/DeepClonerExprGenerator.cs instead? The current behavior is unintuitive and I can't think of a scenario where one would intentionally want to do this. Synthesizing a new type also means methods are lost.

[DocSvartz]

If you are talking about the Update scenario:

var t = sourse.Adapt(destination)

Yes, This should not happen.

And in the Create scenario:

var s = sourse.Adapt<IDestination>()

You can't know which implementation will be chosen anyway

[lofcz]

Yes, I mean "updating" specifically (cloning an existing object into another existing object).

[DocSvartz]

But "updating" happens exactly as you want.

[TestMethod]
public void MappingToInteraceWithIgnorePrivateSetProperty()
{
TypeAdapterConfig<InterfaceSource723, InterfaceDestination723>
.NewConfig()
.TwoWays()
.Ignore(dest => dest.Ignore);
InterfaceSource723 dataSourse = new Data723() { Inter = "IterDataSourse", Ignore = "IgnoreDataSourse" };
InterfaceDestination723 dataDestination = new Data723() { Inter = "IterDataDestination", Ignore = "IgnoreDataDestination" };
var idestination = dataDestination.Adapt<InterfaceDestination723>();
var isourse = dataDestination.Adapt<InterfaceSource723>();
var result = dataSourse.Adapt(dataDestination); result this is type = Data723 is not new created Type
result.Ignore.ShouldBe("IgnoreDataDestination"); result.Inter.ShouldBe("IterDataSourse");
}

I think, you want the "Creating" scenario to copy the Implementing "interface Source" Type to the Destination?

But it seems that this will only work if they match. As in your example.

[DocSvartz]

That's what I mean

IActivityData data = new MyData() var result = data.Adapt<IActivityData>() where result is type MyData 

Hm, There is another option though.
When the SourceType also implements the Destination interface.
This should work too.

[DocSvartz]

@lofcz@andrerav .
If my proposal solves (from i write in review) the problem as well as the original one.
I think it's better to use it. Until we figure it out.

In any case, I agree with this pull request.

[DocSvartz]

@lofcz

I even managed to make this option work. ))
Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

[lofcz]

@lofcz

I even managed to make this option work. )) Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

Looks great to me.

[DocSvartz]

@lofcz Thanks!

@andrerav This can be applied and release
What I came up with may require additional discussion :)

[andrerav]

Thank you @lofcz and @DocSvartz!

[lofcz]

Fixes#755, @andrerav could you please take a look and potentially release a new pre-release version? This regression could've affected many customers (it did us at least) - but the pattern is common.

@DocSvartz CC, I want to verify this doesn't break your code (tests are passing).

[andrerav]

@DocSvartz Please take a look and let me know if this looks okay to you. I can make a speedy release this afternoon :)

[DocSvartz]

@lofcz
Your solution is suitable as a temporary one.
But there are still very strange things happening there :)

Please Do not Close Issue.

[lofcz]

@DocSvartz could you elaborate? I find it strange that if we add any props to the interface:

[TestMethod]publicvoidMappingToInterface_VerifyReadonlyPropsInterfaceAnyPropRule(){SampleInterfaceClsWithPropsource=newSampleInterfaceClsWithProp{ActivityData=newSampleActivityDataWithProp{Data=newSampleActivityParsedData{Steps=newList<string>{"A","B","C"}}}};SampleInterfaceClsWithProptarget=source.Adapt<SampleInterfaceClsWithProp>();target.ShouldNotBeNull();target.ShouldSatisfyAllConditions(()=>target.ActivityData.ShouldBe(source.ActivityData));}publicinterfaceIActivityDataWithProp{intTest{get;set;}}publicclassSampleInterfaceClsWithProp{publicIActivityDataWithProp?ActivityData{get;set;}publicSampleInterfaceClsWithProp(){}publicSampleInterfaceClsWithProp(IActivityDataWithPropdata){SetActivityData(data);}publicvoidSetActivityData(IActivityDataWithPropdata){ActivityData=data;}}publicclassSampleActivityDataWithProp:IActivityDataWithProp{publicintTest{get;set;}=42;publicSampleActivityParsedDataData{get;set;}}publicclassSampleActivityParsedData{publicList<string>Steps{get;set;}=newList<string>();}

When mapping with default config we run into:

// BaseAdapter.cs://if mapping to interface, create dynamic type implementing itelseif(arg.DestinationType.GetTypeInfo().IsInterface){
...

And we synthesize a new type implementing just Test.

[DocSvartz]

As far as I understand, this is done in order to create an instance class that can be filled with values ​​from the source.
because it is impossible to create an interface instance

[lofcz]

That's right but wouldn't it be better to do something like https://github.com/lofcz/DeepCloner/blob/9abf692a58da2e76b4dac6a266f45fbd573dc621/DeepCloner.Core/Helpers/DeepClonerExprGenerator.cs instead? The current behavior is unintuitive and I can't think of a scenario where one would intentionally want to do this. Synthesizing a new type also means methods are lost.

[DocSvartz]

If you are talking about the Update scenario:

var t = sourse.Adapt(destination)

Yes, This should not happen.

And in the Create scenario:

var s = sourse.Adapt<IDestination>()

You can't know which implementation will be chosen anyway

[lofcz]

Yes, I mean "updating" specifically (cloning an existing object into another existing object).

[DocSvartz]

But "updating" happens exactly as you want.

[TestMethod]
public void MappingToInteraceWithIgnorePrivateSetProperty()
{
TypeAdapterConfig<InterfaceSource723, InterfaceDestination723>
.NewConfig()
.TwoWays()
.Ignore(dest => dest.Ignore);
InterfaceSource723 dataSourse = new Data723() { Inter = "IterDataSourse", Ignore = "IgnoreDataSourse" };
InterfaceDestination723 dataDestination = new Data723() { Inter = "IterDataDestination", Ignore = "IgnoreDataDestination" };
var idestination = dataDestination.Adapt<InterfaceDestination723>();
var isourse = dataDestination.Adapt<InterfaceSource723>();
var result = dataSourse.Adapt(dataDestination); result this is type = Data723 is not new created Type
result.Ignore.ShouldBe("IgnoreDataDestination"); result.Inter.ShouldBe("IterDataSourse");
}

I think, you want the "Creating" scenario to copy the Implementing "interface Source" Type to the Destination?

But it seems that this will only work if they match. As in your example.

[DocSvartz]

That's what I mean

IActivityData data = new MyData() var result = data.Adapt<IActivityData>() where result is type MyData 

Hm, There is another option though.
When the SourceType also implements the Destination interface.
This should work too.

[DocSvartz]

@lofcz@andrerav .
If my proposal solves (from i write in review) the problem as well as the original one.
I think it's better to use it. Until we figure it out.

In any case, I agree with this pull request.

[DocSvartz]

@lofcz

I even managed to make this option work. ))
Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

[lofcz]

@lofcz

I even managed to make this option work. )) Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

Looks great to me.

[DocSvartz]

@lofcz Thanks!

@andrerav This can be applied and release
What I came up with may require additional discussion :)

[andrerav]

Thank you @lofcz and @DocSvartz!

[lofcz]

Fixes#755, @andrerav could you please take a look and potentially release a new pre-release version? This regression could've affected many customers (it did us at least) - but the pattern is common.

@DocSvartz CC, I want to verify this doesn't break your code (tests are passing).

[andrerav]

@DocSvartz Please take a look and let me know if this looks okay to you. I can make a speedy release this afternoon :)

[DocSvartz]

@lofcz
Your solution is suitable as a temporary one.
But there are still very strange things happening there :)

Please Do not Close Issue.

[lofcz]

@DocSvartz could you elaborate? I find it strange that if we add any props to the interface:

[TestMethod]publicvoidMappingToInterface_VerifyReadonlyPropsInterfaceAnyPropRule(){SampleInterfaceClsWithPropsource=newSampleInterfaceClsWithProp{ActivityData=newSampleActivityDataWithProp{Data=newSampleActivityParsedData{Steps=newList<string>{"A","B","C"}}}};SampleInterfaceClsWithProptarget=source.Adapt<SampleInterfaceClsWithProp>();target.ShouldNotBeNull();target.ShouldSatisfyAllConditions(()=>target.ActivityData.ShouldBe(source.ActivityData));}publicinterfaceIActivityDataWithProp{intTest{get;set;}}publicclassSampleInterfaceClsWithProp{publicIActivityDataWithProp?ActivityData{get;set;}publicSampleInterfaceClsWithProp(){}publicSampleInterfaceClsWithProp(IActivityDataWithPropdata){SetActivityData(data);}publicvoidSetActivityData(IActivityDataWithPropdata){ActivityData=data;}}publicclassSampleActivityDataWithProp:IActivityDataWithProp{publicintTest{get;set;}=42;publicSampleActivityParsedDataData{get;set;}}publicclassSampleActivityParsedData{publicList<string>Steps{get;set;}=newList<string>();}

When mapping with default config we run into:

// BaseAdapter.cs://if mapping to interface, create dynamic type implementing itelseif(arg.DestinationType.GetTypeInfo().IsInterface){
...

And we synthesize a new type implementing just Test.

[DocSvartz]

As far as I understand, this is done in order to create an instance class that can be filled with values ​​from the source.
because it is impossible to create an interface instance

[lofcz]

That's right but wouldn't it be better to do something like https://github.com/lofcz/DeepCloner/blob/9abf692a58da2e76b4dac6a266f45fbd573dc621/DeepCloner.Core/Helpers/DeepClonerExprGenerator.cs instead? The current behavior is unintuitive and I can't think of a scenario where one would intentionally want to do this. Synthesizing a new type also means methods are lost.

[DocSvartz]

If you are talking about the Update scenario:

var t = sourse.Adapt(destination)

Yes, This should not happen.

And in the Create scenario:

var s = sourse.Adapt<IDestination>()

You can't know which implementation will be chosen anyway

[lofcz]

Yes, I mean "updating" specifically (cloning an existing object into another existing object).

[DocSvartz]

But "updating" happens exactly as you want.

[TestMethod]
public void MappingToInteraceWithIgnorePrivateSetProperty()
{
TypeAdapterConfig<InterfaceSource723, InterfaceDestination723>
.NewConfig()
.TwoWays()
.Ignore(dest => dest.Ignore);
InterfaceSource723 dataSourse = new Data723() { Inter = "IterDataSourse", Ignore = "IgnoreDataSourse" };
InterfaceDestination723 dataDestination = new Data723() { Inter = "IterDataDestination", Ignore = "IgnoreDataDestination" };
var idestination = dataDestination.Adapt<InterfaceDestination723>();
var isourse = dataDestination.Adapt<InterfaceSource723>();
var result = dataSourse.Adapt(dataDestination); result this is type = Data723 is not new created Type
result.Ignore.ShouldBe("IgnoreDataDestination"); result.Inter.ShouldBe("IterDataSourse");
}

I think, you want the "Creating" scenario to copy the Implementing "interface Source" Type to the Destination?

But it seems that this will only work if they match. As in your example.

[DocSvartz]

That's what I mean

IActivityData data = new MyData() var result = data.Adapt<IActivityData>() where result is type MyData 

Hm, There is another option though.
When the SourceType also implements the Destination interface.
This should work too.

[DocSvartz]

@lofcz@andrerav .
If my proposal solves (from i write in review) the problem as well as the original one.
I think it's better to use it. Until we figure it out.

In any case, I agree with this pull request.

[DocSvartz]

@lofcz

I even managed to make this option work. ))
Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

[lofcz]

@lofcz

I even managed to make this option work. )) Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

Looks great to me.

[DocSvartz]

@lofcz Thanks!

@andrerav This can be applied and release
What I came up with may require additional discussion :)

[andrerav]

Thank you @lofcz and @DocSvartz!

[lofcz]

Fixes#755, @andrerav could you please take a look and potentially release a new pre-release version? This regression could've affected many customers (it did us at least) - but the pattern is common.

@DocSvartz CC, I want to verify this doesn't break your code (tests are passing).

[andrerav]

@DocSvartz Please take a look and let me know if this looks okay to you. I can make a speedy release this afternoon :)

[DocSvartz]

@lofcz
Your solution is suitable as a temporary one.
But there are still very strange things happening there :)

Please Do not Close Issue.

[lofcz]

@DocSvartz could you elaborate? I find it strange that if we add any props to the interface:

[TestMethod]publicvoidMappingToInterface_VerifyReadonlyPropsInterfaceAnyPropRule(){SampleInterfaceClsWithPropsource=newSampleInterfaceClsWithProp{ActivityData=newSampleActivityDataWithProp{Data=newSampleActivityParsedData{Steps=newList<string>{"A","B","C"}}}};SampleInterfaceClsWithProptarget=source.Adapt<SampleInterfaceClsWithProp>();target.ShouldNotBeNull();target.ShouldSatisfyAllConditions(()=>target.ActivityData.ShouldBe(source.ActivityData));}publicinterfaceIActivityDataWithProp{intTest{get;set;}}publicclassSampleInterfaceClsWithProp{publicIActivityDataWithProp?ActivityData{get;set;}publicSampleInterfaceClsWithProp(){}publicSampleInterfaceClsWithProp(IActivityDataWithPropdata){SetActivityData(data);}publicvoidSetActivityData(IActivityDataWithPropdata){ActivityData=data;}}publicclassSampleActivityDataWithProp:IActivityDataWithProp{publicintTest{get;set;}=42;publicSampleActivityParsedDataData{get;set;}}publicclassSampleActivityParsedData{publicList<string>Steps{get;set;}=newList<string>();}

When mapping with default config we run into:

// BaseAdapter.cs://if mapping to interface, create dynamic type implementing itelseif(arg.DestinationType.GetTypeInfo().IsInterface){
...

And we synthesize a new type implementing just Test.

[DocSvartz]

As far as I understand, this is done in order to create an instance class that can be filled with values ​​from the source.
because it is impossible to create an interface instance

[lofcz]

That's right but wouldn't it be better to do something like https://github.com/lofcz/DeepCloner/blob/9abf692a58da2e76b4dac6a266f45fbd573dc621/DeepCloner.Core/Helpers/DeepClonerExprGenerator.cs instead? The current behavior is unintuitive and I can't think of a scenario where one would intentionally want to do this. Synthesizing a new type also means methods are lost.

[DocSvartz]

If you are talking about the Update scenario:

var t = sourse.Adapt(destination)

Yes, This should not happen.

And in the Create scenario:

var s = sourse.Adapt<IDestination>()

You can't know which implementation will be chosen anyway

[lofcz]

Yes, I mean "updating" specifically (cloning an existing object into another existing object).

[DocSvartz]

But "updating" happens exactly as you want.

[TestMethod]
public void MappingToInteraceWithIgnorePrivateSetProperty()
{
TypeAdapterConfig<InterfaceSource723, InterfaceDestination723>
.NewConfig()
.TwoWays()
.Ignore(dest => dest.Ignore);
InterfaceSource723 dataSourse = new Data723() { Inter = "IterDataSourse", Ignore = "IgnoreDataSourse" };
InterfaceDestination723 dataDestination = new Data723() { Inter = "IterDataDestination", Ignore = "IgnoreDataDestination" };
var idestination = dataDestination.Adapt<InterfaceDestination723>();
var isourse = dataDestination.Adapt<InterfaceSource723>();
var result = dataSourse.Adapt(dataDestination); result this is type = Data723 is not new created Type
result.Ignore.ShouldBe("IgnoreDataDestination"); result.Inter.ShouldBe("IterDataSourse");
}

I think, you want the "Creating" scenario to copy the Implementing "interface Source" Type to the Destination?

But it seems that this will only work if they match. As in your example.

[DocSvartz]

That's what I mean

IActivityData data = new MyData() var result = data.Adapt<IActivityData>() where result is type MyData 

Hm, There is another option though.
When the SourceType also implements the Destination interface.
This should work too.

[DocSvartz]

@lofcz@andrerav .
If my proposal solves (from i write in review) the problem as well as the original one.
I think it's better to use it. Until we figure it out.

In any case, I agree with this pull request.

[DocSvartz]

@lofcz

I even managed to make this option work. ))
Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

[lofcz]

@lofcz

I even managed to make this option work. )) Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

Looks great to me.

[DocSvartz]

@lofcz Thanks!

@andrerav This can be applied and release
What I came up with may require additional discussion :)

[andrerav]

Thank you @lofcz and @DocSvartz!

[lofcz]

Fixes#755, @andrerav could you please take a look and potentially release a new pre-release version? This regression could've affected many customers (it did us at least) - but the pattern is common.

@DocSvartz CC, I want to verify this doesn't break your code (tests are passing).

[andrerav]

@DocSvartz Please take a look and let me know if this looks okay to you. I can make a speedy release this afternoon :)

[DocSvartz]

@lofcz
Your solution is suitable as a temporary one.
But there are still very strange things happening there :)

Please Do not Close Issue.

[lofcz]

@DocSvartz could you elaborate? I find it strange that if we add any props to the interface:

[TestMethod]publicvoidMappingToInterface_VerifyReadonlyPropsInterfaceAnyPropRule(){SampleInterfaceClsWithPropsource=newSampleInterfaceClsWithProp{ActivityData=newSampleActivityDataWithProp{Data=newSampleActivityParsedData{Steps=newList<string>{"A","B","C"}}}};SampleInterfaceClsWithProptarget=source.Adapt<SampleInterfaceClsWithProp>();target.ShouldNotBeNull();target.ShouldSatisfyAllConditions(()=>target.ActivityData.ShouldBe(source.ActivityData));}publicinterfaceIActivityDataWithProp{intTest{get;set;}}publicclassSampleInterfaceClsWithProp{publicIActivityDataWithProp?ActivityData{get;set;}publicSampleInterfaceClsWithProp(){}publicSampleInterfaceClsWithProp(IActivityDataWithPropdata){SetActivityData(data);}publicvoidSetActivityData(IActivityDataWithPropdata){ActivityData=data;}}publicclassSampleActivityDataWithProp:IActivityDataWithProp{publicintTest{get;set;}=42;publicSampleActivityParsedDataData{get;set;}}publicclassSampleActivityParsedData{publicList<string>Steps{get;set;}=newList<string>();}

When mapping with default config we run into:

// BaseAdapter.cs://if mapping to interface, create dynamic type implementing itelseif(arg.DestinationType.GetTypeInfo().IsInterface){
...

And we synthesize a new type implementing just Test.

[DocSvartz]

As far as I understand, this is done in order to create an instance class that can be filled with values ​​from the source.
because it is impossible to create an interface instance

[lofcz]

That's right but wouldn't it be better to do something like https://github.com/lofcz/DeepCloner/blob/9abf692a58da2e76b4dac6a266f45fbd573dc621/DeepCloner.Core/Helpers/DeepClonerExprGenerator.cs instead? The current behavior is unintuitive and I can't think of a scenario where one would intentionally want to do this. Synthesizing a new type also means methods are lost.

[DocSvartz]

If you are talking about the Update scenario:

var t = sourse.Adapt(destination)

Yes, This should not happen.

And in the Create scenario:

var s = sourse.Adapt<IDestination>()

You can't know which implementation will be chosen anyway

[lofcz]

Yes, I mean "updating" specifically (cloning an existing object into another existing object).

[DocSvartz]

But "updating" happens exactly as you want.

[TestMethod]
public void MappingToInteraceWithIgnorePrivateSetProperty()
{
TypeAdapterConfig<InterfaceSource723, InterfaceDestination723>
.NewConfig()
.TwoWays()
.Ignore(dest => dest.Ignore);
InterfaceSource723 dataSourse = new Data723() { Inter = "IterDataSourse", Ignore = "IgnoreDataSourse" };
InterfaceDestination723 dataDestination = new Data723() { Inter = "IterDataDestination", Ignore = "IgnoreDataDestination" };
var idestination = dataDestination.Adapt<InterfaceDestination723>();
var isourse = dataDestination.Adapt<InterfaceSource723>();
var result = dataSourse.Adapt(dataDestination); result this is type = Data723 is not new created Type
result.Ignore.ShouldBe("IgnoreDataDestination"); result.Inter.ShouldBe("IterDataSourse");
}

I think, you want the "Creating" scenario to copy the Implementing "interface Source" Type to the Destination?

But it seems that this will only work if they match. As in your example.

[DocSvartz]

That's what I mean

IActivityData data = new MyData() var result = data.Adapt<IActivityData>() where result is type MyData 

Hm, There is another option though.
When the SourceType also implements the Destination interface.
This should work too.

[DocSvartz]

@lofcz@andrerav .
If my proposal solves (from i write in review) the problem as well as the original one.
I think it's better to use it. Until we figure it out.

In any case, I agree with this pull request.

[DocSvartz]

@lofcz

I even managed to make this option work. ))
Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

[lofcz]

@lofcz

I even managed to make this option work. )) Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

Looks great to me.

[DocSvartz]

@lofcz Thanks!

@andrerav This can be applied and release
What I came up with may require additional discussion :)

[andrerav]

Thank you @lofcz and @DocSvartz!

[lofcz]

Fixes#755, @andrerav could you please take a look and potentially release a new pre-release version? This regression could've affected many customers (it did us at least) - but the pattern is common.

@DocSvartz CC, I want to verify this doesn't break your code (tests are passing).

[andrerav]

@DocSvartz Please take a look and let me know if this looks okay to you. I can make a speedy release this afternoon :)

[DocSvartz]

@lofcz
Your solution is suitable as a temporary one.
But there are still very strange things happening there :)

Please Do not Close Issue.

[lofcz]

@DocSvartz could you elaborate? I find it strange that if we add any props to the interface:

[TestMethod]publicvoidMappingToInterface_VerifyReadonlyPropsInterfaceAnyPropRule(){SampleInterfaceClsWithPropsource=newSampleInterfaceClsWithProp{ActivityData=newSampleActivityDataWithProp{Data=newSampleActivityParsedData{Steps=newList<string>{"A","B","C"}}}};SampleInterfaceClsWithProptarget=source.Adapt<SampleInterfaceClsWithProp>();target.ShouldNotBeNull();target.ShouldSatisfyAllConditions(()=>target.ActivityData.ShouldBe(source.ActivityData));}publicinterfaceIActivityDataWithProp{intTest{get;set;}}publicclassSampleInterfaceClsWithProp{publicIActivityDataWithProp?ActivityData{get;set;}publicSampleInterfaceClsWithProp(){}publicSampleInterfaceClsWithProp(IActivityDataWithPropdata){SetActivityData(data);}publicvoidSetActivityData(IActivityDataWithPropdata){ActivityData=data;}}publicclassSampleActivityDataWithProp:IActivityDataWithProp{publicintTest{get;set;}=42;publicSampleActivityParsedDataData{get;set;}}publicclassSampleActivityParsedData{publicList<string>Steps{get;set;}=newList<string>();}

When mapping with default config we run into:

// BaseAdapter.cs://if mapping to interface, create dynamic type implementing itelseif(arg.DestinationType.GetTypeInfo().IsInterface){
...

And we synthesize a new type implementing just Test.

[DocSvartz]

As far as I understand, this is done in order to create an instance class that can be filled with values ​​from the source.
because it is impossible to create an interface instance

[lofcz]

That's right but wouldn't it be better to do something like https://github.com/lofcz/DeepCloner/blob/9abf692a58da2e76b4dac6a266f45fbd573dc621/DeepCloner.Core/Helpers/DeepClonerExprGenerator.cs instead? The current behavior is unintuitive and I can't think of a scenario where one would intentionally want to do this. Synthesizing a new type also means methods are lost.

[DocSvartz]

If you are talking about the Update scenario:

var t = sourse.Adapt(destination)

Yes, This should not happen.

And in the Create scenario:

var s = sourse.Adapt<IDestination>()

You can't know which implementation will be chosen anyway

[lofcz]

Yes, I mean "updating" specifically (cloning an existing object into another existing object).

[DocSvartz]

But "updating" happens exactly as you want.

[TestMethod]
public void MappingToInteraceWithIgnorePrivateSetProperty()
{
TypeAdapterConfig<InterfaceSource723, InterfaceDestination723>
.NewConfig()
.TwoWays()
.Ignore(dest => dest.Ignore);
InterfaceSource723 dataSourse = new Data723() { Inter = "IterDataSourse", Ignore = "IgnoreDataSourse" };
InterfaceDestination723 dataDestination = new Data723() { Inter = "IterDataDestination", Ignore = "IgnoreDataDestination" };
var idestination = dataDestination.Adapt<InterfaceDestination723>();
var isourse = dataDestination.Adapt<InterfaceSource723>();
var result = dataSourse.Adapt(dataDestination); result this is type = Data723 is not new created Type
result.Ignore.ShouldBe("IgnoreDataDestination"); result.Inter.ShouldBe("IterDataSourse");
}

I think, you want the "Creating" scenario to copy the Implementing "interface Source" Type to the Destination?

But it seems that this will only work if they match. As in your example.

[DocSvartz]

That's what I mean

IActivityData data = new MyData() var result = data.Adapt<IActivityData>() where result is type MyData 

Hm, There is another option though.
When the SourceType also implements the Destination interface.
This should work too.

[DocSvartz]

@lofcz@andrerav .
If my proposal solves (from i write in review) the problem as well as the original one.
I think it's better to use it. Until we figure it out.

In any case, I agree with this pull request.

[DocSvartz]

@lofcz

I even managed to make this option work. ))
Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

[lofcz]

@lofcz

I even managed to make this option work. )) Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

Looks great to me.

[DocSvartz]

@lofcz Thanks!

@andrerav This can be applied and release
What I came up with may require additional discussion :)

[andrerav]

Thank you @lofcz and @DocSvartz!

[lofcz]

Fixes#755, @andrerav could you please take a look and potentially release a new pre-release version? This regression could've affected many customers (it did us at least) - but the pattern is common.

@DocSvartz CC, I want to verify this doesn't break your code (tests are passing).

[andrerav]

@DocSvartz Please take a look and let me know if this looks okay to you. I can make a speedy release this afternoon :)

[DocSvartz]

@lofcz
Your solution is suitable as a temporary one.
But there are still very strange things happening there :)

Please Do not Close Issue.

[lofcz]

@DocSvartz could you elaborate? I find it strange that if we add any props to the interface:

[TestMethod]publicvoidMappingToInterface_VerifyReadonlyPropsInterfaceAnyPropRule(){SampleInterfaceClsWithPropsource=newSampleInterfaceClsWithProp{ActivityData=newSampleActivityDataWithProp{Data=newSampleActivityParsedData{Steps=newList<string>{"A","B","C"}}}};SampleInterfaceClsWithProptarget=source.Adapt<SampleInterfaceClsWithProp>();target.ShouldNotBeNull();target.ShouldSatisfyAllConditions(()=>target.ActivityData.ShouldBe(source.ActivityData));}publicinterfaceIActivityDataWithProp{intTest{get;set;}}publicclassSampleInterfaceClsWithProp{publicIActivityDataWithProp?ActivityData{get;set;}publicSampleInterfaceClsWithProp(){}publicSampleInterfaceClsWithProp(IActivityDataWithPropdata){SetActivityData(data);}publicvoidSetActivityData(IActivityDataWithPropdata){ActivityData=data;}}publicclassSampleActivityDataWithProp:IActivityDataWithProp{publicintTest{get;set;}=42;publicSampleActivityParsedDataData{get;set;}}publicclassSampleActivityParsedData{publicList<string>Steps{get;set;}=newList<string>();}

When mapping with default config we run into:

// BaseAdapter.cs://if mapping to interface, create dynamic type implementing itelseif(arg.DestinationType.GetTypeInfo().IsInterface){
...

And we synthesize a new type implementing just Test.

[DocSvartz]

As far as I understand, this is done in order to create an instance class that can be filled with values ​​from the source.
because it is impossible to create an interface instance

[lofcz]

That's right but wouldn't it be better to do something like https://github.com/lofcz/DeepCloner/blob/9abf692a58da2e76b4dac6a266f45fbd573dc621/DeepCloner.Core/Helpers/DeepClonerExprGenerator.cs instead? The current behavior is unintuitive and I can't think of a scenario where one would intentionally want to do this. Synthesizing a new type also means methods are lost.

[DocSvartz]

If you are talking about the Update scenario:

var t = sourse.Adapt(destination)

Yes, This should not happen.

And in the Create scenario:

var s = sourse.Adapt<IDestination>()

You can't know which implementation will be chosen anyway

[lofcz]

Yes, I mean "updating" specifically (cloning an existing object into another existing object).

[DocSvartz]

But "updating" happens exactly as you want.

[TestMethod]
public void MappingToInteraceWithIgnorePrivateSetProperty()
{
TypeAdapterConfig<InterfaceSource723, InterfaceDestination723>
.NewConfig()
.TwoWays()
.Ignore(dest => dest.Ignore);
InterfaceSource723 dataSourse = new Data723() { Inter = "IterDataSourse", Ignore = "IgnoreDataSourse" };
InterfaceDestination723 dataDestination = new Data723() { Inter = "IterDataDestination", Ignore = "IgnoreDataDestination" };
var idestination = dataDestination.Adapt<InterfaceDestination723>();
var isourse = dataDestination.Adapt<InterfaceSource723>();
var result = dataSourse.Adapt(dataDestination); result this is type = Data723 is not new created Type
result.Ignore.ShouldBe("IgnoreDataDestination"); result.Inter.ShouldBe("IterDataSourse");
}

I think, you want the "Creating" scenario to copy the Implementing "interface Source" Type to the Destination?

But it seems that this will only work if they match. As in your example.

[DocSvartz]

That's what I mean

IActivityData data = new MyData() var result = data.Adapt<IActivityData>() where result is type MyData 

Hm, There is another option though.
When the SourceType also implements the Destination interface.
This should work too.

[DocSvartz]

@lofcz@andrerav .
If my proposal solves (from i write in review) the problem as well as the original one.
I think it's better to use it. Until we figure it out.

In any case, I agree with this pull request.

[DocSvartz]

@lofcz

I even managed to make this option work. ))
Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

[lofcz]

@lofcz

I even managed to make this option work. )) Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

Looks great to me.

[DocSvartz]

@lofcz Thanks!

@andrerav This can be applied and release
What I came up with may require additional discussion :)

[andrerav]

Thank you @lofcz and @DocSvartz!

[lofcz]

Fixes#755, @andrerav could you please take a look and potentially release a new pre-release version? This regression could've affected many customers (it did us at least) - but the pattern is common.

@DocSvartz CC, I want to verify this doesn't break your code (tests are passing).

[andrerav]

@DocSvartz Please take a look and let me know if this looks okay to you. I can make a speedy release this afternoon :)

[DocSvartz]

@lofcz
Your solution is suitable as a temporary one.
But there are still very strange things happening there :)

Please Do not Close Issue.

[lofcz]

@DocSvartz could you elaborate? I find it strange that if we add any props to the interface:

[TestMethod]publicvoidMappingToInterface_VerifyReadonlyPropsInterfaceAnyPropRule(){SampleInterfaceClsWithPropsource=newSampleInterfaceClsWithProp{ActivityData=newSampleActivityDataWithProp{Data=newSampleActivityParsedData{Steps=newList<string>{"A","B","C"}}}};SampleInterfaceClsWithProptarget=source.Adapt<SampleInterfaceClsWithProp>();target.ShouldNotBeNull();target.ShouldSatisfyAllConditions(()=>target.ActivityData.ShouldBe(source.ActivityData));}publicinterfaceIActivityDataWithProp{intTest{get;set;}}publicclassSampleInterfaceClsWithProp{publicIActivityDataWithProp?ActivityData{get;set;}publicSampleInterfaceClsWithProp(){}publicSampleInterfaceClsWithProp(IActivityDataWithPropdata){SetActivityData(data);}publicvoidSetActivityData(IActivityDataWithPropdata){ActivityData=data;}}publicclassSampleActivityDataWithProp:IActivityDataWithProp{publicintTest{get;set;}=42;publicSampleActivityParsedDataData{get;set;}}publicclassSampleActivityParsedData{publicList<string>Steps{get;set;}=newList<string>();}

When mapping with default config we run into:

// BaseAdapter.cs://if mapping to interface, create dynamic type implementing itelseif(arg.DestinationType.GetTypeInfo().IsInterface){
...

And we synthesize a new type implementing just Test.

[DocSvartz]

As far as I understand, this is done in order to create an instance class that can be filled with values ​​from the source.
because it is impossible to create an interface instance

[lofcz]

That's right but wouldn't it be better to do something like https://github.com/lofcz/DeepCloner/blob/9abf692a58da2e76b4dac6a266f45fbd573dc621/DeepCloner.Core/Helpers/DeepClonerExprGenerator.cs instead? The current behavior is unintuitive and I can't think of a scenario where one would intentionally want to do this. Synthesizing a new type also means methods are lost.

[DocSvartz]

If you are talking about the Update scenario:

var t = sourse.Adapt(destination)

Yes, This should not happen.

And in the Create scenario:

var s = sourse.Adapt<IDestination>()

You can't know which implementation will be chosen anyway

[lofcz]

Yes, I mean "updating" specifically (cloning an existing object into another existing object).

[DocSvartz]

But "updating" happens exactly as you want.

[TestMethod]
public void MappingToInteraceWithIgnorePrivateSetProperty()
{
TypeAdapterConfig<InterfaceSource723, InterfaceDestination723>
.NewConfig()
.TwoWays()
.Ignore(dest => dest.Ignore);
InterfaceSource723 dataSourse = new Data723() { Inter = "IterDataSourse", Ignore = "IgnoreDataSourse" };
InterfaceDestination723 dataDestination = new Data723() { Inter = "IterDataDestination", Ignore = "IgnoreDataDestination" };
var idestination = dataDestination.Adapt<InterfaceDestination723>();
var isourse = dataDestination.Adapt<InterfaceSource723>();
var result = dataSourse.Adapt(dataDestination); result this is type = Data723 is not new created Type
result.Ignore.ShouldBe("IgnoreDataDestination"); result.Inter.ShouldBe("IterDataSourse");
}

I think, you want the "Creating" scenario to copy the Implementing "interface Source" Type to the Destination?

But it seems that this will only work if they match. As in your example.

[DocSvartz]

That's what I mean

IActivityData data = new MyData() var result = data.Adapt<IActivityData>() where result is type MyData 

Hm, There is another option though.
When the SourceType also implements the Destination interface.
This should work too.

[DocSvartz]

@lofcz@andrerav .
If my proposal solves (from i write in review) the problem as well as the original one.
I think it's better to use it. Until we figure it out.

In any case, I agree with this pull request.

[DocSvartz]

@lofcz

I even managed to make this option work. ))
Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

[lofcz]

@lofcz

I even managed to make this option work. )) Did you want something like this?

 [TestMethod]
public void MappingToInterface_VerifyReadonlyPropsInterfaceRule()
{
SampleInterfaceCls source = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "A", "B", "C" }
},
Temp = "Temp data"
}
};
SampleInterfaceCls source2 = new SampleInterfaceCls
{
ActivityData = new SampleActivityData
{
Data = new SampleActivityParsedData
{
Steps = new List<string> { "X", "Y", "Z" }
},
Temp = "Update Temp data"
}
};
var target = source.Adapt<SampleInterfaceClsParent>();
var target2 = source2.Adapt<SampleInterfaceCls>();
var update = target.Adapt(target2);
target.ShouldNotBeNull();
target.ShouldSatisfyAllConditions(
() => target.ActivityData.ShouldBe(source.ActivityData)
);
update.ActivityData.ShouldBe(target.ActivityData);
var resultdata = ((IActivityData)update.ActivityData);
resultdata.Temp.ShouldBe("Temp data");
((SampleActivityData)update.ActivityData).Data.Steps[0].ShouldBe("A");
((SampleActivityData)update.ActivityData).Data.Steps[1].ShouldBe("B");
((SampleActivityData)update.ActivityData).Data.Steps[2].ShouldBe("C");
}

 public interface IActivityData : IActivityDataParent
{
public string Temp { get; set; }
}
public interface IActivityDataParent
{
}
public class SampleInterfaceCls
{
[Newtonsoft.Json.JsonIgnore]
public IActivityDataParent? ActivityData { get; set; }
public SampleInterfaceCls()
{
}
public SampleInterfaceCls(IActivityDataParent data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityDataParent data)
{
ActivityData = data;
}
}
public class SampleInterfaceClsParent
{
[Newtonsoft.Json.JsonIgnore]
public IActivityData? ActivityData { get; set; }
public SampleInterfaceClsParent()
{
}
public SampleInterfaceClsParent(IActivityData data)
{
SetActivityData(data);
}
public void SetActivityData(IActivityData data)
{
ActivityData = data;
}
}

Looks great to me.

[DocSvartz]

@lofcz Thanks!

@andrerav This can be applied and release
What I came up with may require additional discussion :)

[andrerav]

Thank you @lofcz and @DocSvartz!