Question

We have an application that has a primary window, it can launch multiple other windows, in new browsers. We are using a silverlight application as a coordinating server in the primary window to close all windows that are part of the app, regardless of the way they are opened (we can’t guarantee it was via window.open so don’t always have a handle to the window in javascript).

On log out, we want to signal all the other windows to perform an auto-save, if necessary, then close down.

So all windows have a silverlight app, they coordinate using localmessagesenders. However, these are asynchronous:

private void ProcessAutosave()
    {
        foreach (string s in _windows)
        {
            SendMessage(s, "notify-logout");
        }
        // code here quoted later...

    }

    // sendasynch doesn't send until the method terminates, so have to do it in it's own function.
    private void SendMessage(string to, string message)
    {
        var lms = new LocalMessageSender(to);
        lms.SendCompleted += new EventHandler<SendCompletedEventArgs>(SenderSendCompleted);
        lms.SendAsync(message);
    }

Since the ProcessAutosave is called from a javascript onunload event which can’t be cancelled, we need this to be synchronous and not complete before we have a response processed from each sub-window so the session state will still be valid etc.

In the SenderSendCompleted we remove items from _windows when they have said they’re done.

So I added a loop on the end:

while(_windows.Count > 0) {
 Thread.Sleep(1)
}

However, that never terminates, unless I put an iteration counter on it.

Am I the victim of a compiler optimisation meaning the changes in SenderSendCompleted do not affect that while loop, or, have I fundamentally misunderstood something? Or missed something obvious that’s staring me in the face?

Answer 1

I have found a way to work round. However, this does not really “solve” the problem generally, just in my case, which is also only supporting internet explorer.

function WindowCloseEventHandler()
{
   var app = // get silverlight app handle...
   app.doAutoSave();
   var params = 'whatever you need';
   var args = new Object();
   args.hwnd = window;
   window.showModalDialog('blocker.aspx',args,params);
}

function checkAutoSave()
{
   var app = // get silverlight app handle...
   return app.autosavecomplete();
}

Then in blocker.aspx we display a static “performing logout handlers” type message and do:

function timerTick()
{
    if(window.dialogArguments.hwnd.checkAutoSave()) {
      window.close();
    } else {
       setTimeout(timerTick, 500);
    }
}

And start the timer on window load.

The child window’s silverlight apps are notified to start an autosave, then they notify the parent when they are done. We then poll the parent’s status from a modal dialog, which blocks the termination of the WindowCloseEventHandler() which we have wired up to the onclose event of the body.

It’s hacky and horrible, but it means silverlight stays asynchronous and we’re using a javascript timer so the javascript isn’t loading the system.

Of course if the user closes the modal dialogue, there is a potential for issue.