C#

protected virtual bool IsFileLocked(FileInfo file)
{
    FileStream stream = null;

    try
    {
        stream = file.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None);
    }
    catch (IOException)
    {
        //the file is unavailable because it is:
        //still being written to
        //or being processed by another thread
        //or does not exist (has already been processed)
        return true;
    }
    finally
    {
        if (stream != null)
            stream.Close();
    }

    //file is not locked
    return false;
}

JD86 wrote:

It changes it a couple times but then ends up with a uncaught IOException somehow

catch (IOException)
{
    // Log the exception here!!

    // Keep trying till the file is unlocked
    WriteFile(file, sb, oldValue);
}

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

private static readonly object SyncLock = new object();
private void WriteFile(string file, StringBuilder sb, string oldValue)
{
  try
  {
    using (StreamWriter sw = new StreamWriter(file, false))
    {
      sw.Write(sb.ToString());
    }
    // Log
    EventLog.WriteEntry("QBiniMonitor", "Successfully removed LASTUSERNAME. Old Value: " + oldValue, EventLogEntryType.Information);
  }
  catch (IOException)
  {
    lock (SyncLock)
    {
      // Wait for 200 milliseconds
      Monitor.Wait(SyncLock, 200);
    }
    // Keep trying till the file is unlocked
    WriteFile(file, sb, oldValue);
  }
}

Pete O'Hanlon wrote:

I've just had to assume that the lock has a finite
limit.

Pete O'Hanlon wrote:

I'm loathe to suggest this

using System;
using System.Diagnostics;
using System.IO;
using System.ServiceProcess;
using System.Text;
using System.Threading;

namespace QBiniMonitor
{
    public partial class QBMonitor : ServiceBase
    {
        // Watches the qbw.ini directory
        FileSystemWatcher watcher2012;
        FileSystemWatcher watcher2011;

        // Path to the folder where qbw.ini is stored
        string QB2012 = Environment.ExpandEnvironmentVariables("%ALLUSERSPROFILE%") + @"\Intuit\QuickBooks 2012\";
        string QB2011 = Environment.ExpandEnvironmentVariables("%ALLUSERSPROFILE%") + @"\Intuit\QuickBooks 2011\";

        // Version
        enum Version
        {
            QB2011,
            QB2012
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public QBMonitor()
        {
            InitializeComponent();
        }

        /// <summary>
        /// When service starts we need to start our FileSystemWatcher
        /// </summary>
        protected override void OnStart(string[] args)
        {
            StartNewWatcher(Version.QB2011);
            StartNewWatcher(Version.QB2012);
        }

        /// <summary>
        /// Starts the FileSystemWatcher for Quickbooks 2012 & 2011
        /// </summary>
        private void StartNewWatcher(Version watcherVersion)
        {
            if (watcherVersion == Version.QB2011)
            {
                watcher2011 = new FileSystemWatcher();
                watcher2011.Path = QB2011;
                watcher2011.Filter = "qbw.ini";
                watcher2011.NotifyFilter = NotifyFilters.LastWrite;

                watcher2011.Changed += new FileSystemEventHandler(watcher_Changed);

                // Start the watcher
                StartStopWatcher(Version.QB2011, true);
            }
            else if (watcherVersion == Version.QB2012)
            {
                watcher2012 = new FileSystemWatcher();
                watcher2012.Path = QB2012;
                watcher2012.Filter = "qbw.ini";
                watcher2012.NotifyFilter = NotifyFilters.LastWrite;

                watcher2012.Changed += new FileSystemEventHandler(watcher_Changed);

                // Start the watcher
                StartStopWatcher(Version.QB2012, true);
            }
        }

        /// <summary>
        /// When the file is written to we need to remove the last username
        /// </summary>
        private void watcher_Changed(object sender, FileSystemEventArgs e)
        {
            // Get our file system watcher object
            FileSystemWatcher watcher = sender as FileSystemWatcher;

            // Find what version it is and stop the file system watcher
            if (watcher.Path == QB2012)
                StartStopWatcher(Version.QB2012, false);
            else if (watcher.Path == QB2011)
                StartStopWatcher(Version.QB2011, false);

            // Variable if we should change the file or not
            bool saveFile = false;

            // Variable that keeps our old value
            string oldValue = string.Empty;

            // Contains all the text in the file when we read it
            StringBuilder sb = new StringBuilder();

            try
            {
                using (FileStream fs = new FileStream(e.FullPath, FileMode.Open, FileAccess.Read))
                {
                    using (StreamReader sr = new StreamReader(fs))
                    {
                        while (sr.Peek() >= 0)
                        {
                            // Read the current line
                            string currentLine = sr.ReadLine();

                            // If the line is LASTUSERNAME we need to make sure the value is Admin.
                            if (currentLine.StartsWith("LASTUSERNAME="))
                            {
                                // If the line is not just LASTUSERNAME=Admin then change it
                                if (!currentLine.Equals("LASTUSERNAME=Admin"))
                                {
                                    // LASTUSERNAME contains a value. We must change
                                    sb.AppendLine("LASTUSERNAME=Admin");

                                    // Log what the previous value was
                                    oldValue = currentLine;

                                    // Only save file if we change data
                                    saveFile = true;
                                }
                                else
                                    sb.AppendLine(currentLine); // Value is LASTUSERNAME=Admin (blank) so we are good
                            }
                            else
                                sb.AppendLine(currentLine); // Does not start with LASTUSERNAME=Admin
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                EventLog.WriteEntry("QBiniMonitor", "watcher_Changed::: " + ex.ToString(), EventLogEntryType.Error);
            }

            // If we are supposed to save the file then call WriteFile
            if (saveFile)
            {
                // If we are here that means LASTUSERNAME has a value and we must remove it
                if (watcher.Path == QB2012)
                    WriteFile(Version.QB2012, e.FullPath, sb, oldValue, 1);
                else if (watcher.Path == QB2011)
                    WriteFile(Version.QB2011, e.FullPath, sb, oldValue, 1);
            }
            else
            {
                if (watcher.Path == QB2012)
                    StartStopWatcher(Version.QB2012, true);
                else if (watcher.Path == QB2011)
                    StartStopWatcher(Version.QB2011, true);
            }
        }

        private static readonly object SyncLock = new object();
        private void WriteFile(Version watcherVersion, string file, StringBuilder sb, string oldValue, int retryCount)
        {
            if (retryCount < 5)
            {
                try
                {
                    using (StreamWriter sw = new StreamWriter(file, false))
                    {
                        // Write the file
                        sw.Write(sb.ToString());
                    }

                    // Log
                    EventLog.WriteEntry("QBiniMonitor", "Version: " + watcherVersion.ToString() + ". The value for the last username was cleared. The previous value was: " + oldValue, EventLogEntryType.Information);

                    // Start watching again
                    StartStopWatcher(watcherVersion, true);
                }
                catch (IOException)
                {
                    // Wait for 1 seconds before trying again
                    lock (SyncLock)
                    {
                        EventLog.WriteEntry("QBiniMonitor", "Version: " + watcherVersion.ToString() + ". File was locked. Waiting 2 seconds and trying again. Retry number: " + retryCount);
                        Monitor.Wait(SyncLock, 2000);
                    }

                    // Increase the retry count
                    retryCount = retryCount + 1;

                    // Call our method to try to write the file again
                    WriteFile(watcherVersion, file, sb, oldValue, retryCount);
                }
            }
            else
            {
                // Reached our retry limit so stop trying
                EventLog.WriteEntry("QBiniMonitor", "WriteFile::: " + "Retry limit of 5 was reached while trying to change the data in the file. (Because the file was locked)", EventLogEntryType.Warning);

                // Start watching again
                StartStopWatcher(watcherVersion, true);
            }
        }

        /// <summary>
        /// Starts or stops the file system watcher
        /// </summary>
        /// <param name="watcherVersion"></param>
        /// <param name="start"></param>
        private void StartStopWatcher(Version watcherVersion, bool start)
        {
            try
            {
                switch (watcherVersion)
                {
                    case Version.QB2011:
                        if (start)
                        {
                            watcher2011.EnableRaisingEvents = true;
                            //EventLog.WriteEntry("QBiniMonitor", "Started watching file " + watcher2011.Path + "\\" + watcher2011.Filter, EventLogEntryType.Information);
                        }
                        else
                        {
                            watcher2011.EnableRaisingEvents = false;
                            //EventLog.WriteEntry("QBiniMonitor", "Stopped watching file " + watcher2011.Path + "\\" + watcher2011.Filter, EventLogEntryType.Information);
                        }
                        break;

                    case Version.QB2012:
                        if (start)
                        {
                            watcher2012.EnableRaisingEvents = true;
                            //EventLog.WriteEntry("QBiniMonitor", "Started watching file " + watcher2012.Path + "\\" + watcher2012.Filter, EventLogEntryType.Information);
                        }
                        else
                        {
                            watcher2012.EnableRaisingEvents = false;
                            //EventLog.WriteEntry("QBiniMonitor", "Stopped watching file " + watcher2012.Path + "\\" + watcher2012.Filter, EventLogEntryType.Information);
                        }
                        break;

                    default:
                        break;
                }
            }
            catch (IOException ex)
            {
                // Log the error in the event log
                EventLog.WriteEntry("QBiniMonitor", "StartStopWatcher::: " + ex.ToString(), EventLogEntryType.Error);

                // Stop because of error (most likely because we couldn't find the file)
                Stop();
            }
            catch (Exception ex)
            {
                // Log the error in the event log
                EventLog.WriteEntry("QBiniMonitor", "StartStopWatcher::: " + ex.ToString(), EventLogEntryType.Error);

                // Stop because of error (most likely because we couldn't find the file)
                Stop();
            }
        }

        /// <summary>
        /// When the service stops
        /// </summary>
        protected override void OnStop()
        {
            if (watcher2011 != null)
            {
                watcher2011.EnableRaisingEvents = false;
                watcher2011.Dispose();
            }

            if (watcher2012 != null)
            {
                watcher2012.EnableRaisingEvents = false;
                watcher2012.Dispose();
            }
        }
    }
}

GraphicsPath.Warp (PointF[], RectangleF) 	
GraphicsPath.Warp (PointF[], RectangleF, Matrix) 	
GraphicsPath.Warp (PointF[], RectangleF, Matrix, WarpMode) 	
GraphicsPath.Warp (PointF[], RectangleF, Matrix, WarpMode, Single) 

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

Dan_K wrote:

If the function is called several times, the assembly loading will be done multiple times.

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

Dan_K wrote:

But does the AppDomain check whether it has already been loaded so that it does not load again for consecutive calls?

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]