1. //
  2. // SingleInstance.cs
  3. //
  4. // Author: Shams Madhani {sdotmadhaniatgmxdotcom}
  5. //
  6. // Licensed under BSD or compatible license.
  7. // Redistribution and use in source and binary forms, with or without modification,
  8. // are permitted provided that the conditions set forth by BSD license are met.
  9. //
  10. // References: To be added..
  11. //
  14. using System;
  15. using System.IO;
  16. //using System.IO.Pipes;
  17. using System.Threading;
  18. using System.Collections.Generic;
  19. using System.Security.Permissions;
  22. namespace singleinstance
  23. {
  24. public class ArgumentsReceivedEventArgs : EventArgs
  25. {
  26. public String[] Args { get; set; }
  27. }
  29. public class SingleInstance : IDisposable
  30. {
  31. public static string argfilepath = Environment.CurrentDirectory;
  32. public static string argfile = "newargs.txt";
  33. public Mutex mutex = null;
  34. private Boolean ownsMutex = false;
  35. public Guid identifier = Guid.Empty;
  37. FileSystemWatcher watcher = new FileSystemWatcher();
  38. DateTime lastRead = DateTime.MinValue;
  42. /// <summary>
  43. /// Enforces single instance for an application.
  44. /// </summary>
  45. /// <param name="identifier">An identifier unique to this application.</param>
  46. public SingleInstance(Guid identifier)
  47. {
  48. this.identifier = identifier;
  50. mutex = new Mutex(true, identifier.ToString(), out ownsMutex);
  51. }
  53. /// <summary>
  54. /// Indicates whether this is the first instance of this application.
  55. /// </summary>
  56. public Boolean IsFirstInstance
  57. { get { return ownsMutex; } }
  59. /// <summary>
  60. /// Passes the given arguments to the first running instance of the application.
  61. /// </summary>
  62. /// <param name="arguments">The arguments to pass.</param>
  63. /// <returns>Return true if the operation succeded, false otherwise.</returns>
  64. public Boolean PassArgumentsToFirstInstance(String[] arguments)
  65. {
  66. if (IsFirstInstance)
  67. throw new InvalidOperationException("This is the first instance.");
  69. if (!File.Exists(argfile))
  70. File.Create(argfile);
  72. File.WriteAllText(argfile, "");
  74. foreach (string argument in arguments)
  75. {
  76. File.AppendAllText(argfile, argument+Environment.NewLine);
  77. }
  79. return false;
  80. }
  82. /// <summary>
  83. /// Listens for arguments being passed from successive instances of the applicaiton.
  84. /// </summary>
  85. public void ListenForArgumentsFromSuccessiveInstances()
  86. {
  87. if (!IsFirstInstance)
  88. throw new InvalidOperationException("This is not the first instance.");
  90. ThreadPool.QueueUserWorkItem(new WaitCallback(ListenForArguments));
  92. GC.KeepAlive(mutex);
  94. Thread.Sleep(1000);
  95. }
  97. /// <summary>
  98. /// Listens for arguments on a named pipe.
  99. /// </summary>
  100. /// <param name="state">State object required by WaitCallback delegate.</param>
  101. private void ListenForArguments(Object state)
  102. {
  103. if (!File.Exists(argfile))
  104. File.Create(argfile);
  106. watcher.Path = argfilepath;
  107. watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size;
  108. watcher.Filter = argfile;
  109. watcher.Changed += new FileSystemEventHandler(OnChanged);
  110. watcher.IncludeSubdirectories = false;
  111. watcher.EnableRaisingEvents = true;
  112. }
  114. private void OnChanged(Object state, FileSystemEventArgs e)
  115. {
  116. DateTime lastWriteTime = File.GetLastWriteTime(argfile);
  117. if (lastWriteTime != lastRead)
  118. {
  119. try
  120. {
  121. watcher.EnableRaisingEvents = false;
  123. Console.WriteLine("This is the first instance.");
  124. Thread.Sleep(1000);
  126. try
  127. {
  128. String line;
  129. List<String> arguments = new List<String>();
  131. using (StreamReader sr = new StreamReader(argfile))
  132. {
  133. while (sr.Peek() >= 0)
  134. {
  135. line = sr.ReadLine();
  136. arguments.Add(line);
  137. }
  138. sr.Dispose();
  139. }
  141. ThreadPool.QueueUserWorkItem(new WaitCallback(CallOnArgumentsReceived), arguments.ToArray());
  142. Thread.Sleep(1000);
  143. }
  145. catch (Exception exp1)
  146. {
  147. // Let the user know what went wrong.
  148. Console.WriteLine("The file could not be read:");
  149. Console.WriteLine(exp1.Message);
  150. }
  151. }
  153. finally
  154. {
  155. //Thread.Sleep(1000);
  156. watcher.EnableRaisingEvents = true;
  157. }
  159. lastRead = lastWriteTime;
  160. }
  161. }
  164. /// <summary>
  165. /// Calls the OnArgumentsReceived method casting the state Object to String[].
  166. /// </summary>
  167. /// <param name="state">The arguments to pass.</param>
  168. private void CallOnArgumentsReceived(Object state)
  169. {
  170. OnArgumentsReceived((String[])state);
  171. }
  174. /// <summary>
  175. /// Event raised when arguments are received from successive instances.
  176. /// </summary>
  177. public event EventHandler<ArgumentsReceivedEventArgs> ArgumentsReceived;
  180. /// <summary>
  181. /// Fires the ArgumentsReceived event.
  182. /// </summary>
  183. /// <param name="arguments">The arguments to pass with the ArgumentsReceivedEventArgs.</param>
  184. private void OnArgumentsReceived(String[] arguments)
  185. {
  186. if (ArgumentsReceived != null)
  187. ArgumentsReceived(this, new ArgumentsReceivedEventArgs() { Args = arguments });
  188. }
  192. #region IDisposable
  193. private Boolean disposed = false;
  195. protected virtual void Dispose(bool disposing)
  196. {
  197. if (!disposed)
  198. {
  199. if (mutex != null && ownsMutex)
  200. {
  201. mutex.ReleaseMutex();
  202. mutex = null;
  203. }
  204. disposed = true;
  205. }
  206. }
  208. ~SingleInstance()
  209. {
  210. Dispose(false);
  211. }
  213. public void Dispose()
  214. {
  215. Dispose(true);
  216. GC.SuppressFinalize(this);
  217. }
  218. #endregion
  219. }
  220. }

Single instance command line application in C# using Mono