Possible optimisation for chain of mutations?

[SuddenGunter]

If we need to apply several mutations one by one to an entity and we don't need any intermediate
results, it would be good if we can achieve it by creating only 1 new instance of entity:
Now:

            var tempDevice = _remute.With(deviceRecord, x => x.EndpointArn, endpointArn);
            var updatedDevice = _remute.With(tempDevice, x => x.DeviceName, deviceName);

Want to:

            var updatedDevice = _remute.With(deviceRecord, x => x.EndpointArn,   endpointArn)   
                                    .With(x => x.DeviceName, deviceName);

[ababik]

@SuddenGunter thanks for posting this.
It's implemented as an extension method in 1.0.5.
You can do something like this

using Remutable.Extensions;
...

var employee = new Employee(Guid.NewGuid(), "Joe", "Doe");

var actual = employee
    .Remute(x => x.FirstName, "Foo")
    .Remute(x => x.LastName, "Bar");

Assert.AreEqual("Foo", actual.FirstName);
Assert.AreEqual("Bar", actual.LastName);

[SuddenGunter]

@ababik, thank you!

var actual = employee
    .Remute(x => x.FirstName, "Foo")
    .Remute(x => x.LastName, "Bar");

after calling this - how many employee were actually allocated in memory?
2 (employee and actual) or 3 (+intermediate Remute call)?

[ababik]

@SuddenGunter
3 (+intermediate Remute call)
Extension method is just sugar syntax. Take a look at https://github.com/ababik/Remute/blob/master/Remute/Extensions/ExtensionMethods.cs for details.

[SuddenGunter]

But is there some possible "magic" that we can use to make it 2? :)
even if we do .with().with().with() etc

[ababik]

It's doable.
Can you explain me your use-case a little? Are your instances local variables? Do you modify them in a loop? Do you use Mono?
I don't experience any memory issues in my use-cases. Garbage collector does its job well.

[SuddenGunter]

Just local variables, small services on .Net Core in docker. It would be ok?

[ababik]

Absolutely.

[mmalek06]

Hi @ababik ,
Any news on @SuddenGunter suggestions? Even though garbage collector does its job well, it could be beneficial not to create a whole bunch of intermediate objects in high-data-volume scenarios. I think Immutable.Net has this notion of builders to address this exact issue, though their code is much more cumbersome to use in other scenarios than yours.

[ababik]

@mmalek06
Thanks for the inquiry. This feature is number one in the list. Hope to get it available asap.

[ababik]

Just for the context: there is a bit of complexity for this feature because remute supports nested "mutations". E.g instance.Remute(x => x.Prop1.Prop2.Prop3, value)