Is there a way set a dirty flag in a Xamarin ViewModel after the properties are initialized?

Question

I want to set a dirty flag for any of the required properties in my view model. I initialize IsDirty to false in the constructor. Unfortunately all of the setters in my properties are called after the constructor. Is there a way I can set IsDirty to false after all of the setters? The setters all have a line IsDirty=true;

I'm using the Prism framework with Xamarin 4.0, but Prism documentation doesn't have anything on the ViewModel life cycle.

My redacted constructor looks like this:

public SomeDetailsViewModel(INavigationService navigationService) : base(navigationService)
{
    Sample = new SampleDTO();

    InitializeLookupValues();

    _samplesService = new SampleService(BaseUrl);

    TextChangedCommand = new Command(() => OnTextChanged());
    AddSampleCommand = new Command(() => AddCurrentSample());
    CancelCommand = new Command(() => Cancel());

    IsDirty = false;

}

Edit 3:

The constructor calls InitializeLookupValues(). These appear to be the culprit.

private async Task InitializeLookupValues()
        {
            App app = Prism.PrismApplicationBase.Current as App;
            string baseUrl = app.Properties["ApiBaseAddress"] as string;

            _lookupService = new LookupDataService(baseUrl);

            int TbId = app.CurrentProtocol.TbId;
            int accessionId = CollectionModel.Instance.Accession.AccessionId;
            Parts = await _lookupService.GetParts(accessionId);//HACK

            Containers = await _lookupService.GetSampleContainers(TbId);
            Additives = await _lookupService.GetAdditives(TbId);
            UnitsOfMeasure = await _lookupService.GetUnitsOfMeasure();
            
            // with a few more awaits not included.
        }

After exiting the constructor each of the properties are set. They look like this one.

public ObservableCollection<PartDTO> Parts
{
    get
    {
        return parts;
    }
    set
    {
        SetProperty(ref parts, value);
    }
}
private PartDTO part;
public PartDTO SelectedPart
{
    get
    {
        return part;
    }
    set
    {
        SetProperty(ref part, value);
        
        IsDirty = true;
    }
}

Where IsDirty is defined thus:

private bool isDirty;
public bool IsDirty
{
    get
    {
        return isDirty;
    }
    set
    {
        SetProperty(ref isDirty, value);
        Sample.DirtyFlag = value;
    }
}

I haven't explicitly set any of the properties. I would like to avoid their being initialized automatically, or call something after them.

Edit
Just a note to everyone I have been debugging to find out what I could. I found that in each data-bound property the getter is called twice, then the setter is called. I looked at what generated code I could find, and there is no obvious place where data binding is explicitly calling the setter.

Edit 2
What I hadn't shown before, and now looks likes it's a critical piece of information, was that I populate the ObservableCollection with an async call to a service. As far as I can tell, because of XAML data binding, the SelectedPart property setter is called. If I debug slowly this start to show in some places. I've added the async call above.

Answer 1

Since the SetProperty methods are overridable you can inject some custom logic. This could be very useful for when you have objects that you need to validate if they have been altered.

public class StatefulObject : Prism.Mvvm.BindableBase
{
    private bool _isDirty;
    public bool IsDirty
    {
        get => _isDirty;
        private set => SetProperty(ref _isDirty, value);
    }

    protected override bool SetProperty<T>(ref T storage, T value, Action onChanged, [CallerMemberName] string propertyName = null)
    {
        var isDirty = base.SetProperty(ref storage, value, onChanged, propertyName);
        if(isDirty && propertyName != nameof(isDirty))
        {
            IsDirty = true;
        }

        return isDirty;
    }

    public void Reset() => IsDirty = false;
}

Keep in mind that when you initialize fields in this IsDirty would be true, so before binding you would want to call the Reset method to set IsDirty back to false that way you can reliably know when a field has been changed.

Note that how you handle this is somewhat up to you. For instance you might do this with Linq...

var fooDTOs = someService.GetDTOs().Select(x => { x.Reset(); return x; });

You might also enforce a pattern like:

public class FooDTO : StatefulObject
{
    public FooDTO(string prop1, string prop2)
    {
        // Set the properties...
        Prop1 = prop1;

        // Ensure IsDirty is false;
        Reset(); 
    }
}

Answer 2

Is there a way I can set IsDirty to false after all of the setters?

The setters aren't called by themselves, there has to be someone calling them. You should identify who's doing that and either stop him from setting stuff without good reason (preferred) or make him reset the dirty flag after he's done.

As suggested in the comments, adding a breakpoint in the setter and having a look at the stacktrace is a good starting point for finding the source of the setting... if I had to guess, I'd suspect some navigation related callback.

But you should try to make sure that the view model is initialized after the constructor and that IsDirty actually means "has been changed through the view" and not "maybe changed by the user, might also be just part of a delayed initialization".

After your multiple edits, an edit from me:

You should modify your architecture to account for the asynchronous initialization of your view model. Just running everything in parallel and hoping for the best rarely works.

You could make the properties read-only until initialization is complete, for instance, and set IsDirty to false at the end of InitializeLookupValues.

Pseudo-Code:

Constructor()
{
    Task.Run( async () => await InitializeAsync() );
}

string Property
{
    get => _backingField;
    set
    {
        if (_isInitialized && SetProperty( ref _backingField, value ))
            _isDirty = true;
    }
}

private async Task InitializeAsync()
{
    await SomeAsynchronousStuff();
    _isInitialized = true;
}

private bool _isInitialized;
private bool _isDirty;

Probably, you want to expose _isInitialized as a property to the view to show some hourglass, and use a ManualResetEvent instead of a simple bool... but you get the idea.