Is the ContinueWith method truly single-threaded when executed within an Orleans grain?

[louis4li]

https://github.com/aevatarAI/aevatar-station/blob/dev/framework/src/Aevatar.Core/GAgentBase.cs
This is the current base implementation of our project, which inherits from JournaledGrain and overrides the OnStateChanged method. Then I noticed in the relevant documentation at https://learn.microsoft.com/en-us/dotnet/orleans/grains/external-tasks-and-grainsthat using the ContinueWith method would also execute synchronously. However, from the received log prints, I observed duplicate occurrences of the Version.
`
protected sealed override void OnStateChanged()
{
// If the GAgent is not activated, do not process the state change.
if (!_isActivated)
{
return;
}

    // If the version is not greater than the last processed version, do not process the state change.
    if (Version <= _lastProcessedVersion)
    {
        return;
    }
    InternalOnStateChangedAsync().ContinueWith(task =>
    {
        if (task.Exception != null)
        {
            Logger.LogError(task.Exception, "InternalOnStateChangedAsync operation failed");
        }
    }, TaskContinuationOptions.OnlyOnFaulted);
    

    _lastProcessedVersion = Version;       
}

private async Task InternalOnStateChangedAsync()
{
    await HandleStateChangedAsync();
    if (StateDispatcher != null)
    {
        var snapshot = _copier!.Copy(State);
        
        var singleStateWrapper = new StateWrapper<TState>(this.GetGrainId(), snapshot, Version);
        singleStateWrapper.PublishedTimestampUtc = DateTime.UtcNow;
        await StateDispatcher.PublishSingleAsync(this.GetGrainId(), singleStateWrapper);
        
        var batchStateWrapper = new StateWrapper<TState>(this.GetGrainId(), snapshot, Version);
        batchStateWrapper.PublishedTimestampUtc = DateTime.UtcNow;
        await StateDispatcher.PublishAsync(this.GetGrainId(), batchStateWrapper);
    }
}`

When I changed the code to pass the Version as a parameter to the method, the phenomenon disappeared.
`
protected sealed override void OnStateChanged()
{
// If the GAgent is not activated, do not process the state change.
if (!_isActivated)
{
return;
}

    // If the version is not greater than the last processed version, do not process the state change.
    if (Version <= _lastProcessedVersion)
    {
        return;
    }


    InternalOnStateChangedAsync(Version).ContinueWith(task =>
    {
        if (task.Exception != null)
        {
            Logger.LogError(task.Exception, "InternalOnStateChangedAsync operation failed");
        }
    }, TaskContinuationOptions.OnlyOnFaulted);
    

    _lastProcessedVersion = Version;       
}

private async Task InternalOnStateChangedAsync(int version)
{
    await HandleStateChangedAsync();
    if (StateDispatcher != null)
    {
        var snapshot = _copier!.Copy(State);
        
        var singleStateWrapper = new StateWrapper<TState>(this.GetGrainId(), snapshot, version);
        singleStateWrapper.PublishedTimestampUtc = DateTime.UtcNow;
        await StateDispatcher.PublishSingleAsync(this.GetGrainId(), singleStateWrapper);
        
        var batchStateWrapper = new StateWrapper<TState>(this.GetGrainId(), snapshot, version);
        batchStateWrapper.PublishedTimestampUtc = DateTime.UtcNow;
        await StateDispatcher.PublishAsync(this.GetGrainId(), batchStateWrapper);
    }
}`
So does ContinueWith really execute synchronously within the grain?