How to Automatically Update UI When Data Changes

  • Thread starter Thread starter Charles Law
  • Start date Start date
C

Charles Law

Here's one that should probably have the sub-heading "I'm sure I asked this
once before, but ...".

Two users are both looking at the same data, from a database. One user
changes the data and commits it. How does the other user get the updated
view without polling for changes? Is there some sort of callback mechanism
that can be set up on the dataset or connection?

TIA

Charles
 
Hi Charles,

I am not sure about callback mechanisms, I think that Oracle had something
of that, but you can provide a Refresh button and a mechanism that when the
second user tries to change the data, he is notified that the data was
changed since it was retrieved from the database. This can be done using a
timestamp field which is retrieved along with the data. When you do the
update, you get the timestamp first to see if it is the same; if not,
someone else changed the data and you can offer the user a window to see the
changes.

--

Best regards,

Carlos J. Quintero

MZ-Tools: Productivity add-ins for Visual Studio
You can code, design and document much faster:
http://www.mztools.com
 
Charles,

If you are using any kind of dataadapter/tableadapter and dataset/datatable
than it is quiet easy.

A dataset keeps track of the changed rows as long as you did not do
acceptchanges.

In the update process the code checks first row by row of those original
rows are changed in the database. (Created new, deleted or updated).

If that is the fact than you get a concurrency error.
Be aware that accepted rows are handled, so the recovery process is not
easy.
(Although you can set the connection with a begintransaction and a commit or
non commit of that).

Because of the fact that this situations in most situations is seldom, it is
called optimistic concurrency.
However you have to check it and creates the procedures.
Even if that is telling setting everything back to the first state and
telling the user to do his job again.

Very simple is it not?

Cor
 
Hi Carlos

Thanks for the reply. I was thinking more of an automatic way, so that the
second user is notified of the change when it happens, rather than if and
when he tries to make a change. This seems to me like something that would
be quite widely desired. I recollect now that I asked this before wrt web
applications, but I am now looking at a WinForms application, so perhaps
there is a way?

Charles
 
Hi Cor

Sorry if I am not catching on very quickly, but I don't quite see how your
scenario would work.
A dataset keeps track of the changed rows as long as you did not do
acceptchanges.
Click to expand...

Isn't this the dataset of the user who has made the changes? What about the
dataset of the user who is just viewing the data? Does that get some
notification of the changes as well?
In the update process the code checks first row by row of those original
rows are changed in the database. (Created new, deleted or updated).
Click to expand...

This sounds like something that would happen when the second user tries to
make changes, in which case I agree that there would be some sort of error
because the data had already changed. But suppose the second user is just
looking at the data? Because datasets are disconnected in .NET it seems to
me that the second user might never see the changes unless he specifically
reloads the data.

Charles
 
Charles,

The described process keeps only track for the updating user to prevent that
there will not wrong changed data because there where already changes in the
meantime.

What if the first was looking while the second was on the toilet and did the
updates after that while the other one was already not looking anymore.
Should there be a message that he/she was on the toilet but changed it?

This kind of pseudo accuratesse is in most situations already long time seen
as b*sh*t

However not there where there are automatic updates done for by instance by
a stock exchange.

Ken made this sample for this. Problem for me is that it will not work for
me without a 100% load so maybe can you try it as well. Ken has let this
tested by others and told that they had not that problem.

http://www.vb-tips.com/default.aspx?ID=97f5073b-4c42-4215-b71c-3503c15fd46e

Beside this it is of course advisable not to make processes that keeps to
long the changes data on the client. However if you are on a place where
there is really not any usable connection possible, than it can be that it
takes longer.

I hope this helps,

Cor
 
AFAIK this is generally not widely wanted (after all if the other user would
have updated few minutes later, the user that is looking the data would have
not seen this change, so the first question is likely is this that critical
to have instant updates or is it enough to just see what is current when you
request for it comapred with the additional complexity/processing cost ? If
you have a special need, such as plane reservation or something similar you
may want to explain what you are trying to do...).
 
Cor
What if the first was looking while the second was on the toilet and did
the updates after that while the other one was already not looking
anymore. Should there be a message that he/she was on the toilet but
changed it?
Click to expand...

On return from the lavatory, the user's screen would be up-to-date, that's
all.
This kind of pseudo accuratesse is in most situations already long time
seen as b*sh*t
Click to expand...

By whom? It would seem that Microsoft do not see it that way, as they have
introduced the SqlDependency class in VS2005 to address just this situation.

Anyway, I think I have my answer: it is possible only in VS2005 with
SqlServer. Thanks.

Charles
 
Charles,
By whom? It would seem that Microsoft do not see it that way, as they have
introduced the SqlDependency class in VS2005 to address just this
situation.
Click to expand...
I showed you that there are situations where that can be the fact.

However mostly not if it is about humans who are updating.

The same as I did with other words is writen by Patrice by the way.

Cor
 
Hi Patrice

Thanks for the reply.
... such as plane reservation or something similar ...
Click to expand...

That is a good example. Also, a bank call centre. The advisor is referring
to information on-screen whilst discussing details with a caller.
Transactions occur asynchronously, so the account balance could change
whilst the call is in progress. Unless the advisor repeatedly presses an
update button, they would not see the changes.

The stock market prices change by the second, and it is important that
traders have up-to-the-second prices on their screens. Polling is very
inefficient. The observer pattern was made for this scenario but I am
hearing that it can't be implemented on a database. I still think that this
_is_ widely wanted, but that we are largely being told that it can't be
done.

Charles
 
I am currently implementing a pattern that allows this to happen. It is
actually a non-trivial problem. My pattern uses a worker thread for
performing operations, I have my own data cache, ie. I don't use data sets.
The thread checks the cache in idle time to see if anything has changed and
fires off Update, Delete, Insert and Move (it's a tree structure so I need
this one) methods to it's listeners. UI components (user controls) register
with the data cache as listeners for these kind of events and implement an
IDataUpdateThreadNotification interface. In actuality, there are over 60
different kinds of event. Note that the worker thread does not directly
alter the cache, it only reads it, fetches any relevant data and then
invokes a method on the cache object to resolve any changes that were
detected.

For example, consider I have a set of records in an array, stored in my
cache. The process would look like this:

(1) Thread is idling, so it decides to do a "coherency check"
(2) Thread creates a data connection and fetches the records
(3) Thread Invokes a method on the cache called "RecordsFetched"
....
(4) Cache compares all of the time stamps in the fetched records with the
current records and:

Any timestamps that are different, fires an Updated event to it's
listeners
Any records that exist in the fetched set but not in the cache, fires an
Inserted event to it's listeners
Any records that exist in the cache by not in the fetched set, fires a
Deleted event to it's listeners


Anyway, this is the basis I am working from with all of my (somewhat
complex) data structures. Perhaps it's easier with a single data set. I
would definatley avoid any server event notification systems - it's too easy
for your client to miss a message and thereby mess up your state.
 
Charles
The stock market prices change by the second, and it is important that
traders have up-to-the-second prices on their screens. Polling is very
inefficient. The observer pattern was made for this scenario but I am
hearing that it can't be implemented on a database. I still think that
this _is_ widely wanted, but that we are largely being told that it can't
be done.
Click to expand...
I gave an half our ago a message that you have read wherin I wrote that
this are the situations where it is needed complete with a sample from Ken
about that. (Using the notify), I have however the idea that you did not
even look at it.

Therefore why are you writing this while I wrote that already, secondly as
forever did you not give that information in your first message. Not every
application is a broker application you know?

:-)

Cor
 
Have I upset you in some way Cor?
I gave an half our ago a message that you have read wherin I wrote that
this are the situations where it is needed complete with a sample from
Ken about that. (Using the notify), I have however the idea that you did
not even look at it.
Click to expand...

In fact I did, and bookmarked it. That is how I knew that the SqlDependency
class had been introduced in VS2005.
Therefore why are you writing this while I wrote that already, secondly as
forever did you not give that information in your first message. Not every
application is a broker application you know?
Click to expand...

Indeed, but why would I be asking about a notify feature if I did not want
it for a good reason?

:-)

Charles
 
Hi
My pattern uses a worker thread for performing operations, I have my own
data cache, ie. I don't use data sets. The thread checks the cache in idle
time to see if anything has changed and fires off Update, Delete, Insert
and Move (it's a tree structure so I need this one) methods to it's
listeners. UI components (user controls) register with the data cache as
listeners for these kind of events and implement an
IDataUpdateThreadNotification interface.
Click to expand...

I might have a go at this; I take your point about the danger of missing a
server message. Although it shouldn't happen, I have no doubt that it could.

Have you determined a suitable frequency for checking in your worker thread?
Where do you create the data caches, on the UI thread or the worker thread?

Charles
 
The data cache is really the central controller of the whole thing, created
on the UI thread. It basically mediates between the UI components and the
worker thread and the worker thread does all the talking to the database.
The thread maintains queues of operations to perform. The data cache adds a
request to the queue when something needs to be done, for example:


User clicks ADD RECORD button on a toolbar
Code behind the toolbar click tells the cache to ADD RECORD
The cache formats a request and queues it at the thread,
theThread.AddRequest (theRequest, CRITICAL)
....then forgets about it.


I have 3 queues: CRITICAL, UI and BORED. Critical is for performing
operations the user requests, UI is for things like fetching thumbnails (in
my application this is a neccessary evil) and BORED is for coherency
checking and other stuff like that.

On each iteration of the worker thread loop ( while not m_bFinished () ), it
takes the single highest priority item from the list of queues and executes
it. If there is nothing in any of the lists, it idles for 100ms (so it
doesn't take up all CPU) - after idling it will choose something to check
coherency for (in my case the Tree Structure, Thumbnails, etc.) and creates
a request, adding it to the BORED queue. Then:

Thread de-queues the single highest priority request
Executes it
Invokes the result back to the cache
The cache resolves changes and fires events to it's listeners.



In terms of frequency, I leave this up to the user. You have to trade
coherency against network traffic and performance - my application is
designed to be able to connect to a webserver via. SOAP or ASP.NET, so it's
important I can throttle the coherency check down if I need to.

Note that even with high coherency, the user can still execute an action and
have it fail - ie. it's still possible to attempt to modify a record another
user has deleted, if you do it before the coherency check works out that the
record was deleted. To handle this case, you simply tell the user with an
error message, ie. "The record could not be modified because it no longer
exists".


It's really a simple pattern but implementation details can be more tricky.
If you need any help, post up :).
 
I'm not really convinced by the bank sample. It could be blocked when the
transaction is actually processed IMO there is no need to see the amount
refreshed in real time. I'm not even sure the idea is not that it will be
blocked soon enough by the following transaction if not by the current
one....

The stock market price is much more convincing (but this is a niche not
something widely wanted). Several options would be :
- polling
- sql dependency
- callback coming from the server (using remoting, web services, broadcast
or multicast message etc)
etc...

What is your specific scenario ?
 
I see what you mean about non-trivial ;-)

I will read and digest. It is the kind of thing that could fit with my
scenario.

Thanks.

Charles
 
With SQL 2005, yes. With SQL 2000, it can be set up, but it will still poll
in the background. I am not sure about Oracle, but there is probably
something there. If the client is fully connected, you can build a
mechanism, as well, but you are on your own keeping track of who has what
data, which may cost more than the benefit of avoiding concurrency issues
rather than just reducing them.

--
Gregory A. Beamer

*************************************************
Think Outside the Box!
*************************************************
 
What is your specific scenario ?

An accountancy tool, that will start small, but will scale to multiple
users. Some of the screens might be left open for some minutes, whilst the
data backing them will be available to other users. Any or all of the users
could potentially modify the data, and the others must be able to see the
changes when they happen.

Charles
 
Hi,

Then you need:

- A polling mechanism every n seconds
- Some specific notification system for updates provided by your database,
if available.

AFAIK, the standard database objects of the APIs (ADO, ODBC, etc.) don't
provide any of this.

Another approach is to prevent data modifications while a user is viewing it
(row-level locking). This is done in Oracle with a SELECT .. FOR UPDATE
statement, for example. Depending on your app, this kind of lock while
viewing data can be suitable or overkill.

All other approaches detect the conflict after the fact, when the second
user tries to modify data that was not the one that he got initially, as I
explained using a timestamp (or using dynamic recordsets, datasets, etc.
which I suppose that do the same internally)
--

Best regards,

Carlos J. Quintero

MZ-Tools: Productivity add-ins for Visual Studio
You can code, design and document much faster:
http://www.mztools.com
 
Back
Top