Google Outlook Sync - Wait

When I learned that Google had an Outlook Sync feature for Google Calendar, I was quick to download and experiment with it. While I was able to sync successfully between both Google and Outlook, I did notice some quirks that others have also reported:

• Calendar items appear in your Deleted Items folder in Outlook
• Outlook is shutdown during sync.

Of course, the forums have some nasty comments in them, my favorite draws the analogy between Google Calendar Sync and Windows ME. I'm going to hold off on this version (0.9.3) until some of these issues are resolved.

Redirect Standard Output of a Service to log4net

I recently wrote a simple windows service that hosted batch files and other applications within a service process. I found some great stuff located here, which really helped me along.

Like many other developers, I quickly discovered that debugging and diagnosing issues wasn't particularily easy. On my machine, it was fairly simple to set a break point and manually attach to the service, but diagnosing issues on other machines lacked detail in the Event Log. What I needed was a way to capture the output of my hosted application.

As I was already using log4net to trace through application flow, I used the following approach to redirect the output of my hosted application into my logger.

using System.Diagnostics;
using log4net;

public class MyService : ServiceBase
{
    private static readonly ILog log = LogManager.GetLogger(typeof(MyService));

    private Process process;

    public override void OnStart(string[] args)
    {
        process = new Process();
        
        ProcessStartInfo info = new ProcessStartInfo();

        // configure the command-line app.
        info.FileName = "java.exe"
        info.WorkingDirectory = "c:\program files\Selenium\RemoteControlServer"
        info.Arguments = "-jar selenium-server.jar"

        // configure runtime specifics
        info.UseShellExecute = false; // needed to redirect output
        info.RedirectStandardOutput = true;
        info.RedirectErrorOutput = true;

        process.StartInfo = info;
        
        // setup event handlers
        process.EnableRaisingEvents = true;
        process.ErrorDataReceived += new DataReceivedEventHandler(process_ErrorDataReceived);
        process.OutputDataReceived += new DataReceivedEventHandler(process_OutputDataReceived);
        
        
        process.Start();

        // notify process about asynchronous reads
        process.BeginErrorReadLine();
        process.BeginOutputReadLine();
        
    }

    // fires whenever errors output is produced
    private static void process_ErrorDataReceived(object sender, DataReceivedEventArgs e)
    {
        try
        {
            if (!String.IsNullOrEmpty(e.Data))
            {
                log.Warn(e.Data);
            }
        }
        catch(Exception ex)
        {
            log.Error("Error occurred while trying to log console errors.", ex)
        }
    }
    
    // fires whenever standard output is produced
    private static void process_OutputDataReceived(object sender, DataReceivedEventArgs e)
    {
        try
        {
            if (!String.IsNullOrEmpty(e.Data)
            {
                log.Debug(e.Data);
            }
        }
        catch(Exception ex)
        {
            log.Error("Error occurred while trying to log console output.", ex);
        }
    }
}

Twelve Days of Code - Wrap up

Over the Christmas break, I started a series of posts about Visual Studio templates. I did some additional work, but never posted that information. I've got some new ideas for some code that I want to experiment and blog about and I may be afforded some additional time at work to pursue related issues, so hopefully I'll find the time to post about those.

Anyway, to clear out the cob-webs, here's the last segment in that series...

My experiment with the Multi-Item Template was to create two projects, create references between them, reference third-party assemblies and create a default class implementation. The biggest challenge and limitation to overcome is that the user supplied settings in the Multi-Item templates are not shared with each of the Project-Templates, resulting in the Project-Templates reverting to their default values. Very frustrating indeed. (Visual Studio 2008 apparently fixes this)

The best way to really manipulate the projects in a solution is to obtain a reference to the Project through the COM Interop libraries for Visual Studio. Once you have a reference to the project, you can fix the project name, add references, etc.

To overcome the limitations of the Multi-Item template, I used WizardExtensions in both the Multi-Item template and the Project-Templates, then used a singleton to carry settings between the projects.

This approached works, but seems pretty complicated, especially dealing with the COM Interop for Visual Studio. I still would need to strong-name the assemblies and write an installer that installs the templates and the assemblies.

It'll interesting to contrast this to the Guidance Automation Toolkit.