2007-11-07 Igor Zelmanovich <igorz@mainsoft.com>

[mono.git] / mcs / class / System.Web / System.Web.Caching / CacheDependency.cs

diff --git a/mcs/class/System.Web/System.Web.Caching/CacheDependency.cs b/mcs/class/System.Web/System.Web.Caching/CacheDependency.cs
index f887f5da77571ecc7bab7a91f4f7caf10a888cc6..03794c6e89868a9190f09df2f4f5f209dc9c4873 100644 (file)
--- a/mcs/class/System.Web/System.Web.Caching/CacheDependency.cs
+++ b/mcs/class/System.Web/System.Web.Caching/CacheDependency.cs
@@ -30,6 +30,9 @@
 using System.Collections;
 using System.IO;
 using System.Security.Permissions;
+#if NET_2_0
+using System.Text;
+#endif
 
 namespace System.Web.Caching
 {
@@ -47,12 +50,20 @@ namespace System.Web.Caching
                CacheDependency dependency;
                DateTime start;
                Cache cache;
-#if !TARGET_JVM
                FileSystemWatcher[] watchers;
-#endif
                bool hasChanged;
+#if NET_2_0
+               bool used;
+               DateTime utcLastModified;
+#endif
                object locker = new object ();
                
+#if NET_2_0
+               public CacheDependency (): this (null, null, null, DateTime.Now)
+               {
+               }
+#endif
+               
                public CacheDependency (string filename): this (new string[] { filename }, null, null, DateTime.Now)
                {
                }
@@ -84,7 +95,6 @@ namespace System.Web.Caching
                
                public CacheDependency (string[] filenames, string[] cachekeys, CacheDependency dependency, DateTime start)
                {
-#if !TARGET_JVM
                        if (filenames != null) {
                                watchers = new FileSystemWatcher [filenames.Length];
                                for (int n=0; n<filenames.Length; n++) {
@@ -99,6 +109,7 @@ namespace System.Web.Caching
                                                } else
                                                        continue;
                                        }
+                                       watcher.NotifyFilter |= NotifyFilters.Size;
                                        watcher.Created += new FileSystemEventHandler (OnChanged);
                                        watcher.Changed += new FileSystemEventHandler (OnChanged);
                                        watcher.Deleted += new FileSystemEventHandler (OnChanged);
@@ -107,30 +118,56 @@ namespace System.Web.Caching
                                        watchers [n] = watcher;
                                }
                        }
-#endif
                        this.cachekeys = cachekeys;
                        this.dependency = dependency;
                        if (dependency != null)
                                dependency.DependencyChanged += new EventHandler (OnChildDependencyChanged);
                        this.start = start;
+
+#if NET_2_0
+                       FinishInit ();
+#endif
+               }
+
+#if NET_2_0
+               public virtual string GetUniqueID ()
+               {
+                       StringBuilder sb = new StringBuilder ();
+                       lock (locker) {
+                               if (watchers != null)
+                                       foreach (FileSystemWatcher fsw in watchers)
+                                               if (fsw != null && fsw.Path != null && fsw.Path.Length != 0)
+                                                       sb.AppendFormat ("_{0}", fsw.Path);
+                       }
+
+                       if (cachekeys != null)
+                               foreach (string key in cachekeys)
+                                       sb.AppendFormat ("_{0}", key);
+                       return sb.ToString ();
                }
+#endif
                
                void OnChanged (object sender, FileSystemEventArgs args)
+               {
+                       OnDependencyChanged (sender, args);
+               }
+
+               bool DoOnChanged ()
                {
                        if (DateTime.Now < start)
-                               return;
+                               return false;
                        hasChanged = true;
+#if NET_2_0
+                       utcLastModified = DateTime.UtcNow;
+#endif
                        DisposeWatchers ();
                        
                        if (cache != null)
                                cache.CheckExpiration ();
+
+                       return true;
                }
                
-#if TARGET_JVM
-               void DisposeWatchers ()
-               {
-               }
-#else
                void DisposeWatchers ()
                {
                        lock (locker) {
@@ -142,9 +179,26 @@ namespace System.Web.Caching
                                watchers = null;
                        }
                }
-#endif
+
                public void Dispose ()
                {
+                       DependencyDispose ();
+               }
+
+#if NET_2_0
+               internal virtual void DependencyDisposeInternal ()
+               {
+               }
+#endif
+               
+#if NET_2_0
+               protected virtual
+#endif
+               void DependencyDispose () 
+               {
+#if NET_2_0
+                       DependencyDisposeInternal ();
+#endif
                        DisposeWatchers ();
                        if (dependency != null)
                                dependency.DependencyChanged -= new EventHandler (OnChildDependencyChanged);
@@ -154,8 +208,38 @@ namespace System.Web.Caching
                internal void SetCache (Cache c)
                {
                        cache = c;
+#if NET_2_0
+                       used = c != null;
+#endif
                }
                
+#if NET_2_0
+               protected internal void FinishInit () 
+               {
+                       utcLastModified = DateTime.UtcNow;
+               }
+
+               internal bool IsUsed {
+                       get { return used; }
+               }
+
+               internal DateTime Start {
+                       get { return start; }
+                       set { start = value; }
+               }
+
+               public DateTime UtcLastModified {
+                       get {
+                               return utcLastModified;
+                       }
+               }
+
+               protected void SetUtcLastModified (DateTime utcLastModified) 
+               {
+                       this.utcLastModified = utcLastModified;
+               }
+#endif
+               
                public bool HasChanged {
                        get {
                                if (hasChanged)
@@ -164,13 +248,11 @@ namespace System.Web.Caching
                                if (DateTime.Now < start)
                                        return false;
 
-                               if (cache != null) {
-                                       if (cachekeys != null) {
-                                               foreach (string key in cachekeys) {
-                                                       if (cache.GetKeyLastChange (key) > start) {
-                                                               hasChanged = true;
-                                                               break;
-                                                       }
+                               if (cache != null && cachekeys != null) {
+                                       foreach (string key in cachekeys) {
+                                               if (cache.GetKeyLastChange (key) > start) {
+                                                       hasChanged = true;
+                                                       break;
                                                }
                                        }
                                }
@@ -181,18 +263,34 @@ namespace System.Web.Caching
                        }
                }
                
-               void OnChildDependencyChanged (object o, EventArgs a)
+               void OnChildDependencyChanged (object o, EventArgs e)
                {
                        hasChanged = true;
-                       OnDependencyChanged ();
+                       OnDependencyChanged (o, e);
                }
                
-               void OnDependencyChanged ()
+               void OnDependencyChanged (object sender, EventArgs e)
                {
-                       if (DependencyChanged != null)
-                               DependencyChanged (this, null);
+                       if (!DoOnChanged ())
+                               return;
+                       
+                       if (DependencyChanged == null)
+                               return;
+
+                       foreach (EventHandler eh in DependencyChanged.GetInvocationList ())
+                               eh (sender, e);
                }
                
+#if NET_2_0
+               protected
+#else
+               internal
+#endif
+               void NotifyDependencyChanged (object sender, EventArgs e) 
+               {
+                       OnDependencyChanged (sender, e);
+               }
+
                internal event EventHandler DependencyChanged;
        }
 }