I am not going to get overly verbose here; however the importance of application logging is immeasurable. When applications are deployed, obtaining ‘real life’ application can assist in diagnostic and overall application health situations. Excessive logging can be ineffective (too much to analyze) and burdensome (logging to a text file that grows forever) if not implemented appropriately.

When developing and deploying an application having the flexibility of what, when and how to log can alleviate the burden and ineffectiveness of logging. The System.Diagnostics namespace has a number of classes available that allow for this type of flexible logging. The applied use of these classes allows a developer to specify what to log in an application at various levels of detail within one application without the need to deploy diagnostic builds. Depending on diagnostic needs, the application’s config file can specify the level of diagnostic information to write and where. A simple Logging class (this is the class I created to use this functionality) can be developed as follows:

1namespace BPSoftware
2...{
3 public class Logging
4 ...{
5 /**//// <summary>
6 /// strNameSpace is the base namespace for use in the logging message.
7 /// </summary>
8 public static string strNameSpace;
9
10 /**//// <summary>
11 /// GeneralTraceSwitch is a traceswitch object for logging. Switch level is set through
12 /// the application config switches section. The destination listener is also set through
13 /// the application config file.
14 /// </summary>
15 public static TraceSwitch GeneralTraceSwitch = new TraceSwitch( "General", "General Trace Switch" );
16
17 Methods#region Methods
18 /**//// <summary>
19 /// Writeline is the base logging method. Messages are logged to the listener specified
20 /// in the application config file.
21 /// </summary>
22 /// <param name="strClassName">Calling class name.</param>
23 /// <param name="strMethodName">Calling method name.</param>
24 /// <param name="strMessage">The message sent to the listener.</param>
25 public static void WriteLine( string strClassName, string strMethodName, string strMessage )
26 ...{
27 lock ( typeof( Logging ) )
28 ...{
29 Trace.WriteLine( string.Concat(
30 new object[] ...{
31 "(", DateTime.Now, ") ",
32 strNameSpace, ".", strClassName, ".", strMethodName, " -->", strMessage
33 }
34 ) );
35 }
36 }
37
38 /**//// <summary>
39 /// Pass information to the base WriteLine if the TraceError switch is set.
40 /// </summary>
41 /// <param name="strClassName">Calling class name.</param>
42 /// <param name="strMethodName">Calling method name.</param>
43 /// <param name="strMessage">The message sent to the listener.</param>
44 public static void WriteLineTraceError( string strClassName, string strMethodName, string strMessage )
45 ...{
46 if ( Logging.GeneralTraceSwitch.TraceError )
47 WriteLine( strClassName, strMethodName, strMessage );
48 }
49
50 /**//// <summary>
51 /// Pass information to the base WriteLine if the TraceWarning switch is set.
52 /// </summary>
53 /// <param name="strClassName">Calling class name.</param>
54 /// <param name="strMethodName">Calling method name.</param>
55 /// <param name="strMessage">The message sent to the listener.</param>
56 public static void WriteLineTraceWarning( string strClassName, string strMethodName, string strMessage )
57 ...{
58 if ( Logging.GeneralTraceSwitch.TraceWarning )
59 WriteLine( strClassName, strMethodName, strMessage );
60 }
61
62 /**//// <summary>
63 /// Pass information to the base WriteLine if the TraceInfo switch is set.
64 /// </summary>
65 /// <param name="strClassName">Calling class name.</param>
66 /// <param name="strMethodName">Calling method name.</param>
67 /// <param name="strMessage">The message sent to the listener.</param>
68 public static void WriteLineTraceInfo( string strClassName, string strMethodName, string strMessage )
69 ...{
70 if ( Logging.GeneralTraceSwitch.TraceInfo )
71 WriteLine( strClassName, strMethodName, strMessage );
72 }
73
74 /**//// <summary>
75 /// Pass information to the base WriteLine if the TraceVerbose switch is set.
76 /// </summary>
77 /// <param name="strClassName">Calling class name.</param>
78 /// <param name="strMethodName">Calling method name.</param>
79 /// <param name="strMessage">The message sent to the listener.</param>
80 public static void WriteLineTraceVerbose( string strClassName, string strMethodName, string strMessage )
81 ...{
82 if ( Logging.GeneralTraceSwitch.TraceVerbose )
83 WriteLine( strClassName, strMethodName, strMessage );
84 }
85 #endregion
86 }
87}

1 catch ( Exception ex)
2 ...{
3 Logging.WriteLineTraceError( "ClassName", "Method", "Exception: " + ex.Message );
4 }
5
6 Logging.WriteLineTraceInfo( "ClassName", "Method",,
7 String.Format( "{0}: {1}", e.ActionType.ToString(), e.Message )
8 );

1 <system.diagnostics>
2 <trace autoflush="true" indentsize="4">
3 <!-- Specify listener output -->
4 <listeners>
5 <remove name="Default" />
6 <!-- Write to a log file -->
7 <add name="Default"
8 type="System.Diagnostics.TextWriterTraceListener"
9 initializeData="AFileSync.log" />
10 <!-- Write to the Event Log-->
11 <!-- <add name="Default"
12 type="System.Diagnostics.EventLogTraceListener"
13 initializeData="Application" /> -->
14 </listeners>
15 </trace>
16 <switches>
17 <!-- Off = 0, Error = 1, Warning = 2, Info = 3, Verbose = 4 -->
18 <add name="General" value="3" />
19 </switches>
20 </system.diagnostics>

Labels: .NET, C#, Code, How-To

As I whipped up my file synchronizing service application, to synchronize files between my computer and my NAS), I worked with the System.ServiceProcess Namespace. The System.ServiceProcess Namespace "provides classes that allow you to implement, install, and control Windows service applications".

My file synchronization needs did not require that my application service to be "running" all the time. In, fact I only needed the service to run under certain situations. It was easy enough to get the service written and installed and now I wanted to 'automatically' (programmatically) start and stop my service when certain conditions were met.

Entrance - the ServiceController Class. The ServiceController Class "Represents a Windows service and allows you to connect to a running or stopped service, manipulate it, or get information about it." In order to get acclimated to the ServiceController Class I created a simple application to list and display information about the installed services.

1using System;
2using System.Windows.Forms;
3using System.ServiceProcess;
4
5namespace Services1
6...{
7 public partial class Form1 : Form
8 ...{
9 ServiceController controller;
10
11 public Form1()
12 ...{
13 controller = new ServiceController();
14 controller.MachineName = ".";
15 InitializeComponent();
16 lstServices.DisplayMember = "DisplayName";
17 lstServices.ValueMember = "ServiceName";
18 lstServices.DataSource = ServiceController.GetServices();
19 }
20
21 private void StartService(string servicename)
22 ...{
23 controller.ServiceName = servicename;
24 controller.Start();
25
26 }
27
28 private void PauseService(string servicename)
29 ...{
30 controller.ServiceName = servicename;
31 if (controller.CanPauseAndContinue)
32 controller.Pause();
33 }
34
35 private void StopService(string servicename)
36 ...{
37 controller.ServiceName = servicename;
38 if (controller.CanStop)
39 controller.Stop();
40 }
41
42
43 private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
44 ...{
45 if (lstServices.SelectedItems.Count > 0)
46 ...{
47 try
48 ...{
49 controller.ServiceName = lstServices.SelectedValue.ToString();
50 textBox1.Text = String.Format(
51 "Service Name: {0}\r\nDisplay Name: {1}\r\nType: {2}\r\nStatus: {3}",
52 controller.ServiceName,
53 controller.DisplayName,
54 controller.ServiceType.ToString(),
55 controller.Status.ToString()
56 );
57 }
58 catch (Exception ex)
59 ...{
60 textBox1.Text = String.Format("Error: \r\n{0}",ex.Message);
61 }
62 }
63 else
64 ...{
65 textBox1.Clear();
66 }
67 }
68
69 private void btnStart_Click(object sender, EventArgs e)
70 ...{
71 StartService(lstServices.SelectedValue.ToString());
72 }
73
74 private void btnPause_Click(object sender, EventArgs e)
75 ...{
76 PauseService(lstServices.SelectedValue.ToString());
77 }
78
79 private void btnStop_Click(object sender, EventArgs e)
80 ...{
81 StopService(lstServices.SelectedValue.ToString());
82 }
83 }
84}

Labels: .NET, C#, Code

Recently, I posted about the new addition to my backup strategy; a NAS. My intended use of this device is to have a hot backup of my files. The system I was using before was not capable of storing the amount of data I need backed up, nor was it easy to manage. I modified the set of xCopy batch files that I used for my backups to write the files to the NAS.

This system worked fine, but I needed more. I manage a lot of data and have a lot of files. I wouldn't want to lose any in the event of a system failure. The one problem I see with using this process is the lack of a real time solution.

I was in search of a solution that would offer me real-time synchronization between my files and the NAS. I didn't have to search very far. The .NET Framework includes the FileSystemWatcher Class.

The FileSystemWatcher Class "Listens to the file system change notifications and raises events when a directory, or file in a directory, changes." (quoted directly from MSDN) After reading through this class I quickly whipped up a solution. I developed my own FileSync class that allowed me to easily synchronize files between my remote and local storage. I created a Windows Service (threaded) built around my class (the screen shot in this post is from a sample app I used to test my class) so that I could have the FileSync class running and keeping my files in sync without me needing to do anything. Here is the unit I created:

1using System;
2using System.IO;
3using System.Diagnostics;
4
5namespace BPSoftware
6...{
7 class FileSync
8 ...{
9 private FileSystemWatcher watcher;
10
11 Fields#region Fields
12 private string destpath;
13 public string DestPath
14 ...{
15 get ...{ return destpath; }
16 set ...{ destpath = value; }
17 }
18
19 private string sourcepath;
20 public string SourcePath
21 ...{
22 get ...{ return sourcepath; }
23