Question

We have an heavily used .Net 3.5 application that reads “expensive to create” data and caches it. The application reads\writes files based on it not “being used by another process”. If some other process is reading and writing to the file, then the application goes to sleep(for some time) and retries. Is this a correct way of reading and writing files? Please advise.

public void Add<T>(string key, CacheItem<T> item)
        {
            bool fileInUse = false;
            while (!fileInUse)
            {
                try
                {
                    using (Stream stream = new FileStream(Path.Combine(cachePath, key+".bin"), FileMode.Create, FileAccess.Write, FileShare.None))
                    {
                        Serializer.NonGeneric.Serialize(stream, item);
                    }
                    fileInUse = true;
                }
                catch (IOException ex)
                {
                    if (ex.Message.Contains("being used by another process"))
                    {
                        //Poll till the file is free to be used by this process
                        Thread.Sleep(100);
                        fileInUse = false;
                    }
                }
            }            
        }        

public CacheItem<T> Get<T>(string key, Type type)
        {
            CacheItem<T> item = null;

            FileInfo fileInfo = new FileInfo(Path.Combine(cachePath, key+".bin"));
            fileInfo.Refresh();
            if (fileInfo.Exists)
            {
                bool fileInUse = false;
                while (!fileInUse)
                {
                    try
                    {
                        using (Stream stream = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.None))
                        {
                            object objectTemp = Serializer.NonGeneric.Deserialize(type, stream);
                            item = (CacheItem<T>)objectTemp;
                        }
                        fileInUse = true;
                    }
                    catch(IOException ex) 
                    {
                        if (ex.Message.Contains("being used by another process"))
                        {
                            //Poll till the file is free to be used by this process
                            Thread.Sleep(100);
                            fileInUse = false;
                        }
                    }
                }               
            }                       
            return item;                                   
        }

Answer 1

You could add a global mutex on top of it, to avoid waiting more than absolutely necessary.

Global mutex is created by passing a non-empty name to Mutex Constructor.

Benefits:

• Mutex will allow you to wake up immediately after the file becomes available, instead of waiting 50 ms on average.
• Mutex allows you to fall asleep once and wake up once, instead of repeatedly sleeping/waking. Threads that are sleeping are handled very efficiently by the OS and consume almost no resources at all.
• Once you acquire the mutex, the file open is almost 100% likely to succeed, instead of failing potentially many times before succeeding.

All in all, you are not just going to be faster, you’ll likely consume less CPU cycles in the process.