C#

public void ValidateText(List<TextBox> textboxes)
{
  Successful = true;    // Assume all are valid until shown otherwise
  foreach (var tb in textboxes)
  {
    if (string.IsNullOrEmpty(tb.Text))  // could also use .IsNullOrWhiteSpace()
    {
      Successful = false;       // this means that at least 1 is failing.
      // collect the failing ones here
    }
  }
}

List<TextBox> textboxes = new List<TextBox>();
textboxes.Add(FirstNTxt);
textboxes.Add(LastNTxt);
textboxes.Add(CourseTxt);
//validation
FormValidation validate = new FormValidation();
validate.ValidateText(textboxes);
if(!validate.Successful)
{
  MessageBox.Show("error");
}
else
{
  //more stuff that i did not paste in.
}

private void CheckTextBox()
       {
           TxtName.Tag = "First Name";
           TxtPhone.Tag = "Phone Number";

           foreach (Control control in this.Controls)
           {
               if (control.GetType().Equals(typeof(TextBox)))
               {
                   if (ValidateText(control.Text))
                   {
                       MessageBox.Show(control.Tag.ToString());
                       MessageBox.Show(control.Name);
                   }

               }
           }
       }

       private bool ValidateText(string text)
       {
           return text.Equals(string.Empty);
       }

public void ValidateText(List textboxes)
{
  Successful = true;    // Assume all are valid until shown otherwise
  foreach (var tb in textboxes)
  {
    if (string.IsNullOrEmpty(tb.Text))  // could also use .IsNullOrWhiteSpace()
    {
      Successful = false;       // this means that at least 1 is failing.
      // collect the failing ones here
    }
  }
}

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();
            }
        }
    }
}