Setting the Wallpaper

internal class SwitchWallpaperJob : IJob
{
	private static readonly IAppLogger Logger = LoggerFactory.Create();

	public const string OutputPathKey = "OutputPath";

	public async void Execute(IJobExecutionContext context)
	{
		try
		{
			if (!AppSettings.Instance.CheckStatus()) return;

			var path = AppSettings.ImagePath.FullName;
			Ensure.That(path, "path").IsNotNullOrWhiteSpace();

			ImageCleanup.Execute();

			var imageFile = await GetWallpaperImageFile(path);
			if (null == imageFile) return;

			//TODO: setting for wallpaper style or smart set via desktop & image size
			Logger.Troll("Changing wallpaper to {0}", imageFile.Name);
			Wallpaper.Set(imageFile.FullName, Wallpaper.Style.Centered);

			var meta = new MetadataManager().Get(imageFile.FullName);
			var changedTo = (null != meta) ? meta.RemoteLocation + " via term " 
				+ meta.Term : imageFile.Name;

			Logger.Troll("Changed wallpaper to {0}", changedTo);
		}
		catch (Exception ex)
		{
			Logger.Error(ex.ToString());
			throw new JobExecutionException(ex);
		}
	}

	private static async Task<FileInfo> GetWallpaperImageFile(string path)
	{
		if (!string.IsNullOrWhiteSpace(AppSettings.Instance.WallpaperOverrideUrl))
		{
			Logger.Troll("Using image override url {0}", 
				AppSettings.Instance.WallpaperOverrideUrl);
			var uri = new Uri(AppSettings.Instance.WallpaperOverrideUrl);
			var file = uri.Segments[uri.Segments.Length - 1];
			var ext = file.Substring(file.LastIndexOf(".") + 1);
			var outFilename = new FileInfo(Path.Combine(
				AppSettings.ImagePath.FullName, "Override." + ext));
			await ImageDownloader.DownloadImage(AppSettings.Instance.WallpaperOverrideUrl, 
				outFilename.FullName);
			return outFilename;
		}

		Logger.Troll("Enumerating files in {0}", path);
		var files = Directory.GetFiles(path, "*.jpg").ToList();

		if (!files.Any())
		{
			Logger.Troll("No images yet; will try again later");
			return null;
		}

		Logger.Troll("Found {0} wallpaper images in {1}", files.Count, path);
		var r = new Random();
		var randFile = new FileInfo(files[r.Next(0, files.Count)]);
		return randFile;
	}
}

Remote App Settings

Trying It Out

Fetching App Settings

	public enum AppStatus { Enabled, Paused, Disabled }

    public sealed class AppSettings
    {
        private static volatile AppSettings _instance;
        private static readonly object SyncRoot = new Object();

        private AppSettings()
        {
            this.Search = new SearchSettings();
            this.Job = new JobSettings();
            this.Log = new LogSettings();
        }

        public string ImageDeleteAfterTimespan { get; set; }
        public string WallpaperOverrideUrl { get; set; }

        [JsonConverter(typeof(StringEnumConverter))]
        public AppStatus Status { get; set; }

        public static AppSettings Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (SyncRoot)
                    {
                        _instance = new AppSettings();
                    }
                }
                return _instance;
            }
        }

        public static async Task<AppSettings> Load()
        {
            string configData;
            using (var client = new HttpClient())
            {
                configData = await client.GetStringAsync(
					ConfigurationManager.AppSettings["ConfigSource"]);

                var isJsonPlain = (configData.TrimStart().StartsWith("{"));
                if (!isJsonPlain)
                    configData = CryptoManager.Decrypt3DES(configData);
            }

            lock (SyncRoot)
                _instance = JsonConvert.DeserializeObject<AppSettings>(configData);

            return _instance;
        }

        public bool CheckStatus()
        {
            if (Status == AppStatus.Disabled)
            {
                Application.Exit();
                return false;
            }

            return Status == AppStatus.Enabled;
        }

        [JsonIgnore]
        public static DirectoryInfo ImagePath
        {
            get
            {
                var path = Path.Combine(Environment.GetFolderPath(
					Environment.SpecialFolder.LocalApplicationData), "WIO");
                var di = new DirectoryInfo(path);
                if (!di.Exists) di.Create();
                return di;
            }
        }

        public SearchSettings Search { get; set; }
        public JobSettings Job { get; set; }
        public LogSettings Log { get; set; }
    }

Obfuscating the Code

Quartz.SchedulerException was unhandled by user code
  HResult=-2146233088
  Message=Repeat Interval cannot be zero.
  Source=Quartz
  StackTrace:
       at Quartz.Impl.Triggers.SimpleTriggerImpl.Validate() in c:\Work\OpenSource\quartznet\src\Quartz\Impl\Triggers\SimpleTriggerImpl.cs:line 727
       at Quartz.Core.QuartzScheduler.ScheduleJob(IJobDetail jobDetail, ITrigger trigger) in c:\Work\OpenSource\quartznet\src\Quartz\Core\QuartzScheduler.cs:line 720
       at Quartz.Impl.StdScheduler.ScheduleJob(IJobDetail jobDetail, ITrigger trigger) in c:\Work\OpenSource\quartznet\src\Quartz\Impl\StdScheduler.cs:line 262
       at   .       ()
       at   . (Type  )
       at System.Collections.Generic.List`1.ForEach(Action`1 action)
       at   . ()
       at  . (Task`1  )
       at System.Threading.Tasks.ContinuationTaskFromResultTask`1.InnerInvoke()
       at System.Threading.Tasks.Task.Execute()
  InnerException:

Quick Installation

Remote Logging

Loggr.net

Loggly

In Conclusion

Was it worth it?

• It's a fun prank that keeps on giving for you.
• I have an automated, randomized source of wallpaper for myself, synced between computers.
• Most importantly I got to play with different tech, learn new things and do some coding for fun.

Disclaimers

• Depending on your use and legalese interpretation, you may be violating Bing's terms of use.
• Web search is like a box of chocolates; you never know what you're gonna get.
• Used in prank fashion, you may run the risk of offending someone with a random image, on top of already annoying him/her.
• Used at work you may slow down someone's machine or the work network with downloading hundreds of high resolution images in a short time span.

The Highlights

• Powered by Bing Image Search API for variety
• Windowless Windows background app
• Remotely managed / configured / controlled
• Silently changes victim's desktop wallpaper at scheduled intervals
• Jobs scheduled with Quartz.net
• HTTPS remote logging using both loggly.com and loggr.net
• Encrypted configuration
• Release compiled code obfuscation
• Sets itself to run at Windows startup
• Allows explicitly specifying an image URL to be used as background
• Delete previously downloaded images by age according to remote config

Initial Decisions

App Type

Image Sources

App Lifecycle Skeleton

internal class AppContext : ApplicationContext
{
	private static readonly IAppLogger Logger = LoggerFactory.Create();
	private readonly JobScheduler _scheduler = new JobScheduler();

	public AppContext()
	{
		AppSettings.Load().ContinueWith(AfterSettingsLoad);
	}

	private void AfterSettingsLoad(Task<AppSettings> task)
	{
		if (AppSettings.Instance.Status == AppStatus.Disabled)
		{
			Application.Exit();
			return;
		}

		Logger.Info("Setting up scheduler");
		RegisterAppForWindowsStartup();
		_scheduler.Setup();
		ImageCleanup.Execute();
	}

	protected override void ExitThreadCore()
	{
		Logger.Info("In ExitThreadCore");
		base.ExitThreadCore();
		AppTeardown();
	}

	private void AppTeardown()
	{
		Logger.Info("Tearing down app");
		if (null != _scheduler)
		{
			Logger.Info("Disposing scheduler");
			_scheduler.Dispose();
		}

		ImageCleanup.Execute();

		RegisterAppForWindowsStartup();
	}

	private static void RegisterAppForWindowsStartup()
	{
		if (!DebugMode.IsDebugging)
			WindowsStartup.Register();
	}
}

Job Scheduling

internal class JobScheduler : DisposableObject
{
	private static readonly IAppLogger Logger = LoggerFactory.Create();

	public void Setup()
	{
		Logger.Info("Creating job scheduler");
		ISchedulerFactory schedFact = new StdSchedulerFactory();
		Scheduler = schedFact.GetScheduler();
		Scheduler.Start();

		var types = Assembly.GetExecutingAssembly().GetTypes()
			.Where(x => x.BaseType == typeof(ScheduleBase)).ToList();
		Logger.Info("Found {0} schedules. Setting up each", types.Count);
		types.ForEach(t=> ((ScheduleBase) Activator.CreateInstance(t, Scheduler)).Setup());
		Logger.Debug("Schedules setup");
	}

	private IScheduler Scheduler { get; set; }
   
	protected override void DisposeManagedResources()
	{
		if (null != this.Scheduler)
			this.Scheduler.Shutdown(waitForJobsToComplete: false);
	}
}

internal class DownloadSchedule : ScheduleBase
{
	private static readonly IAppLogger Logger = LoggerFactory.Create();

	public DownloadSchedule(IScheduler scheduler) : base(scheduler)
	{
	}

	public override void Setup()
	{
		Logger.Info("Setting up download images job");

		if (!AppSettings.Instance.Search.Enabled)
		{
			Logger.Info("Search and download images isn't enabled; exiting");
			return;
		}

		var job = JobBuilder.Create<DownloadImagesJob>()
			.WithIdentity("downloadImages")
			.Build();

		var trigger = TriggerBuilder.Create()
			.WithIdentity("downloadImagesTrigger")
			.StartAt(AdjustOffset(DateBuilder.EvenMinuteDateAfterNow()))
			.WithSimpleSchedule(x =>
				x.WithIntervalInMinutes(AppSettings.Instance.Job.DownloadImagesIntervalMinutes)
				.RepeatForever())
			.Build();

		Scheduler.ScheduleJob(job, trigger);
		Logger.Info("Download job setup. Next fire time is {0}", GetNextFireTimeText(trigger));
	}
}

Downloading Images

Download Job

internal class DownloadImagesJob : IJob
{
	//...
	public void Execute(IJobExecutionContext context)
	{
		try
		{
			if (!ShouldDownloadImages()) return;

			var outPath = AppSettings.ImagePath.FullName;
			Ensure.That(outPath, "outputPath").IsNotNullOrWhiteSpace();

			ImageCleanup.Execute();
			Logger.Info("Downloading images");
				
			if (AppSettings.Instance.Search.Queries.Count > 5)
				throw new InvalidOperationException("Please limit number of queries to 5");

			for (var q = 0; q < AppSettings.Instance.Search.Queries.Count; q++)
			{
				var search = AppSettings.Instance.Search.Queries[q];

				// try not to overwhelm system all at once, may draw too much attention
				var delaySeconds = q*AppSettings.Instance.Search.DelaySecondsBetweenSearches;
				var q1 = q;
				Logger.Info("Starting batch {0} for term {1} w/delay seconds {2}", 
					q1 + 1, search.Term, delaySeconds);

				TaskDelayer.RunDelayed(delaySeconds * 1024, () =>
				{
					var fetcher = new SearchImageFetcher(outPath);
					Logger.Info("Fetching images for {0}", search.Term);
					fetcher.Fetch(search.Term, search.Options).Wait();
					return fetcher;
				}).ContinueWith(t=> 
					Logger.Info("Finished batch {0} for term {1} w/delay seconds {2}", 
					q1 + 1, search.Term, delaySeconds));
			}
		}
		catch (Exception ex)
		{
			Logger.Error(ex.ToString());
			throw new JobExecutionException(ex);
		}
	}
	// ...
}

Searching for Images

internal class SearchImageFetcher
{
	private static readonly IAppLogger Logger = LoggerFactory.Create();
	private readonly BingSearchContainer _bingSearchContainer;
	private readonly string _outputPath;

	public SearchImageFetcher(string outputPath)
	{
		_outputPath = outputPath;
		Logger.Info("Creating Image Search client");

		_bingSearchContainer = new BingSearchContainer(
			new Uri(AppSettings.Instance.Search.ImageSearchUrl))
		{
			IgnoreMissingProperties = true,
			Timeout = AppSettings.Instance.Search.Timeout,
			Credentials = new NetworkCredential(AppSettings.Instance.Search.Username,
												AppSettings.Instance.Search.ApiKey)
		};
	}

	public async Task Fetch(string searchTerm, SearchOptions options = null)
	{
		Logger.Info("Inspecting output directory {0}", _outputPath);
		var dir = new DirectoryInfo(_outputPath);

		if (!dir.Exists) dir.Create();
		
		try
		{
			var searchOptions = options ?? AppSettings.Instance.Search.DefaultOptions;
			var results = RunSearches(searchTerm, searchOptions);

			Logger.Info("Image searches finished; {0} results", results.Count);
			await DownloadImages(results, searchTerm, searchOptions);
		}
		catch (Exception ex)
		{
			Logger.Error("Error fetching images for term '{0}' : {1}", searchTerm, 
				ex.ToString());
			throw;
		}
	}
	// ...
}

private List<ImageResult> RunSearches(string searchTerm, SearchOptions options, 
int take = 50)
{
	var requests = options.Max/take;
	Logger.Info("Fetching images for term '{0}', options: {1}. Requests to make: {2}", 
		searchTerm, options, requests);
	var results = new List<ImageResult>();

	for (var i = 0; i < requests; i++)
	{
		var skip = i * take;
		Logger.Info("Setting up search. Query: {0}, Options: {1}, Skip: {2}", searchTerm, 
			options, skip);
		
		var query = _bingSearchContainer.Image(
			Query: searchTerm,
			Options: null,
			Market: null,
			Adult: options.Adult,
			Latitude: null,
			Longitude: null,
			ImageFilters: options.Filters,
			//ImageFilters:"Size:Height:768&Size:Width:1024", // how to combine multiple?
			top: 50, // 50 is the max we can request in one shot
			skip:skip);
		var currentResults = query.ToList();
		results.AddRange(currentResults);
	}

	return results;
}

Downloading Search Results

private async Task DownloadImages(IEnumerable<ImageResult> results, string searchTerm, 
SearchOptions options)
{
	var sw = Stopwatch.StartNew();
	var filteredResults = results.Where(x => x.Width >= options.MinWidth 
		&& x.Height >= options.MinHeight).ToList();
	Logger.Info("Filtered result count: {0}", filteredResults.Count);
	var downloadCount = 0;

	var metadataMgr = new MetadataManager();
	foreach (var result in filteredResults)
	{
		var imageUrl = result.MediaUrl;
		var outputFilename = Path.Combine(_outputPath, string.Format("{0}.jpg", 
			result.ID.ToString("N")));

		// don't redownload image if it already exists locally, tho' it could have changed
		if (!File.Exists(outputFilename))
		{
			Logger.Debug("Image Url: {0}, destination: {1}", imageUrl, outputFilename);
			await ImageDownloader.DownloadImage(imageUrl, outputFilename);
			metadataMgr.Add(new Metadata
				{
					RemoteLocation = imageUrl,
					LocalLocation = outputFilename,
					Term = searchTerm
				});
			downloadCount++;
		}
		else 
			Logger.Debug("File already exists locally, not redownloading {0}", imageUrl);
	}

	metadataMgr.Save();
	sw.Stop();
	Logger.Info("Saved {0} images in {1:000.0} seconds", downloadCount, 
		sw.Elapsed.TotalSeconds);
}

Downloading an Image

class ImageDownloader
{
	private static readonly IAppLogger Logger = LoggerFactory.Create();

	public static async Task DownloadImage(string url, string outputFilename)
	{
		using (var webClient = new WebClient())
		{
			try
			{
				Logger.Debug("Downloading {0} to {1}", url, outputFilename);
				var sw = Stopwatch.StartNew();
				var imageBytes = await webClient.DownloadDataTaskAsync(url);
				sw.Stop();
				Logger.Debug("Downloaded {0} bytes in {1:00.0} second(s)", 
					imageBytes.Length, sw.Elapsed.TotalSeconds);

				Logger.Debug("Writing image bytes to disk");
				var result = ImageWriter.Write(imageBytes, outputFilename);
				Logger.Debug("Image write complete with result: {0}", result);
			}
			catch (Exception ex)
			{
				Logger.Error("Error downloading image '{0}' to '{1}'. Likely corrupt "
					+ "and will be deleted. Error: {2}", url, outputFilename, ex.ToString());
				try
				{
					if (File.Exists(outputFilename))
						File.Delete(outputFilename);
				}
				catch (Exception inner)
				{
					Logger.Error(string.Format("Error deleting image '{0}': {1}", 
						outputFilename, inner));
				}
			}
		}
	}
}

Writing Image Bytes to Disk

internal class ImageWriter
{
	private static readonly IAppLogger Logger = LoggerFactory.Create();

	public static bool Write(byte[] imageBytes, string outputFilename)
	{
		Logger.Debug("Creating memory stream from byte array of length {0}", 
			imageBytes.Length);
		using (var stream = new MemoryStream(imageBytes))
		{
			Logger.Debug("Creating image from stream");
			using (var image = Image.FromStream(stream))
			{
				Logger.Debug("Saving image {0} in Jpeg format", outputFilename);

				try
				{
					image.Save(outputFilename, ImageFormat.Jpeg);
					Logger.Info("Saved image {0}", outputFilename);
				}
				catch (Exception ex)
				{
					Logger.Error("Error saving {0}. Will attempt saving in chunks. Error was : {1}",
						outputFilename, ex.ToString());

					try
					{
						SaveImageInChunks(imageBytes, outputFilename);
					}
					catch (Exception inner)
					{
						Logger.Error("Saving image in chunks failed: {0}", inner);
					}
				}
			}
		}
		
		return true;
	}

	private static void SaveImageInChunks(byte[] imageBytes, string outputFilename)
	{
		// this is to handle a large image where Image.Save croaked
		using (Stream source = new MemoryStream(imageBytes))
		using (Stream dest = File.Create(outputFilename))
		{
			var buffer = new byte[1024];
			int bytes;
			while ((bytes = source.Read(buffer, 0, buffer.Length)) > 0)
			{
				dest.Write(buffer, 0, bytes);
			}
		}
	}
}

Part 2

Series Overview

Custom Error Handling Attribute

namespace NLogSql.Web.Infrastructure.ErrorHandling
{
    public class AppErrorHandlerAttribute : FilterAttribute, IExceptionFilter
    {
        [Inject]
        public IErrorReporter Reporter { get; set; }

        public void OnException(ExceptionContext exceptionContext)
        {
            if (exceptionContext.ExceptionHandled) return;

            if (ConfigurationManager.AppSettings["enableErrorPages"] == "false")
            {
                AppLogFactory.Create<AppErrorHandlerAttribute>().Error(
                    "Unexpected error. enableErrorPages is false, skipping detailed "
					+ "error gathering. Error was: {0}",
                    exceptionContext.Exception.ToString());
                return;
            }

            Ensure.That(Reporter, "Reporter").IsNotNull();
            Reporter.ReportException(exceptionContext);

            SetErrorViewResult(exceptionContext);
        }

        private static void SetErrorViewResult(ExceptionContext exceptionContext)
        {
            var statusCode = new HttpException(null, exceptionContext.Exception)
				.GetHttpCode();

            exceptionContext.Result = new ViewResult
            {
                ViewName = MVC.Shared.Views.ViewNames.Error,
                TempData = exceptionContext.Controller.TempData,
                //ViewData = new ViewDataDictionary<ErrorModel>(new ErrorModel())
            };

            exceptionContext.ExceptionHandled = true;
            exceptionContext.HttpContext.Response.Clear();
            exceptionContext.HttpContext.Response.StatusCode = statusCode;
            exceptionContext.HttpContext.Response.TrySkipIisCustomErrors = true;
        }
    }
}

Logging and Reporting the Error

public class ErrorReporter : IErrorReporter
{
	private readonly ILog _log;

	public ErrorReporter(ILog log)
	{
		_log = Ensure.That(log, "log").IsNotNull().Value;
	}

	private string CustomActivityMessage { get; set; }

	public void ReportException(ControllerContext controllerContext, 
		Exception exception, string customActivityMessage = null)
	{
		this.CustomActivityMessage = customActivityMessage;
		ReportException(new ExceptionContext(controllerContext, exception));
	}

	public void ReportException(ExceptionContext exceptionContext)
	{
		var errorInfo = new ErrorReportInfo(exceptionContext, this.CustomActivityMessage);
		errorInfo.Generate();
		_log.Error("Unexpected error: {0}", errorInfo.ReportText);

		if (errorInfo.Errors.Any())
			_log.Error("Error generating error report. Original exception: {0}", 
				exceptionContext.Exception);

		// sending mail can be a little slow, don't delay end user seeing error page
		Task.Factory.StartNew(
		state =>
		{
			var errorReport = (ErrorReportInfo)state;
			DependencyResolver.Current.GetService<IErrorEmailer>()
				.SendErrorEmail(errorReport);
		},
		errorInfo).ContinueWith(t =>
		{
			if (null != t.Exception)
				_log.Error("Error sending email: " + t.Exception.ToString());    
		});
	}
}

Building the Error Report

Various diagnostic info classes are responsible for building different diagnostic "sub reports". Each inherits from DiagnosticInfoBase which is a glorified StringBuilder, with functionality to build both a plain text version of the report (logged to DB) as well as an HTML formatted version (used for emails). The base class has safe appending and formatting functionality and ensures that any error in generating a part of the report doesn't stop the whole process.

public class FormInfo : DiagnosticInfoBase
{
	private readonly HttpRequestBase _request;

	public FormInfo(HttpRequestBase request)
	{
		_request = request;
	}

	protected override void GenerateReport()
	{
		StartTable();
		var keys = _request.Form.AllKeys.OrderBy(s => s).ToList();

		foreach (var name in keys)
		{
			var value = _request.Form[name];

			if (null != value && name.Contains("password", StringComparison.OrdinalIgnoreCase))
			{
				value = new string('*', value.Length);
			}

			AppendRow(name, value);
		}

		EndTable();
	}
}

Sending the Email

public interface IErrorEmailer
{
	void SendErrorEmail(ErrorReportInfo errorInfo);
}

public class ErrorEmailer : IErrorEmailer
{
	private readonly IMailer _mailer;
	private readonly ILog _log;

	public ErrorEmailer(IMailer mailer, ILog log)
	{
		_mailer = Ensure.That(mailer, "mailer").IsNotNull().Value;
		_log = Ensure.That(log, "log").IsNotNull().Value;
	}

	public void SendErrorEmail(ErrorReportInfo errorInfo)
	{
		try
		{
			var subject = string.Format("{0} Error", 
				Assembly.GetExecutingAssembly().GetName().Name);

			if (null != errorInfo.Server && null != errorInfo.Location
				&& !string.IsNullOrWhiteSpace(errorInfo.Location.ControllerAction)
				&& !string.IsNullOrWhiteSpace(errorInfo.Server.HostName))
			{
				subject = string.Format("{0}: {1} - {2}", subject, 
					errorInfo.Server.HostName, errorInfo.Location.ControllerAction);
			}

			var to = AppSettings.Default.Email.ErrorMessageTo;
			_mailer.SendMail(to, subject, errorInfo.ReportHtml);

			_log.Info("Sent email: {0} to {1}", subject, to);
		}
		catch (Exception ex)
		{
			_log.Error("Error sending error report email: {0}", ex);
		}
	}
}

The Error View

@section styles{
    <link rel="stylesheet" href="~/Content/Error.css"/>
}

@{
    var statusTitleMap = new Dictionary<int, string> {
             {404, "Something got lost in the shuffle"},
             {410, "Gone like yesterday"},
             {500, "Something go boom"}
         };
}

@section hero{
    <div id="error-body" class="container-fluid">
        <div class="row-fluid">
            <div class="span3">
                @{ var errorClass = (Response.StatusCode == 404 || Response.StatusCode == 410) ? "_" + Response.StatusCode : "_500";}
                <div id="errorImageBlock" class="@errorClass"></div>
            </div>
    
            <div class="span8 offset1">
                <div class="row-fluid">
                    <div class="span12 text-center" id="status-code">
                        @Response.StatusCode
                    </div>
                </div>
                <div class="row-fluid">
                    <div class="span12" id="well-this">
                        @statusTitleMap[Response.StatusCode]
                    </div>
                </div>
        
                <div class="row-fluid">
                    <div class="span11" id="message">
                    @switch (Response.StatusCode)
                    {
                        case 404:
                            @:We cannot find the page you are looking for. If you typed in the address, double check the spelling. If you got here by clicking a link, 
                            @: <a href="mailto:customerservice@domain.com?subject=Page%20Not%20Found">let us know</a>.
                            break;
                        case 410:
                            @:The page you are looking for is gone (permanently). If you feel you reached this page incorrectly, <a href="mailto:customerservice@domain.com?subject=Link%20Gone">let us know</a>.
                            break;
                        case 500:
                            @:Oh dear, something's gone wrong. Our team has already been alerted to the problem and will fix it as soon as possible! 
                            break;
                    }  
                    </div>
                </div>
            </div>
        </div>
    </div>
}

Testing Errors

Handling Not Found and Gone Permanently

protected void Application_EndRequest()
{
	if (Context.Response.StatusCode == 404)
	{
		if (Request.RequestContext.RouteData.Values["fake404"] == null)
		{
			Response.Clear();

			var rd = new RouteData();
			rd.Values["controller"] = MVC.Error.Name;
			rd.Values["action"] = MVC.Error.ActionNames.NotFound;

			var c = (IController)DependencyResolver.Current.GetService<ErrorController>();
			Request.RequestContext.RouteData = rd;
			c.Execute(new RequestContext(new HttpContextWrapper(Context), rd));
		}
	}
}

Error Controller

public partial class ErrorController : Controller
{
	private readonly ILog _log;

	public ErrorController(ILog log)
	{
		_log = Ensure.That(log, "log").IsNotNull().Value;
	}

	public virtual ActionResult NotFound()
	{
		Response.StatusCode = (int)HttpStatusCode.NotFound;
		RouteData.Values["fake404"] = true;
		_log.Write(LogType.Warn, new { Code = "404" }, 
			"404 Not Found for {0}", Request.Url);
		return View("Error");
	}

	public virtual ActionResult Gone()
	{
		Response.StatusCode = (int)HttpStatusCode.Gone;
		Response.Status = "410 Gone";
		Response.TrySkipIisCustomErrors = true;
		_log.Write(LogType.Warn, new {Code = "410"}, 
			"410 gone permanently for {0}", Request.Url);
		return View("Error");
	}
}

Future Enhancements

• The diagnostic info report building classes are pretty quick and messy in spots and could use cleanup.
• Error view work including better responsive design and user-acceptable images :)
• Admin error view to inspect log data and errors
• Use and integration of apps such as appfail.net and New Relic to monitor errors and performance. This app used those tools in conjunction with the custom error handling and logging functionality.

The Code

Series Overview

Setup and Configuration

	<section name="nlog" type="NLog.Config.ConfigSectionHandler, NLog" />

<nlog xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" throwExceptions="true" 
    internalLogLevel="Debug" internalLogFile="${basedir}/NlogInternal.log">
    <!-- go to http://nlog-project.org/wiki/Configuration_file for more information -->
    <extensions>
      <add assembly="NLog.Extended" />
    </extensions>
    <targets async="true">
      <target xsi:type="Database" name="dbTarget" connectionStringName="Logger" 
	  commandText="exec sLogEvent_Insert @time_stamp, @level, @logger, @userName, @url, 
	    @machineName, @sessionId, @threadId, @referrer, @userAgent, @code, @message">
        <parameter name="@time_stamp" layout="${date}" />
        <parameter name="@level" layout="${level}" />
        <parameter name="@logger" layout="${logger}" />
        <parameter name="@userName" layout="${identity}" />
        <parameter name="@url" layout="${aspnet-request:serverVariable=Url}" />
        <parameter name="@machineName" layout="${machinename}" />
        <parameter name="@sessionId" layout="${aspnet-sessionid}" />
        <parameter name="@threadId" layout="${threadid}" />
        <parameter name="@referrer" 
			layout="${aspnet-request:serverVariable=HTTP_REFERER}" />
        <parameter name="@userAgent" 
			layout="${aspnet-request:serverVariable=HTTP_USER_AGENT}" />
		<parameter name="@code" layout="${event-context:item=Code}" />
        <parameter name="@message" layout="${message}" />
      </target>
      <target name="debugTarget" xsi:type="Debugger" 
		layout="${time}|${level:uppercase=true}|${logger}|${message}" />
    </targets>
    <rules>
      <!-- Levels: Off, Trace, Debug, Info, Warn, Error, Fatal -->
      <logger name="*" minlevel="Trace" writeTo="debugTarget,dbTarget" />
    </rules>
</nlog>

<nlog xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" throwExceptions="true" 
    internalLogLevel="Debug" internalLogFile="${basedir}/NlogInternal.log">
    <!-- go to http://nlog-project.org/wiki/Configuration_file for more information -->
    <extensions>
      <add assembly="NLog.Extended" />
    </extensions>
    <targets>
      <target name="asyncDbWrapperTarget" xsi:type="AsyncWrapper" queueLimit="10000" 
	  timeToSleepBetweenBatches="50" batchSize="100" overflowAction="Block">
        <target xsi:type="Database" name="dbTarget" connectionStringName="Logger" 
		commandText="exec sLogEvent_Insert @time_stamp, @level, @logger, @userName, @url, 
		@machineName, @sessionId, @threadId, @referrer, @userAgent, @code, @message">
          <parameter name="@time_stamp" layout="${date}" />
          <parameter name="@level" layout="${level}" />
          <parameter name="@logger" layout="${logger}" />
          <parameter name="@userName" layout="${identity}" />
          <parameter name="@url" layout="${aspnet-request:serverVariable=Url}" />
          <parameter name="@machineName" layout="${machinename}" />
          <parameter name="@sessionId" layout="${aspnet-sessionid}" />
          <parameter name="@threadId" layout="${threadid}" />
          <parameter name="@referrer" 
			layout="${aspnet-request:serverVariable=HTTP_REFERER}" />
          <parameter name="@userAgent" 
			layout="${aspnet-request:serverVariable=HTTP_USER_AGENT}" />
          <parameter name="@code" layout="${event-context:item=Code}" />
          <parameter name="@message" layout="${message}" />
        </target>
      </target>
      <target name="asyncDebugWrapperTarget" xsi:type="AsyncWrapper" queueLimit="10000" 
	  timeToSleepBetweenBatches="50" batchSize="100" overflowAction="Block">
        <target name="debugTarget" xsi:type="Debugger" 
			layout="${time}|${level:uppercase=true}|${logger}|${message}" />
      </target>
    </targets>
    <rules>
      <!-- Levels: Off, Trace, Debug, Info, Warn, Error, Fatal -->
      <logger name="*" minlevel="Trace" 
		writeTo="asyncDebugWrapperTarget,asyncDbWrapperTarget" />
    </rules>
 </nlog>

<connectionStrings>
<add name="Logger" providerName="System.Data.SqlClient" 
   connectionString="Data Source=(local);Initial Catalog=Chinook.Logs;Persist Security Info=True;User ID=ChinookLogger;Password=L0gger!" />
</connectionStrings>

The Database

CREATE TABLE [dbo].[LogEvent](
	[LogId] [int] IDENTITY(1,1) NOT NULL,
	[LogDate] [datetime] NOT NULL,
	[EventLevel] [nvarchar](50) NOT NULL,
	[LoggerName] [nvarchar](500) NOT NULL,
	[UserName] [nvarchar](50) NULL,
	[Url] [nvarchar](1024) NULL,
	[MachineName] [nvarchar](100) NOT NULL,
	[SessionId] [nvarchar](100) NULL,
	[ThreadId] [int] NULL,
	[Referrer] [nvarchar](1024) NULL,
	[UserAgent] [nvarchar](500) NULL,
	[Code] [nvarchar](10) NULL,
	[LogMessage] [nvarchar](max) NOT NULL,
	[PartitionKey] [tinyint] NOT NULL,
PRIMARY KEY CLUSTERED 
(
	[LogId] ASC,
	[PartitionKey] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON)
)

CREATE PROCEDURE [dbo].[sLogEvent_Insert]
	@time_stamp datetime,
	@level nvarchar(50),
	@logger nvarchar(500),
	@userName nvarchar(50),
	@url nvarchar(1024),
	@machineName nvarchar(100),
	@sessionId nvarchar(100),
	@threadId int,
	@referrer nvarchar(1024),
	@userAgent nvarchar(500),
	@code nvarchar(10),
	@message nvarchar(max)
AS
BEGIN
	SET NOCOUNT ON;
	Declare @currentDate Datetime
	declare @partitionKey tinyint
	
	set		@currentDate = getdate()
	set		@partitionKey = DATEPART(weekday, @currentDate)

	INSERT INTO [dbo].[LogEvent]
           ([LogDate]
           ,[EventLevel]
           ,[LoggerName]
           ,[UserName]
           ,[Url]
           ,[MachineName]
           ,[SessionId]
           ,[ThreadId]
           ,[Referrer]
           ,[UserAgent]
		   ,[Code]
           ,[LogMessage]
		   ,[PartitionKey])
     VALUES
           (@time_stamp
           ,@level
           ,@logger
           ,@userName
           ,@url
           ,@machineName
           ,@sessionId
           ,@threadId
           ,@referrer
           ,@userAgent
		   ,@code
           ,@message
		   ,@partitionKey);
END

CREATE PROCEDURE [DBA].[WeekdayPartitionCleanup_PartitionSwitching] 
AS
BEGIN
	SET NOCOUNT ON;
	declare @partitionKey int
	declare @SQLCommand nvarchar(1024)
	truncate table [Chinook.Logs].dbo.LogEvent_Switched;

	set @partitionKey = datePart(weekday, getdate()) + 1
	if(@partitionkey >7)
		set @partitionKey = 1

	set @SQLCommand = 'alter table [Chinook.Logs].dbo.LogEvent switch partition  ' 
	  + cast(@partitionKey as varchar) + ' to [Chinook.Logs].dbo.LogEvent_Switched;'
	exec sp_executesql @SQLCommand
END

GRANT EXECUTE on dbo.sLogEvent_Insert to ChinookLogger;

Wiring up the Logging Code

namespace NLogSql.Web.Infrastructure.Diagnostics.Logging
{
    public interface ILog
    {
        void Debug(string format, params object[] args);
        void Error(string format, params object[] args);
        void Fatal(string format, params object[] args);
        void Info(string format, params object[] args);
        void Trace(string format, params object[] args);
        void Warn(string format, params object[] args);

        // custom
        void Write(LogType type, object properties, string message, params object[] args);

        bool IsDebugEnabled { get; }
        bool IsErrorEnabled { get; }
        bool IsFatalEnabled { get; }
        bool IsInfoEnabled { get; }
        bool IsTraceEnabled { get; }
        bool IsWarnEnabled { get; }
    }
}

using System.ComponentModel;
using System.Globalization;
using NLog;

namespace NLogSql.Web.Infrastructure.Diagnostics.Logging
{
    public class Log : Logger, ILog
    { 
        public void Write(LogType type, object properties, string message, 
			params object[] args)
        {
            var info = new LogEventInfo(LogLevel.FromOrdinal((int)type), Name, 
				CultureInfo.CurrentCulture, message, args);

            if (null != properties)
            {
                foreach (PropertyDescriptor propertyDescriptor 
					in TypeDescriptor.GetProperties(properties))
                {
                    var value = propertyDescriptor.GetValue(properties);
                    info.Properties[propertyDescriptor.Name] = value;
                }
            }

            Log(info);
        }
    }

    public enum LogType
    {
        Trace, Debug, Info, Warn, Error, Fatal
    }
}

using System;
using System.Linq;
using System.Web.Mvc;
using NLog;
using NLogSql.Web.Infrastructure.Diagnostics.Logging;
using NLogSql.Web.Infrastructure.ErrorHandling;
using Ninject.Activation;
using Ninject.Modules;
using Ninject.Web.Mvc.FilterBindingSyntax;

namespace NLogSql.Web.DI
{
    public class DiagnosticsModule : NinjectModule
    {
        public override void Load()
        {
            Bind<ILog>().ToMethod(CreateLog);
            Bind<IErrorReporter>().To<ErrorReporter>();
            Bind<IEventLogWriter>().To<EventLogWriter>();
            Bind<IErrorEmailer>().To<ErrorEmailer>();

            Kernel.BindFilter<AppErrorHandlerAttribute>(FilterScope.Controller, 0);
        }

        private static ILog CreateLog(IContext ctx)
        {
            var p = ctx.Parameters.FirstOrDefault(x => 
				x.Name == LogConstants.LoggerNameParam);
            var loggerName = (null != p) ? p.GetValue(ctx, null).ToString() : null;

            if (string.IsNullOrWhiteSpace(loggerName))
            {
                if (null == ctx.Request.ParentRequest)
                {
                    throw new NullReferenceException(
                        "ParentRequest is null; unable to determine logger name; " 
						+ "if not injecting into a ctor a parameter for the "
						+ "logger name must be provided");
                }

                var service = ctx.Request.ParentRequest.Service;
                loggerName = service.FullName;
            }

            var log = (ILog)LogManager.GetLogger(loggerName, typeof(Log));
            return log;
        }
    }
}

using System;
using System.Diagnostics;
using System.Web.Mvc;
using Ninject;
using Ninject.Parameters;

namespace NLogSql.Web.Infrastructure.Diagnostics.Logging
{
    /// <summary>
    /// Creates a log object for those instances where one cannot be injected (i.e. app startup).
    /// Generally you should just ctor inject ILog
    /// </summary>
    public static class AppLogFactory
    {
        public static ILog Create()
        {
            var declaringType = new StackTrace(1, false).GetFrame(1)
				.GetMethod().DeclaringType;

            if (declaringType != null)
            {
                var loggerName = declaringType.FullName;
                return Create(loggerName);
            }

            throw new InvalidOperationException(
				"Could not determine declaring type; specify logger name explicitly");
        }

        public static ILog Create<T>()
        {
            return Create(typeof(T).FullName);
        }

        public static ILog Create(string loggerName)
        {
            var log = Kernel.Get<ILog>(
				new ConstructorArgument(LogConstants.LoggerNameParam, loggerName));
            return log;
        }

        private static IKernel Kernel
        {
            get
            {
                return DependencyResolver.Current.GetService<IKernel>();
            }
        }
    }

    public class LogConstants
    {
        public const string LoggerNameParam = "loggerName";
    }
}

Exercising the Log

public partial class HomeController : Controller
{
	private readonly IMappingService _mappingService;
	private readonly ILog _log;
	private readonly IMusicService _musicService;

	public HomeController(IMusicService musicService, ILog log, IMappingService mappingService)
	{
		_mappingService = Ensure.That(mappingService, "mappingService").IsNotNull().Value;
		_log = Ensure.That(log, "log").IsNotNull().Value;
		_musicService = Ensure.That(musicService, "musicService").IsNotNull().Value;
	}
	
	public virtual ActionResult Index()
	{
		_log.Debug("Retrieving genres");
		var genres = GetGenres().Result;
		_log.Info("Retrieved {0} music genres from the database", genres.Count);
		// ...
	}
}

public class ActionTrackerAttribute : ActionFilterAttribute
{
	private Stopwatch Watch { get; set; }
	private ILog Log { get; set; }
	private ActionExecutingContext FilterContext { get; set; }

	private string ActionName
	{
		get { return FilterContext.ActionDescriptor.ActionName; }
	}

	private string ControllerName
	{
		get { return FilterContext.ActionDescriptor.ControllerDescriptor.ControllerName; }
	}

	private Uri Url
	{
		get { return FilterContext.RequestContext.HttpContext.Request.Url; }
	}

	public override void OnActionExecuting(ActionExecutingContext filterContext)
	{
		base.OnActionExecuting(filterContext);

		try
		{
			FilterContext = filterContext;
			Log = AppLogFactory.Create<ActionTrackerAttribute>();
			Log.Trace("Executing {0}.{1}", ControllerName, ActionName);
			Watch = Stopwatch.StartNew();
		}
		catch (Exception ex)
		{
			Trace.WriteLine(ex);
		}
	}

	public override void OnResultExecuted(ResultExecutedContext filterContext)
	{
		base.OnResultExecuted(filterContext);

		try
		{
			Watch.Stop();
			Log.Info("Executed {0}.{1} for {2} in {3:##0.000} second(s)", 
				ControllerName, ActionName, Url, Watch.Elapsed.TotalSeconds);
		}
		catch (Exception ex)
		{
			Trace.WriteLine(ex);
		}
	}
}

Troubleshooting Failed Logging

public class LogManagement
{
	public static AsyncTargetWrapper GetAsyncDbWrapperTarget()
	{
		var target = (AsyncTargetWrapper)LogManager.Configuration
			.FindTargetByName("asyncDbWrapperTarget");
		return target;
	}
}

Evaluating Async Logging

public virtual ActionResult BatchTest()
{
	var sw = Stopwatch.StartNew();
	const int count = 10000;
	for (var i = 0; i < count; i++)
	{
		_log.Trace("Testing {0}", i);
	}
	sw.Stop();
	var msg = string.Format("{0} log invokes in {1:##0.000} seconds", count, 
		sw.Elapsed.TotalSeconds);
	_log.Info(msg);

	return new ContentResult { Content = msg };
}

Evaluating Log Queries

Preparing for Deployment

<nlog xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xdt:Transform="SetAttributes"
        throwExceptions="false" internalLogLevel="Warn" 
		internalLogFile="${basedir}/NlogInternal.log">
    <rules>
       <!-- Levels: Off, Trace, Debug, Info, Warn, Error, Fatal -->
       <logger name="*" minlevel="Info" writeTo="asyncDbWrapperTarget" 
	      xdt:Transform="SetAttributes" xdt:Locator="Match(name)" />
    </rules>
</nlog>

Some Queries

SELECT *
FROM LogEvent WITH (NOLOCK)
WHERE PartitionKey = (
		SELECT DATEPART(weekday, getdate())
		)
ORDER BY logid DESC;

SELECT *
FROM LogEvent WITH (NOLOCK)
WHERE eventlevel IN (
		'Error'
		,'Warn'
		)
	AND DATEDIFF(hh, LogDate, GETDATE()) <= 2
ORDER BY logid DESC;

SELECT cast(logdate AS DATE) [Day]
	,url
	,count(*) ErrorCount
FROM LogEvent WITH (NOLOCK)
WHERE eventlevel = 'Error'
	AND len(url) > 0
GROUP BY cast(logdate AS DATE)
	,url
ORDER BY Day DESC
	,Url;

SELECT LoggerName
	,count(*) AS ErrorCount
FROM LogEvent WITH (NOLOCK)
WHERE EventLevel = 'Error'
GROUP BY LoggerName
ORDER BY count(*) DESC;

SELECT *
FROM LogEvent WITH (NOLOCK)
WHERE PartitionKey = (
		SELECT DATEPART(weekday, getdate())
		)
	AND eventlevel = 'Error'
	AND LoggerName IN ('NLogSql.Web.Infrastructure.ErrorHandling.IErrorReporter')
ORDER BY logid DESC;

Future Enhancements / Considerations

• Web view to read, search, filter log maybe with some SignalR goodness
• AppId type column if logging from multiple apps w/o desire for multiple log databases
• Possibly a separate error table that the log table could link to for errors with the full error report split up

The Code

Reference Datasource

<referenceData>
	<refTable name="CONTACT_TYPE" alias="ContactType" default="Person">
		<record CONTACT_TYPE_ID="1" CONTACT_TYPE_NAME="Company" RANK="2">
			<langs field="CONTACT_TYPE_NAME">
				<lang name="en">Company</lang>
				<lang name="de">Gesellschaft</lang>
				<lang name="es">Empresa</lang>
				<lang name="zh-CN">公司</lang>
				<lang name="fr">Société</lang>
			</langs>
		</record>
		<record CONTACT_TYPE_ID="2" CONTACT_TYPE_NAME="Person" RANK="1">
			<langs field="CONTACT_TYPE_NAME">
				<lang name="en">Person</lang>
				<lang name="de">Person</lang>
				<lang name="es">Persona</lang>
				<lang name="zh-CN">人</lang>
				<lang name="fr">Personne</lang>
			</langs>
		</record>
	</refTable>
</referenceData>

Schema Metadata and Parsing

RefDataResources.tt

const string ReferenceData = "ReferenceData";

private SchemaMetadata LoadSchema()
{
	var loader = new SchemaReader(Host);
	var schema = loader.Load(SchemaReader.LoadOption.ReferenceData);
	return schema;
}

private void GenerateResourceFiles(SchemaMetadata schema, Manager manager, 
	DirectoryInfo t4DirInfo)
{
	var distinctLanguages = schema.ReferenceData.DistinctLanguages;
	foreach (var lang in distinctLanguages)
	{
		var resxNameNoExt = ("en" != lang) ? ReferenceData + "." + lang : ReferenceData;
		var resxName = resxNameNoExt + ".resx";
		manager.StartNewFile(resxName);

		var resxFilename = Path.Combine(t4DirInfo.FullName, resxName);
		// use .net's ResXResourceWriter so we don't have to worry about the XML format
		using (ResXResourceWriter  resx = new ResXResourceWriter(resxFilename))
		{
			var strings = schema.ReferenceData.StringsForLanguage(lang);

			foreach (var warn in schema.Warnings)
			{
				base.Warning(warn);
			}

			foreach (var de in strings)
			{
				try 
				{
					resx.AddResource(de.Key, de.Value);
				}
				catch (Exception ex)
				{
					base.Warning(ex.ToString());
				}
			}

			resx.Generate();
			resx.Close();
		}

		// we've written the file but outside the process of T4. 
		// In order to get the file to automatically added as a new output file 
		// underneath the t4 file, we must write the generated content to output stream
		Write(File.ReadAllText(resxFilename));

		manager.EndBlock();
		
	} // end for each lang loop
}

private void SetCustomToolOnMainResourceFile(DirectoryInfo t4DirInfo)
{
	// WARNING: You are entering the dark land of EnvDTE COM. You've been warned
	var hostServiceProvider = (IServiceProvider) Host;
	var dte = (EnvDTE.DTE) hostServiceProvider.GetService(typeof(EnvDTE.DTE));
	var filename = Path.Combine(t4DirInfo.FullName, "ReferenceData.resx");
	var projectItem = dte.Solution.FindProjectItem(filename);
	projectItem.Properties.Item("CustomTool").Value = "PublicResXFileCodeGenerator";
	projectItem.Properties.Item("CustomToolNamespace").Value = "App.Domain";
	var projItemObj = (VSProjectItem)projectItem.Object;
	projItemObj.RunCustomTool();
}

Enums.tt

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated from a template.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using JetBrains.Annotations;

namespace App.Domain
{
	public partial class ContactType : Enumeration
	{		
		/// <summary>
		/// ContactType of Company (ID: 1, "Company")
		/// </summary>
		[GeneratedCode("TextTemplatingFileGenerator", "11")]
		public static readonly ContactType Company 
			= new ContactType( 1, ReferenceData.ContactType_Company );

		/// <summary>
		/// ContactType of Person (ID: 2, "Person")
		/// </summary>
		[GeneratedCode("TextTemplatingFileGenerator", "11")]
		public static readonly ContactType Person 
			= new ContactType( 2, ReferenceData.ContactType_Person );


		[ExcludeFromCodeCoverage, DebuggerNonUserCode, GeneratedCode("TextTemplatingFileGenerator", "11")]
		private ContactType( int value, string displayName ) : base( value, displayName ) { }

		[ExcludeFromCodeCoverage, DebuggerNonUserCode, GeneratedCode("TextTemplatingFileGenerator", "11")]
		public static ContactType Default()
		{
			return Person;
		}

		[UsedImplicitly, Obsolete("ORM runtime use only")]
		[ExcludeFromCodeCoverage, DebuggerNonUserCode, GeneratedCode("TextTemplatingFileGenerator", "11")]
		private ContactType() { }
	}
}

Testing It Out

using System.Globalization;
using NUnit.Framework;
using System.Threading;

namespace App.Domain.Tests
{
    [TestFixture, Category("Unit")]
    public class ReferenceDataI18NTests
    {
        [Test]
        public void English_To_French_Strings_Change()
        {
            var orig = Thread.CurrentThread.CurrentUICulture;
            Assert.AreEqual("Company", ReferenceData.ContactType_Company);
            Thread.CurrentThread.CurrentUICulture = new CultureInfo("fr-FR");
            Assert.AreEqual("Société", ReferenceData.ContactType_Company);
            Thread.CurrentThread.CurrentUICulture = orig;
        }

        [Test]
        public void English_To_Spanish_Strings_Change()
        {
            var orig = Thread.CurrentThread.CurrentUICulture;
            Assert.AreEqual("Company", ReferenceData.ContactType_Company);
            Thread.CurrentThread.CurrentUICulture = new CultureInfo("es");
            Assert.AreEqual("Empresa", ReferenceData.ContactType_Company);
            Thread.CurrentThread.CurrentUICulture = orig;
        }

        [Test]
        public void English_To_German_Strings_Change()
        {
            var orig = Thread.CurrentThread.CurrentUICulture;
            Assert.AreEqual("Company", ReferenceData.ContactType_Company);
            Thread.CurrentThread.CurrentUICulture = new CultureInfo("de");
            Assert.AreEqual("Gesellschaft", ReferenceData.ContactType_Company);
            Thread.CurrentThread.CurrentUICulture = orig;
        }

        [Test]
        public void English_To_Chinese_Taiwan_Strings_Change()
        {
            var orig = Thread.CurrentThread.CurrentUICulture;
            Assert.AreEqual("Company", ReferenceData.ContactType_Company);
            Thread.CurrentThread.CurrentUICulture = new CultureInfo("zh-CN");
            Assert.AreEqual("公司", ReferenceData.ContactType_Company);
            Thread.CurrentThread.CurrentUICulture = orig;
        }
    }
}

using System.Linq;
using FluentAssertions;
using NUnit.Framework;

namespace App.Domain.Tests
{
    [TestFixture(
        Description = "Tests base Enumeration class via PhoneType concrete class")]
    [Category("Unit")]
    public class EnumerationTests
    {
        [Test]
        public void FromValue_Matches_Type_Value()
        {
            var fromValue = Enumeration.FromValue<PhoneType>(PhoneType.Cell.Value);
            Assert.AreEqual(PhoneType.Cell, fromValue);

            fromValue = Enumeration.FromValue<PhoneType>(PhoneType.Voice.Value);
            Assert.AreEqual(PhoneType.Voice, fromValue);
        }

        [Test]
        public void FromDisplayName_Matches_Type_Name()
        {
            var fromName = Enumeration.FromDisplayName<PhoneType>(PhoneType.Fax.DisplayName);
            Assert.AreEqual(PhoneType.Fax.DisplayName, fromName.DisplayName);

            fromName = Enumeration.FromDisplayName<PhoneType>(PhoneType.Pager.DisplayName);
            Assert.AreEqual(PhoneType.Pager.DisplayName, fromName.DisplayName);
        }

        [Test]
        public void ToString_Equals_DisplayName()
        {
            Assert.AreEqual(PhoneType.Cell.DisplayName, PhoneType.Cell.ToString());
        }

        [Test]
        public void Absolute_Difference_Math_Is_Correct()
        {
            var diff = Enumeration.AbsoluteDifference(PhoneType.Cell, PhoneType.Voice);
            Assert.AreEqual(3, diff);
            diff = Enumeration.AbsoluteDifference(PhoneType.Voice, PhoneType.Cell);
            Assert.AreEqual(3, diff);
        }

        [Test]
        public void GetAll_Contains_Expected_Members()
        {
            var all = Enumeration.GetAll<PhoneType>().ToList();
            Assert.AreEqual(4, all.Count);
            Assert.NotNull(all.FirstOrDefault(x => x == PhoneType.Cell));
            Assert.NotNull(all.FirstOrDefault(x => x == PhoneType.Fax));
            Assert.NotNull(all.FirstOrDefault(x => x == PhoneType.Pager));
            Assert.NotNull(all.FirstOrDefault(x => x == PhoneType.Voice));
            Assert.NotNull(all.FirstOrDefault(x => x == PhoneType.Default()));
        }

        [Test]
        public void Equality_Two_Are_Equal()
        {
            var one = PhoneType.Cell;
            var two = PhoneType.Cell;
            Assert.AreEqual(one, two);
            Assert.True(one == two);
        }

        [Test]
        public void Equality_Two_Different_Not_Equal()
        {
            var one = PhoneType.Cell;
            var two = PhoneType.Voice;
            Assert.AreNotEqual(one, two);
            Assert.True(one != two);
        }

        [Test]
        public void Equality_One_Null_Not_Equal()
        {
            PhoneType.Cell.Equals(null).Should().BeFalse();
        }

        [Test]
        public void Compare_To_Succeeds()
        {
            var diff = PhoneType.Cell.CompareTo(PhoneType.Fax);
            diff.Should().Be(1);

            diff = PhoneType.Fax.CompareTo(PhoneType.Cell);
            diff.Should().Be(-1);
        }

        [Test]
        public void Invalid_Parse_Number_Throws()
        {
            Assert.That(() => { Enumeration.FromValue<PhoneType>(999); }, Throws.Exception);
        }
    }
}

There's More

• For simplicity some complexity was removed from the T4. This includes reference tables that have foreign keys to other reference tables (including strongly typed properties and ctor params) and resource strings for fields other than the primary display name.
• One thing that bothered me initially with this was it felt a bit like introducing Data Driven Design into an otherwise Domain Driven Design paradigm. This was offset somewhat with aliases for table names (or a naming convention pattern) and reference tables could be selectively ignored in code generation through the use of attributes or other means. Another possible issue is class name conflicts with existing types in the domain project; this could be offset with a different namespace and/or naming convention.
• Many apps load reference data from the database each time it's needed, or load it once and cache it until invalidated. Other apps may let users edit select sets of reference type data. If the data is likely to change during an app session or if users can edit some of it, chances are it isn't truly reference data to begin with. With a good deployment process, any compiled reference data info can be easily deployed and various reference data is likely to be tied to app business and presentation rules anyway.
• Several of the enum classes would have corresponding partial classes for extended logic. For this reason, various code generation type attributes were places directly on generated members and not on the class itself, per various guidance.
• An example use in the domain would be a ContactType enum property on a Contact object and requiring different fields when attempting to add contacts of different types. This app uses this component strategy in Fluent NHibernate to map the data from the database reference table into the domain class. For the UI side, Enumeration.GetAllMembers can be used along with AutoMapper to get the id and text values into simple ViewModel types for select lists.

Code

Mapper.CreateMap<Contact, AddressBookDetailsModel>()
	.ForMember( d => d.PhoneNumbers, o => o.MapFrom( s => s.Phones ) );

Mapper.CreateMap<Contact, AddressBookDetailsModel>()
	.ForMember( d => d.PhoneNumbers).MapFrom( s=> s.Phones );				

public static class AutoMapperExtensions
{
	public static IMappingExpression<TSource, TDestination> MapItem<TSource, TDestination, TMember>(
		this IMappingExpression<TSource, TDestination> target,
		Expression<Func<TDestination, object>> destinationMember,
		Expression<Func<TSource, TMember>> sourceMember )
	{
		return target.ForMember( destinationMember, opt => opt.MapFrom( sourceMember ) );
	}
}

				
Mapper.CreateMap<Contact, AddressBookDetailsModel>()
	.MapItem( d => d.PhoneNumbers, s=> s.Phones );				

		
public static class AutoMapperExtensions
{
	public static IMappingExpression<TSource, TDestination> Ignore<TSource, TDestination>(
		this IMappingExpression<TSource, TDestination> target,
		Expression<Func<TDestination, object>> destinationMember)
	{
		return target.ForMember( destinationMember, opt => opt.Ignore() );
	}
	
	/* other code removed for brevity */
}

To Stick with Apple or Not

Apple's New Lineup

• Price - A 256GB HD isn't large enough for me so that means the $2800 model; add in tax and AppleCare and it's up to nearly $3,500. Talk about $ticker $hock.
• Portability - After using a MacBook Air for a bit, that light, super portable form factor is hard to give up. The retina MBP is quite lighter than my MBP but it still feels heavy and large next to the Air.
• The Bleeding Edge - The icons in many third party apps look pretty bad with such an HD display. While major apps were/are updated quickly, others will take some time. I have more concerns about website images which aren't likely to be upgraded any time soon just to clean them up for HD displays at the cost of slower load times. I've also seen posts regarding plasma style image burn-in, overheating, and resolution issues in Windows to name a few.

Evaluating the Air

Initial Impressions

Connections

Weight and Size

Speed

Bootcamp Debacle

To Bootcamp or not to Bootcamp

• Phone emulators - Some mobile dev emulators such as Windows Phone wouldn't run under Parallels; the VM inside a VM Inception type problem. However I believe Fusion worked and maybe this has since been fixed in Parallels.
• Silverlight - there was at least one Silverlight runtime issue that was specific to running inside a VM.
• Compatibility, performance - some other select apps and games had problems running virtually either compatibility wise or performance wise.

Bootcamp Setup While Half Asleep

• Selected disc in Disk Utility
• File->New Disc Image From
• Chose the CD/DVD .cdr option
• Saved .cdr to my public folder
• Renamed .cdr to .iso (seriously Apple why not .iso)
• Pointed Bootcamp assistant on my Air to Win7 iso on my MBP public folder
• Copied 25% of Windows files and hung indefinitely

Setting Up For Development

Performance

Other Misc. Timings

• Windows and VS 2012 fully loaded and ready via Parallels: ~45 seconds
• git clone SignalR: < 8 seconds
• Initial SignalR build.cmd run (includes executing unit tests): under 2 mins
• Cold boot time into Mac including entering password and startup apps: < 22 seconds

MBP Comparision

The Boot Selection Screen

Putting it to Work

Heat and Fan

Battery Life

Windows

A Freak Dock Issue

Summary

param (
	$TrunkPath = "D:\Projects\MyApp\trunk"
)	

function Start-WebsitePrecompile
{    
    $logFile = (join-path $TrunkPath "\build\output\logs\BackgroundCompile.log")
    "Build log file is $logFile"
        
    $msg = @"
Starting background compile of site. Use Get-Job to check progress. 
You may go on about your merry way but may want to leave the host open until complete.
"@
    
    Write-Output $msg
    $job = Start-Job -InputObject $TrunkPath -Name MyAppPageCompile -ScriptBlock {
        # doesn't appear transcription is supported here
        $trunk = $input

        Set-Alias aspnetcompile $env:windir\Microsoft.NET\Framework\v4.0.30319\aspnet_compiler.exe
        
        # see website solution file for these values
        $virtualPath = "/web"
        $physicalPath = (join-path $trunk "\web")
        $compilePath = $trunk + "\PrecompiledWeb\web"
        aspnetcompile -v $virtualPath -p $physicalPath -f -errorstack $compilePath        
    }
    
    # output details
    $job    
   
    Register-ObjectEvent $job -MessageData $logFile -EventName StateChanged `
        -SourceIdentifier Compile.JobStateChanged `
        -Action {            
            $logFile = $event.MessageData
            Set-Content -Force -Path $logFile `
            	-Value $(Receive-Job -Id $($Sender.Id) -Keep:$KeepJob | Out-String)
            #$eventSubscriber | UnregisterEvent
            Unregister-event -SourceIdentifier Compile.JobStateChanged
            $eventSubscriber.Action | Remove-Job
            Write-Host "Job # $($sender.Id) ($($sender.Name)) complete. Details at $logFile." 
        }
}

Some Notes

• Everything inside the job's script block will be executed in another PowerShell process; anything from outside the script block that needs to be used inside must be passed into the script block with the InputObject parameter ($input). While this might be obvious it does mean potential refactoring considerations.
• It didn't appear transcription was supported inside the script block which was disappointing.
• I half expected that Start-Job would provide a parameter for a block to call when the job was complete. Register-ObjectEvent works but it's a bit verbose and isn't even mentioned in many posts talking about job management.
• Like the job script block, the event handler action script block cannot refer to anything from the outside other than anything passed into the block with the MessageData parameter and automatic variables such as $event, $eventSubscriber, $sender, $sourceEventArgs, and $sourceArgs.
• I went through some trial and error in getting the output from the job in the completed event. The code on line 36 and 37 worked fine but it was not the most obvious initial syntax.
• There are a couple of ways to unregister events such as line 38, but I found that when I called the function again I received an error that the event was already subscribed to, so it was clear the unregistration was not working for some reason. The current code is working but similar code did not work previously. I dunno man, gremlins.
• Event handler cleanup strikes me as a bit odd and this Register-TemporaryEvent script is worth a look.

In Action

Calls to Record Activity Progress

function New-Build() # params omitted, body simplified for brevity
{	
    Start-Activity "Performing a new build"
	$percentComplete = 0
	
	Log-Progress "Creating code" -PercentComplete $percentComplete		
	New-CodeGen
	$percentComplete += 33
	
	Log-Progress "Creating config" -PercentComplete $percentComplete		
	New-Config
	$percentComplete += 33
	
	Log-Progress "Creating DB" -PercentComplete $percentComplete
	New-DB -common
	
	Stop-Activity
}

function New-CodeGen ([bool]$buildStatusUpdate = $true)
{	
    Start-Activity "Running CodeGen with NAnt"
	# ... real work done here ...
	Stop-Activity
}

# ...

Starting an Activity

$_activityStack = new-object Collections.Stack

function Start-Activity([string]$activity = $(throw "activity is required"))
{
    Write-Output "Activity starting: $activity"
    
    $act = new-object PSObject
    $act | add-member -membertype NoteProperty -name "StartTime" -value $(get-date)
	$act | add-member -membertype NoteProperty -name "Name" -value $activity    
	$act | add-member -membertype NoteProperty -name "TotalSeconds" -Value 0
    $act | add-member -membertype NoteProperty -name "EstimatedSeconds" `
		-Value (Get-ActivityEstimatedSeconds $activity)
    
    $_activityStack.Push($act)
    Log-Progress $activity
}

Stopping an Activity

function Stop-Activity
{
    $id = $_activityStack.Count
    $act = $_activityStack.Pop()
    $ts = $(get-date) - $act.StartTime
	$act.TotalSeconds = $ts.TotalSeconds
    $time = ""
    
    if ($ts.TotalMinutes -ge 1) { $time = "{0:##.00} minute(s)" -f $ts.TotalMinutes }
    else { $time = "{0:##.00} second(s)" -f $ts.TotalSeconds }
    
	# TODO: add in $act.EstimatedSeconds if > 0
    $status = ("'{0}' complete in {1}" -f $act.Name, $time)
    Write-Progress -Activity $act.Name -Status $status -Completed -Id $id
    Write-Output $status
	
	Write-Stats $act 
}

Writing Activity Stats

function Write-Stats ($act = $(throw "activity is required"))
{	
	# initialize an array to hold recent stats for this activity
 	$recent=@()
	$recent += $act
	$statsFile = Get-StatsFilename
	$maxKeep = 50 # across all activities; several different, want a few of each
	
	if (Test-Path $statsFile)
	{
	 	# get a list of the $maxKeep-1 most recent stats and add each path to the $recent array
		# | Where-Object {$_.Name -eq $act.Name}
	 	Import-CSV $statsFile | Sort StartTime -Descending `
			| Select -Last ($maxKeep -1) | foreach {$recent+=$_}
		# remove the file as we have the data in memory and want to re-write w/top item # and desc time sort
		Remove-Item $statsFile -force
	}
	
	$recent | select StartTime, Name, TotalSeconds | Export-Csv $statsFile -NoTypeInformation
}

Getting Activity Estimated Time

function Get-ActivityEstimatedSeconds([string]$activityName)
{
    $statsFile = (Get-StatsFilename)
    $avg = -1
    
    if (Test-Path $statsFile) 
    {
        $totalSeconds=@()
        Import-CSV $statsFile | Where-Object {$_.Name -eq $activityName} `
			| foreach {$totalSeconds+=$_.TotalSeconds}
        $m = $totalSeconds | measure-object -ave
        $avg = $m.Average
    }	
	
    return $avg
}

Misc. Functions

function Log-Progress([string]$msg, [int]$percentComplete = 0)
{
    Write-Output $msg
    $act = $_activityStack.Peek()
    $id = $_activityStack.Count
	# the problem with -SecondsRemaining is it won't auto update w/timer or anything 
	# so it will be helpful at first and then quickly misleading
	
	$actName = $act.Name
	
	if ($act.EstimatedSeconds -ge 0)
	{
		$estFinish = $act.StartTime.AddSeconds($act.EstimatedSeconds)
		$actName += " - Est. Finish @ " + $estFinish.ToString("hh:mm:ss tt")
	}
	
    Write-Progress -Activity $actName -Status $msg -PercentComplete $percentComplete `
        -Id $id #-SecondsRemaining $act.EstimatedSeconds
}

function Get-StatsFilename
{
	# considered a separate file per activity but we can filter out of one file
	# too much clutter w/sep and would have to build a safe filename with activity name
	$file = (Join-Path (Get-StatsFilePath) "Stats.csv")
	return $file
}

function Get-StatsFilePath
{
	$path = (join-path $env:LOCALAPPDATA "MyCompany\MyApp\build_output\stats")
	if (!(Test-Path $path)) { New-Item $path -type directory | Out-Null }
	return $path
}

In Conclusion

Changes Over Last Year's Version

• Mango upgrade - OS target upgrade from 7.0 to 7.1 and many fixes to address breaking changes
• Map view - new map view with various points of interest and directions. Points of interest are externally configured so if you have suggestions, let me know.
• Branding - logo, title, date, image and theme related changes
• Source control and hosting - switch from HG and bitbucket to git and github
• New app, not an upgrade - Due to various factors this year's version was submitted as a new app and last year's was hidden. If by chance you have last year's version installed, uninstall it first.

Potential Future Changes

• Live tile - maybe showing next session via schedule and/or favorite
• Better twitter integration - i.e. more of a native twitter client instead of mobile twitter links.
• More graceful public WiFi handling - better error message when an HTML response (from a WiFi logon page) was received instead of expected JSON. (change pending Marketplace approval in v2.2)

Overview Video