You're right. But I never said that. What I said was

Bunch of stuff, it will be faster to use a class because of serialization
overhead associated with session

The

The only over head is not just a name look up since the hashtable access has
to be cast back into an object of an appropriate type since the hashtable
stores its items as dictionaryitem. This access is not as fast as, say -
reading an accessor which returns someobject.ToString() since a tostring()
operation boils down to an internal pointer on the object - in essense, a
direct read.

It's quick but it's not quick as a class property read which is why i
recommended it in the first place.

Here's a quick example:

public class SiteApplication
{
 public static MyClass MyInstance{
   get{
     object Result =
HttpContext.Current.Application["SiteApplication.MyInstance"];
     if(Result == null){
       Result = new MyClass();
       HttpContext.Current.Application["SiteApplication.MyInstance"] =
Result;
   }
   return (MyClass)Result;
 }
}

Why so difficult? You can simply update the variable holding the value on a
database write (under a lock of course), where you have all the data ready.
Instead of just setting a dirty flag and then re-requesting the data you
already had from a database.

Jerry

Put a static dirty flag variable in there, set an accessor to read this
dirty flag - IsValid
When you write to the database, set IsValid to false. Every access to the
class should check this property to know whether the cache is valid or not.
If it is valid, read it, otherwise, read from the database and update the
flag to true.

Lock it as well before you touch it. Roughly, the code should look like
this. This will be thread safe *mostly* because you have all that stuff in
the global class you have to protect it from concurrent reads/writes.

private static bool isValid = false;

public bool IsValid
{
   get
   {
       lock(this)
       {
            isValid ? return isValid : return !isValid;
       }
   }
   set
   {
       lock(this)
       {
            isValid = value;
       }
   }
}

--
Regards,
Alvin Bruney
Got Tidbits? Get it here
www.networkip.net/tidbits
 "Jay Lindsay" <JayLindsay@comcast.net> wrote in message
news:uctI4ZNuDHA.2224@TK2MSFTNGP09.phx.gbl...
 Now that I have implemented my need for "caching" with a class variable I
see that there is a problem.  To review:  I am using a class (shared)
variable to store a list of preferences that applies to all users.  I have a
method that returns these preferences.  In that method I check to make  sure
the collection of preferences has been set, if not I access the database to
retrieve the preferences.   When I insert a new item in the database that
item will not be read by my class because the collection of preferences has
already been set.  By using Cache I can invalidate my cache when I insert a
new item in the database so that the cache will be recreated.

 Any thoughts?

 This leads me back to my other question of how can I use Cache in class
that inherits directly from Object.

 ----
 Jay