ImageResizer.Plugins.DiskCache.CachedFolder Class Reference

Represents a cached view of a folder of cached items More...

Inheritance diagram for ImageResizer.Plugins.DiskCache.CachedFolder:

Public Member Functions
virtual void	clear ()
virtual CachedFileInfo	getCachedFileInfo (string relativePath)
	Returns null if (a) the file doesn't exist, or (b) the file isn't populated. Calling code should always fall back to filesystem calls on a null result. More...
virtual void	setCachedFileInfo (string relativePath, CachedFileInfo info)
	Sets the CachedFileInfo object for the specified path, creating any needed folders along the way. If 'null', the item will be removed, and no missing folder will be created. More...
bool	bumpDateIfExists (string relativePath)
	Tries to set the AccessedUtc of the specified file to the current date (just in memory, not on the filesystem). More...
virtual CachedFileInfo	getFileInfo (string relativePath, string physicalPath)
	Gets a CachedFileInfo object for the file even if it isn't in the cache (falls back to the filesystem) More...
virtual CachedFileInfo	getFileInfoCertainExists (string relativePath, string physicalPath)
	Verifies the file exists before returning the cached data. Discrepancies in file existence result in OnFileDisappeard being fired. More...
bool	GetIsValid (string relativePath)
	Returns the value of IsValid on the specified folder if present, or 'false' if not present. More...
IList< string >	getSubfolders (string relativePath)
	returns a list More...
Dictionary< string, CachedFileInfo >	getSubfilesCopy (string relativePath)
	returns a dictionary of files. More...
ICollection< KeyValuePair < string, CachedFileInfo > >	getSortedSubfiles (string relativePath)
	returns a dictionary of files. More...
int	getFileCount (string relativePath)
void	populate (string relativePath, string physicalPath)
	Refreshes file and folder listing for this folder (non-recursive). Sets IsValid=true afterwards. More...
bool	existsCertain (string relativePath, string physicalPath)
bool	exists (string relativePath, string physicalPath)
bool	modifiedDateMatches (DateTime utc, string relativePath, string physicalPath)
bool	modifiedDateMatchesCertainExists (DateTime utc, string relativePath, string physicalPath)

Protected Member Functions
CachedFolder	getFolder (string relativePath)
	Not thread safe. More...
CachedFolder	getOrCreateFolder (string relativePath, bool createIfMissing)
void	populateSubfolders (string relativePath, string physicalPath)
	Updates the 'folders' dictionary to match the folders that exist on disk. ONLY UPDATES THE LOCAL FOLDER More...
void	populateFiles (string relativePath, string physicalPath)
	Updates the 'files' dictionary to match the files that exist on disk. Uses the accessedUtc values from the previous dictionary if they are newer. More...
bool	roughCompare (DateTime d1, DateTime d2)
	Returns true if both dates are equal to the nearest 200th of a second. More...
string	checkRelativePath (string relativePath)

Protected Attributes
readonly object	_sync = new object()
Dictionary< string, CachedFolder >	folders = new Dictionary<string, CachedFolder>(StringComparer.OrdinalIgnoreCase)
Dictionary< string, CachedFileInfo >	files = new Dictionary<string, CachedFileInfo>(StringComparer.OrdinalIgnoreCase)

Properties
bool	IsValid [get, set]
	Defaults to false. Set to true immediately after being refreshed from the filesystem. Set to false if a file disappears from the filesystem cache without the cache index being notified first. Used by the cleanup system - not of importance to the cache write system. More...
StringComparer	KeyComparer [get]

Events
FileDisappearedHandler	FileDisappeared
	Fired when a file disappears from the cache folder without the cache index knowing about it. More...

Detailed Description

Represents a cached view of a folder of cached items

Definition at line 14 of file CachedFolder.cs.

Member Function Documentation

bool ImageResizer.Plugins.DiskCache.CachedFolder.bumpDateIfExists ( string  relativePath )

inline

Tries to set the AccessedUtc of the specified file to the current date (just in memory, not on the filesystem).

Parameters

relativePath

Returns

Definition at line 114 of file CachedFolder.cs.

                                                          {
            relativePath = checkRelativePath(relativePath);
            lock (_sync) {
                int slash = relativePath.IndexOf('/');
                if (slash < 0) {
                    //Update the accessed date.
                    CachedFileInfo old;
                    if (files.TryGetValue(relativePath,out old)) files[relativePath] = new CachedFileInfo(old, DateTime.UtcNow);
                    return true; //We updated it!
                } else {
                    //Try to access subfolder
                    string folder = relativePath.Substring(0, slash);
                    CachedFolder f = null;
                    if (!folders.TryGetValue(folder, out f)) return false;//If the folder doesn't exist, quit
                    if (f == null) return false; //If the folder is null, quit!

                    //Recurse if possible
                    return f.bumpDateIfExists(relativePath.Substring(slash + 1));
                }
            }
        }

string ImageResizer.Plugins.DiskCache.CachedFolder.checkRelativePath ( string  relativePath )

inlineprotected

Parameters

relativePath

Returns

Definition at line 399 of file CachedFolder.cs.

                                                                {
            if (relativePath == null) return relativePath;
            if (relativePath.StartsWith("/") || relativePath.EndsWith("/")) {
                Debug.WriteLine("Invalid relativePath value - should never have leading slash!");
            }
            return relativePath;
        }

virtual CachedFileInfo ImageResizer.Plugins.DiskCache.CachedFolder.getCachedFileInfo ( string  relativePath )

inlinevirtual

Returns null if (a) the file doesn't exist, or (b) the file isn't populated. Calling code should always fall back to filesystem calls on a null result.

Parameters

relativePath

Returns

Definition at line 59 of file CachedFolder.cs.

                                                                             {
            relativePath = checkRelativePath(relativePath);
            lock (_sync) {
                int slash = relativePath.IndexOf('/');
                if (slash < 0) {
                    CachedFileInfo f;
                    if (files.TryGetValue(relativePath, out f)) return f; //cache hit
                } else {
                    //Try to access subfolder
                    string folder = relativePath.Substring(0, slash);
                    CachedFolder f;
                    if (!folders.TryGetValue(folder, out f)) f = null;
                    //Recurse if possible
                    if (f != null) return f.getCachedFileInfo(relativePath.Substring(slash + 1));
                }
                return null; //cache miss or file not found
            }
        }

virtual CachedFileInfo ImageResizer.Plugins.DiskCache.CachedFolder.getFileInfo ( string  relativePath, string  physicalPath  )

inlinevirtual

Gets a CachedFileInfo object for the file even if it isn't in the cache (falls back to the filesystem)

Parameters

relativePath
physicalPath

Returns

Definition at line 142 of file CachedFolder.cs.

                                                                                            {
            relativePath = checkRelativePath(relativePath);
            lock (_sync) {
                CachedFileInfo f = getCachedFileInfo(relativePath);
                //On cache miss or no file
                if (f == null && System.IO.File.Exists(physicalPath)) {
                    //on cache miss
                    f = new CachedFileInfo(new System.IO.FileInfo(physicalPath));
                    //Populate cache
                    setCachedFileInfo(relativePath, f);
                }
                return f;//Null only if the file doesn't exist.
            }
        }

virtual CachedFileInfo ImageResizer.Plugins.DiskCache.CachedFolder.getFileInfoCertainExists ( string  relativePath, string  physicalPath  )

inlinevirtual

Verifies the file exists before returning the cached data. Discrepancies in file existence result in OnFileDisappeard being fired.

Parameters

relativePath
physicalPath

Returns

Definition at line 163 of file CachedFolder.cs.

                                                                                                         {
            relativePath = checkRelativePath(relativePath);
            bool fireEvent = false;
            CachedFileInfo f = null;
            lock (_sync) {
                bool exists = System.IO.File.Exists(physicalPath);

                f = getCachedFileInfo(relativePath);
                //cache miss
                if (f == null && exists) {
                    //on cache miss
                    f = new CachedFileInfo(new System.IO.FileInfo(physicalPath));
                    //Populate cache
                    setCachedFileInfo(relativePath, f);
                }
                //cache wrong, discrepancy. File deleted by external actor
                if (f != null && !exists) {
                    f = null;
                    clear(); //Clear the cache completely.
                    fireEvent = true;
                }
            }
            //Fire the event outside of the lock.
            if (fireEvent && FileDisappeared != null) FileDisappeared(relativePath, physicalPath);

            return f;//Null only if the file doesn't exist.
        }

CachedFolder ImageResizer.Plugins.DiskCache.CachedFolder.getFolder ( string  relativePath )

inlineprotected

Not thread safe.

Parameters

relativePath

Returns

Definition at line 208 of file CachedFolder.cs.

                                                              {
            return getOrCreateFolder(relativePath, false);
        }

bool ImageResizer.Plugins.DiskCache.CachedFolder.GetIsValid ( string  relativePath )

inline

Returns the value of IsValid on the specified folder if present, or 'false' if not present.

Parameters

relativePath

Returns

Definition at line 196 of file CachedFolder.cs.

                                                    {
            lock (_sync) {
                CachedFolder f = getFolder(relativePath);
                if (f != null) return f.IsValid;
                return false;
            }
        }

ICollection<KeyValuePair<string, CachedFileInfo> > ImageResizer.Plugins.DiskCache.CachedFolder.getSortedSubfiles ( string  relativePath )

inline

returns a dictionary of files.

Parameters

relativePath

Returns

Definition at line 262 of file CachedFolder.cs.

                                                                                                        {
            lock (_sync) {
                CachedFolder f = getFolder(relativePath);
                if (f == null || f.files.Count < 1) return null;
                //Copy pairs to an array.
                KeyValuePair<string, CachedFileInfo>[] items = new KeyValuePair<string, CachedFileInfo>[f.files.Count];
                int i = 0;
                foreach (KeyValuePair<string, CachedFileInfo> pair in f.files) {
                    items[i] = pair;
                    i++;
                }
                //Sort the pairs on accessed date
                Array.Sort<KeyValuePair<string, CachedFileInfo>>(items, delegate(KeyValuePair<string, CachedFileInfo> a, KeyValuePair<string, CachedFileInfo> b) {
                    return DateTime.Compare(a.Value.AccessedUtc, b.Value.AccessedUtc);
                });


                return items;
            }
        }

Dictionary<string, CachedFileInfo> ImageResizer.Plugins.DiskCache.CachedFolder.getSubfilesCopy ( string  relativePath )

inline

returns a dictionary of files.

Parameters

relativePath

Returns

Definition at line 251 of file CachedFolder.cs.

                                                                                       {
            lock (_sync) {
                CachedFolder f = getFolder(relativePath);
                return new Dictionary<string, CachedFileInfo>(f.files, f.files.Comparer);
            }
        }

IList<string> ImageResizer.Plugins.DiskCache.CachedFolder.getSubfolders ( string  relativePath )

inline

returns a list

Parameters

relativePath

Returns

Definition at line 239 of file CachedFolder.cs.

                                                                {
            lock (_sync) {
                CachedFolder f = getFolder(relativePath);
                return new List<string>(f.folders.Keys);
            }
        }

void ImageResizer.Plugins.DiskCache.CachedFolder.populate ( string  relativePath, string  physicalPath  )

inline

Refreshes file and folder listing for this folder (non-recursive). Sets IsValid=true afterwards.

Parameters

relativePath
physicalPath

Definition at line 296 of file CachedFolder.cs.

                                                                       {
            //NDJ-added May 29,2011
            //Nothing was setting IsValue=true before.
            populateSubfolders(relativePath, physicalPath);
            populateFiles(relativePath, physicalPath);
            getOrCreateFolder(relativePath, true).IsValid = true;
        }

void ImageResizer.Plugins.DiskCache.CachedFolder.populateFiles ( string  relativePath, string  physicalPath  )

inlineprotected

Updates the 'files' dictionary to match the files that exist on disk. Uses the accessedUtc values from the previous dictionary if they are newer.

Parameters

relativePath
physicalPath

Definition at line 335 of file CachedFolder.cs.

                                                                               {
            relativePath = checkRelativePath(relativePath);
            string[] physicalFiles = null;
            try {
                physicalFiles = System.IO.Directory.GetFiles(physicalPath);
            } catch (DirectoryNotFoundException) {
                physicalFiles = new string[] { }; //Pretend it's empty. We don't care, the next recursive will get rid of it.
            }
            Dictionary<string, CachedFileInfo> newFiles = new Dictionary<string, CachedFileInfo>(physicalFiles.Length, KeyComparer);

            CachedFolder f = getOrCreateFolder(relativePath, true);
            foreach (string s in physicalFiles) {
                string local = s.Substring(s.LastIndexOf(System.IO.Path.DirectorySeparatorChar) + 1);
                
                //Todo, add a callback that handles exclusion of files
                if (local.EndsWith(".config", StringComparison.OrdinalIgnoreCase)) continue;
                if (local.StartsWith(".")) continue; //Skip files that start with a period

                //What did we have on file?
                CachedFileInfo old = null;
                lock (_sync) {
                    if (!f.files.TryGetValue(relativePath, out old)) old = null;
                }
                newFiles[local] = new CachedFileInfo(new FileInfo(s), old);
            }
            lock (_sync) {
                f.files = newFiles;
            }
        }

void ImageResizer.Plugins.DiskCache.CachedFolder.populateSubfolders ( string  relativePath, string  physicalPath  )

inlineprotected

Updates the 'folders' dictionary to match the folders that exist on disk. ONLY UPDATES THE LOCAL FOLDER

Parameters

relativePath
physicalPath

Definition at line 308 of file CachedFolder.cs.

                                                                                    {
            relativePath = checkRelativePath(relativePath);
            string[] dirs = null;
            try {
                 dirs = System.IO.Directory.GetDirectories(physicalPath);
            } catch (DirectoryNotFoundException) {
                dirs = new string[]{}; //Pretend it's empty. We don't care, the next recursive will get rid of it.
            }
            lock (_sync) {
                CachedFolder f = getOrCreateFolder(relativePath, true);
                Dictionary<string, CachedFolder> newFolders = new Dictionary<string, CachedFolder>(dirs.Length, KeyComparer);
                foreach (string s in dirs) {
                    string local = s.Substring(s.LastIndexOf(System.IO.Path.DirectorySeparatorChar) + 1);
                    if (local.StartsWith(".")) continue; //Skip folders that start with a period.
                    if (f.folders.ContainsKey(local)) 
                        newFolders[local] = f.folders[local]; //What if the value is null? does containskey work?
                    else 
                        newFolders[local] = new CachedFolder();
                }
                f.folders = newFolders; //Question - why didn't the folders ge tlisted?
            }
        }

bool ImageResizer.Plugins.DiskCache.CachedFolder.roughCompare ( DateTime  d1, DateTime  d2  )

inlineprotected

Returns true if both dates are equal to the nearest 200th of a second.

Parameters

d1
d2

Returns

Definition at line 390 of file CachedFolder.cs.

                                                              {
            return Math.Abs(d1.Ticks - d2.Ticks) < TimeSpan.TicksPerMillisecond * 5;
        }

virtual void ImageResizer.Plugins.DiskCache.CachedFolder.setCachedFileInfo ( string  relativePath, CachedFileInfo  info  )

inlinevirtual

Sets the CachedFileInfo object for the specified path, creating any needed folders along the way. If 'null', the item will be removed, and no missing folder will be created.

Parameters

relativePath
info

Definition at line 84 of file CachedFolder.cs.

                                                                                        {
            relativePath = checkRelativePath(relativePath);
            lock (_sync) {
                int slash = relativePath.IndexOf('/');
                if (slash < 0) {
                    //Set or remove the file
                    if (info == null)
                        files.Remove(relativePath);
                    else
                        files[relativePath] = info;
                } else {
                    //Try to access subfolder
                    string folder = relativePath.Substring(0, slash);
                    CachedFolder f;
                    if (!folders.TryGetValue(folder, out f)) f = null;


                    if (info == null && f == null) return; //If the folder doesn't exist, the file definitely doesn't. Already accomplished.
                    //Create it if it doesn't exist
                    if (f == null) f = folders[folder] = new CachedFolder();
                    //Recurse if possible
                    f.setCachedFileInfo(relativePath.Substring(slash + 1), info);
                }
            }
        }

Property Documentation

bool ImageResizer.Plugins.DiskCache.CachedFolder.IsValid

getset

Defaults to false. Set to true immediately after being refreshed from the filesystem. Set to false if a file disappears from the filesystem cache without the cache index being notified first. Used by the cleanup system - not of importance to the cache write system.

Definition at line 25 of file CachedFolder.cs.

Event Documentation

FileDisappearedHandler ImageResizer.Plugins.DiskCache.CachedFolder.FileDisappeared

Fired when a file disappears from the cache folder without the cache index knowing about it.

Definition at line 36 of file CachedFolder.cs.

---

The documentation for this class was generated from the following file:

• C:/Users/nathanael/Documents/resizer/Plugins/DiskCache/Index/CachedFolder.cs