Does Mapster has a way to explicitly map the same object while false ShallowCopyForSameType?

[klabajo]

Is this possible?

cfg.Default.ShallowCopyForSameType(true);

// Attempted code:
cfg.NewConfig<MyStuff, MyStuff>().ShallowCopyForSameType(false);

Trying to replicate similar behavior in the following:

// Source - https://stackoverflow.com/a/31677062
// Posted by Jimmy Bogard
// Retrieved 2026-04-28, License - CC BY-SA 3.0
You're reusing a type on both the source and destination objects, "MyStuff". When AutoMapper sees two assignable types, it assigns them rather than copying them. You can override this behavior by creating an explicit map:

Mapper.CreateMap<MyStuff, MyStuff>();

AutoMapper defaults to assigning, as AutoMapper is not a copying/cloning library.

Concerns

• While I'm trying out attempted code, some passes and some fails the unit test wherein the failed attempted code always had an error System.NullReferenceException : Object reference not set to an instance of an object..
• These are only occurring for objects that has their own parameterless constructor that instantiates their uninitialized object properties if it's still null.

public FailingMyStuff() { CreateEmptyEntities(); }
public void CreateEmptyEntities() { Item1 ??= new(); Item2 ??= new(); }

• Although it can be fixed using MapWith and defining a function, let's say MapToSelf, where it's general structure is return src == null ? null : new MyStuff(){ ... }; and I've verified that this passed the failing unit tests.

However, I wanted to know if there's a better way in automating this instead of using MapToSelf.

[DocSvartz]

HI, @klabajo. What version of mapster are you using? Try latest pre-release version.

You do not have to register custom mapping configuration If you want to receive a shallow copy.

cfg.NewConfig<MyStuff, MyStuff>() ❌

[klabajo]

I'm on version 10.0.7, I'll try out pre-release

[klabajo]

@DocSvartz Oh also, I have cfg.RequireExplicitMapping = true; forgot to mention. So I still need to register the config cfg.NewConfig<MyStuff, MyStuff>()

[klabajo]

It didn't seem to work while using pre-release version, still the same error as System.NullReferenceException : Object reference not set to an instance of an object..

I can confirm that cfg.NewConfig<MyStuff, MyStuff>().ShallowCopyForSameType(false); is working because it was able to deep copy. But the concern is still the same as I mentioned before:

These are only occurring for objects that has their own parameterless constructor that instantiates their uninitialized object properties if it's still null.

public FailingMyStuff() { CreateEmptyEntities(); }
public void CreateEmptyEntities() { Item1 ??= new(); Item2 ??= new(); }

[DocSvartz]

You using creation mapping src.Adapt<TDest>().
or update mapping src.Adapt(dest). ?

Yes, I checked . Shallow copy without a registered configuration was only available for types that couldn't be recreated from itself.

Please provide a more detailed example.

[DocSvartz]

I can't get this behavior.

[TestMethod]
public void SelfCopy()
{
    TypeAdapterConfig.GlobalSettings.Default.ShallowCopyForSameType(false);


    TypeAdapterConfig<MyStaff, MyStaff>
        .NewConfig()
        .ShallowCopyForSameType(false);

    var src = new MyFailStuff();
    src.Item1.Add(null);
    var result = src.Adapt<MyFailStuff>();

    var patch = new MyFailStuff ();


    patch.Adapt(result);

}

public class MyFailStuff
{
    public MyFailStuff() { CreateEmptyEntities(); }

    public void CreateEmptyEntities() { this.Item1 ??= new(); this.Item2 ??= new(); }

    public List<MyStaff?>? Item1 { get; set; } 

    public List<MyStaff?>? Item2 { get; set; }
}

I tried both ShallowCopyForSameType(false) and ShallowCopyForSameType(true) and still got no error.

[klabajo]

Something like this

protected MyFailStuff _originalStuff;
public MyFailStuff DynamicStuff { get; set; }

[TestMethod]
public void StoreUpdateRestoreOriginalStuff()
{
    var cfg = new TypeAdapterConfig();
    cfg.RequireExplicitMapping = true;
    cfg.Default.ShallowCopyForSameType(true);
    cfg.Default.AvoidInlineMapping(true);

    cfg.NewConfig<MyFailStuff , MyFailStuff>
        .ShallowCopyForSameType(false);

    cfg.compile();

    var mapper = new Mapper(cfg);

    DynamicStuff = new MyFailStuff();
    DynamicStuff.Item1 = new RandomObject1();
    DynamicStuff.Item1.SampleName = "SN1";
    DynamicStuff.Item2 = new RandomObject2();
    DynamicStuff.Item2.SampleNumber = 2;

    // Store
    _originalStuff= mapper.Map<MyFailStuff>(DynamicStuff);

    // Update
    DynamicStuff.Item1.SampleName = "SN1CHANGED";
    DynamicStuff.Item2.SampleNumber = 3;

    // Restore (cancelling update, restoring original copy)
    if (_originalStuff != null)
    {
        _mapper.Map(_originalStuff, DynamicStuff);
    }

    // Assert
    Assert.That(DynamicStuff.Item1.SampleName, Is.EqualTo("SN1"));
    Assert.That(DynamicStuff.Item2.SampleNumber, Is.EqualTo(2));
}

public class MyFailStuff
{
    public MyFailStuff() { CreateEmptyEntities(); }

    public void CreateEmptyEntities() { this.Item1 ??= new(); this.Item2 ??= new(); }

    public RandomObject1? Item1 { get; set; } 

    public RandomObject1? Item2 { get; set; }
}

public class RandomObject1
{
    public string? SampleName{ get; set; }
}

public class RandomObject2
{
    public int SampleNumber { get; set; }
}

[DocSvartz]

You can register include if you have polymorphic properties.

But even here, I didn't get a null reference exception. Except in this case,

    protected MyFailStuff _originalStuff;
    public dynamic DynamicStuff { get; set; }

    [TestMethod]
    public void StoreUpdateRestoreOriginalStuff()
    {
        var cfg = new TypeAdapterConfig();
        cfg.RequireExplicitMapping = true;
        cfg.Default.ShallowCopyForSameType(true);
        cfg.Default.IgnoreNullValues(true);
        cfg.Default.AvoidInlineMapping(true);

        cfg.NewConfig<RandomObject2, RandomObject2>();
        cfg.NewConfig<RandomObject1, RandomObject1>()
            .Include<RandomObject2, RandomObject2>();

        cfg.NewConfig<MyFailStuff, MyFailStuff>()
            .ShallowCopyForSameType(false);

        cfg.Compile();

        var _mapper = new Mapper(cfg);

        DynamicStuff = new MyFailStuff();
        DynamicStuff.Item1 = new RandomObject1();
        DynamicStuff.Item1.SampleName = "SN1";
        DynamicStuff.Item2 = new RandomObject2();
        DynamicStuff.Item2.SampleNumber = 2;

        // Store
        _originalStuff = _mapper.Map<MyFailStuff,MyFailStuff>(DynamicStuff);

        // Update
        DynamicStuff.Item1.SampleName = "SN1CHANGED";
        DynamicStuff.Item2.SampleNumber = 3;

        // Restore (cancelling update, restoring original copy)
        if (_originalStuff != null)
        {
            _mapper.Map<MyFailStuff, MyFailStuff>(_originalStuff, DynamicStuff);
        }

        // Assert
       (DynamicStuff.Item1 as RandomObject1).SampleName.ShouldBe("SN1");
       (DynamicStuff.Item2 as RandomObject2).SampleNumber.ShouldBe(2);
    }

 public class RandomObject1
 {
     public string? SampleName { get; set; }
 }

 public class RandomObject2: RandomObject1
 {
     public int SampleNumber { get; set; }
 }

[DocSvartz]

It looks like it's a bug. I think I understand what the person who made the change wanted to achieve, which is why it stopped working.
But they incorrectly defined the conditions under which it could work.

[DocSvartz]

Resolved: Settings are retrieved via MergeSettings. However, each pair stores its own instance, created via new.

@andrerav @stagep Have you noticed that cfg.Default it doesn't actually work for mappings created by users via NewConfig or ForType?

Or should it only work for automatically created views?

https://github.com/MapsterMapper/Mapster/wiki/Configuration

Default.PreserveReference(true) It doesn't work either. It doesn't copy the settings from the Default to the custom mapping setting.

This is especially evident during compilation.
When registered mappings are not received, the default settings are used, and sometimes completely different mapping functions are compiled.~~
...

[DocSvartz]

@klabajo perhaps I misunderstood you. Do you need to copy fields by link if it are of the same type?
But in this case you will not get the result from the test.
Because after the first Mapping you will not have copies of items with the same values ​​from which you could then restore the value.

_originalStuff = _mapper.Map<MyFailStuff,MyFailStuff>(DynamicStuff);

object.ReferenceEquals(_originalStuff.Item1, DynamicStuff.Item1) == true it is this is the same object