Adam Anderly

Publisher is gone. Here’s why I built PubKeep.

Thu, 01 Oct 2026 18:40:09 GMT

It started with a phone call from my mom.

Microsoft had announced it was removing Publisher from Microsoft 365, and she, my aunt, and my cousin all had years of files made in it. Newsletters, wedding programs, labels, the family photo calendar we got every Christmas. She wanted to know if I could help them get their files out before the app went away.

I had not used Publisher in years. But I knew exactly what she meant, because I had used it for our own wedding program and thank-you cards. Publisher was the tool ordinary people used to make something that came out looking finished. And it was a tool you bought once.

The more I looked, the bigger the problem got. Church offices build the weekly bulletin from last week’s .pub file. Schools have years of newsletters and certificates. Nonprofits, small businesses, the volunteer who makes the monthly newsletter. The suggested replacements are good tools, but they are subscriptions, and none of them open the files people already have. Everyone was being told to start over.

So I started building.

First, save the files

The urgent problem was the archive. If Publisher was going away, people needed a way to turn years of .pub files into something they could always open.

The first thing I built was a converter: drop a whole folder of .pub files and get exact PDFs back, page for page. My family tried it the first day. My mom’s reply was “Oh hallelujah!”

That saved the past. It didn’t help with next week’s bulletin.

Then, keep editing

A PDF only saves what you’ve already made. The real question was why Publisher users should have to stop publishing at all.

So I built PubKeep, a desktop app for Windows and Mac that opens your .pub files and keeps them editable. The same text boxes, master pages, and fold-over booklets you already use, without Publisher on the computer. No converting first, and nothing to rebuild.

It’s a one-time purchase, not a subscription. You buy it once and it keeps working. And it saves to .pubk, an open format you can always get your work out of. After watching people lose access to their own work, I wasn’t going to build another lock-in.

The people who helped build it

Before launch, more than 1,100 organizations signed up for early access, most of them churches. They opened their own bulletins and newsletters, told us what was missing, and sent the files that didn’t come through right so we could fix them.

Some of what they wrote back has stuck with me. One church secretary said she got more done in 45 minutes than she had in other programs all week. An author told us she had thousands of Publisher files from 30 years of work, and that PubKeep was better than she had dared hope for.

Launch

PubKeep went on sale September 30, the day before Microsoft pulled Publisher from Microsoft 365, with a free 7-day trial.

What’s next

Support for the perpetual versions of Publisher ends October 13, so the next few weeks are about helping everyone who still depends on it. We keep widening what PubKeep opens, and the files people send us decide what we work on next.

If you or someone you know has a pile of .pub files, PubKeep is at pubkeep.com, and the free trial needs no card.

And if your mom calls about her Publisher files, now you know what to tell her.

Cross-Cutting Concerns with MediatR Pipeline Behaviors

Thu, 12 Dec 2019 16:41:14 GMT

I’ve recently been exploring MediatR Pipeline Behaviors and cross-cutting concerns (logging, validation, security, transactions) but also wanted to tackle some performance and resilience scenarios that may not always apply to every request/command (retry, fallback and caching).

Here are some gists that tackle these concerns:

Caching Behavior (using ASP.NET Core IDistributedCache):

For caching, I’m using a separately defined CachePolicy similar to a FluentValidation Validator class.

public class CacheService : ICache
	{
		private readonly string _keyPrefix;
		private readonly IDistributedCache _cache;
		private readonly IConfiguration _config;

		public CacheService(IDistributedCache cache, IConfiguration config)
		{
			_cache = cache;
			_config = config;
			var keyPrefix = _config["CacheKeyPrefix"];
			_keyPrefix = keyPrefix ?? typeof(CacheService).FullName;
		}

		public string GetCacheKey(string key)
		{
			return MakeKey(key);
		}

		public async Task<T> GetAsync<T>(string key, CancellationToken token = default)
		{
			return await GetInternalAsync<T>(key, token);
		}

		public async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> factory, CancellationToken token = default)
		{
			return await GetOrCreateInternalAsync<T>(key, null, null, null, factory, token);
		}

		public async Task<T> GetOrCreateAsync<T>(string key, TimeSpan slidingExpiration, Func<Task<T>> factory, CancellationToken token = default)
		{
			return await GetOrCreateInternalAsync<T>(key, slidingExpiration, null, null, factory, token);
		}

		public async Task<T> GetOrCreateAsync<T>(string key, DateTime absoluteExpiration, Func<Task<T>> factory, CancellationToken token = default)
		{
			return await GetOrCreateInternalAsync<T>(key, null, absoluteExpiration, null, factory, token);
		}

		public async Task<T> GetOrCreateAsync<T>(string key, TimeSpan slidingExpiration, DateTime absoluteExpiration, Func<Task<T>> factory, CancellationToken token = default)
		{
			return await GetOrCreateInternalAsync<T>(key, slidingExpiration, absoluteExpiration, null, factory, token);
		}

		public async Task<T> GetOrCreateAsync<T>(string key, TimeSpan slidingExpiration, TimeSpan absoluteExpirationRelativeToNow, Func<Task<T>> factory, CancellationToken token = default)
		{
			return await GetOrCreateInternalAsync<T>(key, slidingExpiration, null, absoluteExpirationRelativeToNow, factory, token);
		}

		public async Task<T> GetOrCreateAsync<T>(string key, TimeSpan? slidingExpiration, DateTime? absoluteExpiration, TimeSpan? absoluteExpirationRelativeToNow, Func<Task<T>> factory, CancellationToken token = default)
		{
			return await GetOrCreateInternalAsync<T>(key, slidingExpiration, absoluteExpiration, absoluteExpirationRelativeToNow, factory, token);
		}

		public async Task SetAsync<T>(string key, T value, CancellationToken token = default)
		{
			await SetInternalAsync(key, value, null, null, null, token);
		}

		public async Task SetAsync<T>(string key, T value, DateTime absoluteExpiration,
			CancellationToken token = default)
		{
			await SetInternalAsync(key, value, null, absoluteExpiration, null, token);
		}

		public async Task SetAsync<T>(string key, T value, TimeSpan slidingExpiration,
			CancellationToken token = default)
		{
			await SetInternalAsync(key, value, slidingExpiration, null, null, token);
		}

		public async Task SetAsync<T>(string key, T value, TimeSpan? slidingExpiration, DateTime? absoluteExpiration,
			CancellationToken token = default)
		{
			await SetInternalAsync(key, value, slidingExpiration, absoluteExpiration, null, token);
		}

		public async Task SetAsync<T>(string key, T value, TimeSpan? slidingExpiration, TimeSpan? absoluteExpirationRelativeToNow,
			CancellationToken token = default)
		{
			await SetInternalAsync(key, value, slidingExpiration, null, absoluteExpirationRelativeToNow, token);
		}

		public async Task SetAsync<T>(string key, T value, TimeSpan? slidingExpiration, DateTime? absoluteExpiration,
			TimeSpan? absoluteExpirationRelativeToNow, CancellationToken token = default)
		{
			await SetInternalAsync(key, value, slidingExpiration, absoluteExpiration, absoluteExpirationRelativeToNow, token);
		}

		public async Task RefreshAsync(string key, CancellationToken token = default)
		{
			await _cache.RefreshAsync(key, token);
		}

		public async Task RemoveAsync(string key, CancellationToken token = default)
		{
			await _cache.RemoveAsync(key, token);
		}

		private string MakeKey(string key)
		{
			return $"{(string.IsNullOrWhiteSpace(_keyPrefix) ? "" : _keyPrefix + ":")}{key}";
		}

		private async Task<T> GetInternalAsync<T>(string key, CancellationToken token = default)
		{
			return await _cache.GetAsync<T>(MakeKey(key), token);
		}

		private async Task<T> GetOrCreateInternalAsync<T>(string key, TimeSpan? slidingExpiration, DateTime? absoluteExpiration, TimeSpan? absoluteExpirationRelativeToNow, Func<Task<T>> factory, CancellationToken token = default)
		{
			var value = await GetInternalAsync<T>(key, token);

			if (value != null) return value;

			value = await factory();

			if (value != null)
			{
				await SetInternalAsync<T>(key, value, slidingExpiration, absoluteExpiration, absoluteExpirationRelativeToNow, token);
			}

			return value;
		}

		private async Task SetInternalAsync<T>(string key, T value, TimeSpan? slidingExpiration, DateTime? absoluteExpiration, TimeSpan? absoluteExpirationRelativeToNow,
			CancellationToken token = default)
		{
			var cacheEntryOptions = new DistributedCacheEntryOptions();
			if (slidingExpiration.HasValue)
			{
				cacheEntryOptions.SlidingExpiration = slidingExpiration.Value;
			}

			if (absoluteExpiration.HasValue)
			{
				cacheEntryOptions.AbsoluteExpiration = absoluteExpiration.Value;
			}

			if (absoluteExpirationRelativeToNow.HasValue)
			{
				cacheEntryOptions.AbsoluteExpirationRelativeToNow = absoluteExpirationRelativeToNow.Value;
			}

			if (!slidingExpiration.HasValue && !absoluteExpiration.HasValue && !absoluteExpirationRelativeToNow.HasValue)
			{
				cacheEntryOptions.SetSlidingExpiration(TimeSpan.FromSeconds(30));
				cacheEntryOptions.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5);
				//cacheEntryOptions.SetAbsoluteExpiration(DateTime.UtcNow.AddMinutes(5));
			}

			await _cache.SetAsync<T>(MakeKey(key), value, cacheEntryOptions, token);
		}

	}

/// <summary>
/// MediatR Caching Pipeline Behavior
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
public class CachingBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly IEnumerable<ICachePolicy<TRequest, TResponse>> _cachePolicies;
    // ICache is a helper wrapper over IDistributedCache that adds some read-through cache methods, etc.
    private readonly ICache _cache;
    private readonly ILogger<CachingBehavior<TRequest, TResponse>> _logger;

    public CachingBehavior(ICache cache, ILogger<CachingBehavior<TRequest, TResponse>> logger, IEnumerable<ICachePolicy<TRequest, TResponse>> cachePolicies)
    {
        _cache = cache;
        _logger = logger;
        _cachePolicies = cachePolicies;
    }

    public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
    {
        var cachePolicy = _cachePolicies.FirstOrDefault();
        if (cachePolicy == null)
        {
            // No cache policy found, so just continue through the pipeline
            return await next();
        }
        var cacheKey = cachePolicy.GetCacheKey(request);
        var cachedResponse = await _cache.GetAsync<TResponse>(cacheKey, cancellationToken);
        if (cachedResponse != null)
        {
            _logger.LogDebug($"Response retrieved {typeof(TRequest).FullName} from cache. CacheKey: {cacheKey}");
            return cachedResponse;
        }

        var response = await next();
        _logger.LogDebug($"Caching response for {typeof(TRequest).FullName} with cache key: {cacheKey}");

        await _cache.SetAsync(cacheKey, response, cachePolicy.SlidingExpiration, cachePolicy.AbsoluteExpiration, cachePolicy.AbsoluteExpirationRelativeToNow, cancellationToken);
        return response;
    }
 }

public class Details
{
  
    // Query definition
    public class Query : IRequest<Models.Customer>
    {
        [FromRoute]
        public string CustomerNumber { get; set; }
    }
    
    // Simply defining a CachePolicy for ICachePolicy<TRequest,TResponse> sets up caching
    // similar to setting up a FluentValidation Validator that inherits from AbstractValidator<TRequest>.
    // This could be in the same file or in a separate file, but doesn't clutter up the "Handler".
    public class CachePolicy : ICachePolicy<Query, Models.Customer>
    {
        // Optionally, change defaults
        public TimeSpan? AbsoluteExpirationRelativeToNow => TimeSpan.FromMinutes(10);
        public TimeSpan? SlidingExpiration => TimeSpan.FromMinutes(1);

        // Optionally, provide a different implementation here. By default the CacheKey will be in the following format:
        //     Query{CustomerNumber:001425}
        public string GetCacheKey(Query query)
        {
            return $"Customers.{query.CustomerNumber}";
        }
    }
    
    // Query Handler
    public class Handler : IRequestHandler<Query, Models.Customer>
    {
        private readonly CustomerContext _db;
        private readonly IConfigurationProvider _configuration;

        public Handler(CustomerContext db, IConfigurationProvider configuration)
        {
            _db = db;
            _configuration = configuration;
        }

        public async Task<Models.Customer> Handle(Query message, CancellationToken token)
        {
            return await _db.Customers.Where(c => c.Number == message.CustomerNumber)
                .ProjectTo<Models.Customer>(_configuration)
                .FirstOrDefaultAsync(token);
        }
    }
    
   }
}

public interface ICache
	{
		string GetCacheKey(string key);

		/// <summary>Gets a value with the given key.</summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation, containing the located value or null.</returns>
		Task<T> GetAsync<T>(string key, CancellationToken token = default);

		Task<T> GetOrCreateAsync<T>(
			string key,
			Func<Task<T>> factory,
			CancellationToken token = default);

		Task<T> GetOrCreateAsync<T>(
			string key,
			TimeSpan slidingExpiration,
			Func<Task<T>> factory,
			CancellationToken token = default);

		Task<T> GetOrCreateAsync<T>(
			string key,
			DateTime absoluteExpiration,
			Func<Task<T>> factory,
			CancellationToken token = default);

		Task<T> GetOrCreateAsync<T>(
			string key,
			TimeSpan slidingExpiration,
			DateTime absoluteExpiration,
			Func<Task<T>> factory,
			CancellationToken token = default);

		Task<T> GetOrCreateAsync<T>(
			string key,
			TimeSpan? slidingExpiration,
			DateTime? absoluteExpiration,
			TimeSpan? absoluteExpirationRelativeToNow,
			Func<Task<T>> factory,
			CancellationToken token = default);

		/// <summary>Sets the value with the given key.</summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="value">The value to set in the cache.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
		Task SetAsync<T>(
			string key,
			T value,
			CancellationToken token = default);

		/// <summary>Sets the value with the given key.</summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="value">The value to set in the cache.</param>
		/// <param name="absoluteExpiration">The cache options for the value.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
		Task SetAsync<T>(
			string key,
			T value,
			DateTime absoluteExpiration,
			CancellationToken token = default);

		/// <summary>Sets the value with the given key.</summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="value">The value to set in the cache.</param>
		/// <param name="slidingExpiration">The cache options for the value.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
		Task SetAsync<T>(
			string key,
			T value,
			TimeSpan slidingExpiration,
			CancellationToken token = default);

		/// <summary>Sets the value with the given key.</summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="value">The value to set in the cache.</param>
		/// <param name="slidingExpiration">The cache options for the value.</param>
		/// <param name="absoluteExpiration">The cache options for the value.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
		Task SetAsync<T>(
			string key,
			T value,
			TimeSpan? slidingExpiration,
			DateTime? absoluteExpiration,
			CancellationToken token = default);

		/// <summary>Sets the value with the given key.</summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="value">The value to set in the cache.</param>
		/// <param name="slidingExpiration">The cache options for the value.</param>
		/// <param name="absoluteExpirationRelativeToNow">The cache options for the value.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
		Task SetAsync<T>(
			string key,
			T value,
			TimeSpan? slidingExpiration,
			TimeSpan? absoluteExpirationRelativeToNow,
			CancellationToken token = default);

		/// <summary>Sets the value with the given key.</summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="value">The value to set in the cache.</param>
		/// <param name="slidingExpiration">The cache options for the value.</param>
		/// <param name="absoluteExpiration">The cache options for the value.</param>
		/// <param name="absoluteExpirationRelativeToNow">The cache options for the value.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
		Task SetAsync<T>(
			string key,
			T value,
			TimeSpan? slidingExpiration,
			DateTime? absoluteExpiration,
			TimeSpan? absoluteExpirationRelativeToNow,
			CancellationToken token = default);

		/// <summary>
		/// Refreshes a value in the cache based on its key, resetting its sliding expiration timeout (if any).
		/// </summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
		Task RefreshAsync(string key, CancellationToken token = default);

		/// <summary>Removes the value with the given key.</summary>
		/// <param name="key">A string identifying the requested value.</param>
		/// <param name="token">Optional. The <see cref="T:System.Threading.CancellationToken" /> used to propagate notifications that the operation should be canceled.</param>
		/// <returns>The <see cref="T:System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
		Task RemoveAsync(string key, CancellationToken token = default);
	}

// Using C# 8.0 to provide a default interface implementation.
// Optionally, could move this to an AbstractCachingPolicy like AbstractValidator.
public interface ICachePolicy<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    DateTime? AbsoluteExpiration => null;
    TimeSpan? AbsoluteExpirationRelativeToNow => TimeSpan.FromMinutes(5);
    TimeSpan? SlidingExpiration => TimeSpan.FromSeconds(30);

    string GetCacheKey(TRequest request)
    {
        var r = new {request};
        var props = r.request.GetType().GetProperties().Select(pi => $"{pi.Name}:{pi.GetValue(r.request, null)}");
        return $"{typeof(TRequest).FullName}{{{String.Join(",", props)}}}";
    }
}

View MediatR Caching Pipeline Behavior on GitHub.

Fallback Behavior (using Polly):

For Fallback and Retry behavior, I’m using separate interfaces IFallbackHandler and IRetryableRequest to get the behavior.

public class Handler : IRequestHandler<Query, Customer>, IFallbackHandler<Query, Customer>
{
    private readonly ICustomerRepository _db;
    private readonly ICustomerRepository<SourceSystem.Secondary> _db2;
    private readonly IConfigurationProvider _configuration;

    public Handler(ICustomerRepository db, ICustomerRepository<SourceSystem.Secondary> db2, IConfigurationProvider configuration)
    {
        _db = db;
        _db2 = db2;
        _configuration = configuration;
    }

    public async Task<Customer> Handle(Query message, CancellationToken token)
    {
        return await _db.GetCustomerByNumberAsync(message.CustomerNumber);
    }

    // HandleFallback method from IFallbackHandler<TRequest, TResponse> interface.
    // This method will get called if my Handle method fails.
    public async Task<Customer> HandleFallback(Query message, CancellationToken token)
    {
        return await _db2.GetCustomerByNumberAsync(message.CustomerNumber);
    }
}

/// <summary>
/// MediatR Fallback Pipeline Behavior
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
public class FallbackBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    private readonly IEnumerable<IFallbackHandler<TRequest, TResponse>> _fallbackHandlers;
    private readonly ILogger<FallbackBehavior<TRequest, TResponse>> _logger;

    public FallbackBehavior(IEnumerable<IFallbackHandler<TRequest, TResponse>> fallbackHandlers, ILogger<FallbackBehavior<TRequest, TResponse>> logger)
    {
        _fallbackHandlers = fallbackHandlers;
        _logger = logger;
    }

    public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
    {
        var fallbackHandler = _fallbackHandlers.FirstOrDefault();
        if (fallbackHandler == null)
        {
            // No fallback handler found, continue through pipeline
            return await next();
        }

        var fallbackPolicy = Policy<TResponse>
            .Handle<Exception>()
            .FallbackAsync(async (cancellationToken) =>
            {
                _logger.LogDebug($"Initial handler failed. Falling back to `{fallbackHandler.GetType().FullName}@HandleFallback`");
                return await fallbackHandler.HandleFallback(request, cancellationToken)
                    .ConfigureAwait(false);
            });

        var response = await fallbackPolicy.ExecuteAsync(async () => await next());

        return response;
    }
}

public interface IFallbackHandler<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    Task<TResponse> HandleFallback(TRequest request, CancellationToken cancellationToken);
}

View MediatR Fallback Pipeline Behavior on GitHub.

Retry Behavior (using Polly):

public class Handler : IRequestHandler<Query, Customer>, IRetryableRequest<Query, Customer>
{
    private readonly CustomerContext _db;
    private readonly IConfigurationProvider _configuration;

    // By implementing IRetryableRequest<TRequest, TResponse> I get the following
    // properties to control how my "Handle" method will get retried.
    public int RetryAttempts => 2;
    public int RetryDelay => 500;
    public bool RetryWithExponentialBackoff => true;
    public int ExceptionsAllowedBeforeCircuitTrip => 2;

    public Handler(CustomerContext db, IConfigurationProvider configuration)
    {
        _db = db;
        _configuration = configuration;
    }

    public async Task<Customer> Handle(Query message, CancellationToken token)
    {
        return await _db.Customers.Where(c => c.Number == message.CustomerNumber)
            .ProjectTo<Models.Customer>(_configuration)
            .FirstOrDefaultAsync(token);
    }

}

public interface IRetryableRequest<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    int RetryAttempts => 1;

    int RetryDelay => 250;

    bool RetryWithExponentialBackoff => false;

    int ExceptionsAllowedBeforeCircuitTrip => 1;

}

public class RetryBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly IEnumerable<IRetryableRequest<TRequest, TResponse>> _retryHandlers;
    private readonly ILogger<RetryBehavior<TRequest, TResponse>> _logger;

    public RetryBehavior(IEnumerable<IRetryableRequest<TRequest, TResponse>> retryHandlers, ILogger<RetryBehavior<TRequest, TResponse>> logger)
    {
        _retryHandlers = retryHandlers;
        _logger = logger;
    }

    public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
    {
        var retryHandler = _retryHandlers.FirstOrDefault();
        if (retryHandler == null)
        {
            // No retry handler found, continue through pipeline
            return await next();
        }

        var circuitBreaker = Policy<TResponse>
            .Handle<Exception>()
            .CircuitBreakerAsync(retryHandler.ExceptionsAllowedBeforeCircuitTrip, TimeSpan.FromMilliseconds(5000),
                (exception, things) =>
                {
                    _logger.LogDebug("Circuit Tripped!");
                },
                () =>
                {
                });

        var retryPolicy = Policy<TResponse>
            .Handle<Exception>()
            .WaitAndRetryAsync(retryHandler.RetryAttempts, retryAttempt =>
            {
                var retryDelay = retryHandler.RetryWithExponentialBackoff
                    ? TimeSpan.FromMilliseconds(Math.Pow(2, retryAttempt) * retryHandler.RetryDelay)
                    : TimeSpan.FromMilliseconds(_handler.RetryDelay);

                _logger.LogDebug($"Retrying, waiting {retryDelay}...");

                return retryDelay;
            });

        var response = await retryPolicy.ExecuteAsync(async () => await next());

        return response;
    }
}

View MediatR Retry Pipeline Behavior on GitHub.

These can all be combined as well and work based on the order they’re registered in Startup.cs. In my case, I want my main Handle method to retry, then, optionally, fallback to my HandleFallback, then finally cache the result based on the defined CachePolicy.

I’m debating between using separately defined classes/policies (like FluentValidation Validators) vs. making Handlers implement the interfaces to get the behavior. On one hand, if they’re separate, I could move the Cache, Fallback and Retry policies to separate files, folders, etc. and keep my main MediatR handlers very lean and clean. If you want to see them in the same place, you could put them in the same file like many of Jimmy Bogard’s examples with Validators, etc. But if the files get too big and you want to separate them out, you could do that. However, with Retry and Fallback, it’s kind of nice seeing that with the main request handler.

Of course, all this gets wired-up and registered in Startup.cs. I’m using Scrutor to aid in discovery my Caching, Fallback and Retry policies. See below.

// Register MediatR Pipeline Behaviors
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(CachingBehavior<,>));
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(FallbackBehavior<,>));
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(RetryBehavior<,>));

// ICachePolicy discovery and registration
services.Scan(scan => scan
    .FromAssemblies(assembly)
    .AddClasses(classes => classes.AssignableTo(typeof(ICachePolicy<,>)))
    .AsImplementedInterfaces()
    .WithTransientLifetime());

// IFallbackHandler discovery and registration
services.Scan(scan => scan
    .FromAssemblies(typeof(Startup).Assembly)
    .AddClasses(classes => classes.AssignableTo(typeof(IFallbackHandler<,>)))
    .UsingRegistrationStrategy(RegistrationStrategy.Skip)
    .AsImplementedInterfaces()
    .WithTransientLifetime());

// IFallbackHandler discovery and registration
services.Scan(scan => scan
    .FromAssemblies(typeof(Startup).Assembly)
    .AddClasses(classes => classes.AssignableTo(typeof(IRetryableRequest<,>)))
    .UsingRegistrationStrategy(RegistrationStrategy.Skip)
    .AsImplementedInterfaces()
    .WithTransientLifetime());

View MediatR Pipeline Behavior Registration on GitHub.

What do you think? Which approach do you prefer? Let me know in the comments.

Laravel User Timezone Aware Trait

Thu, 21 Dec 2017 17:36:21 GMT

Next up in the series on useful Laravel model traits is the UserTimezoneAware Trait.

This trait is useful when you have dates on models that you need to display in the user’s timezone.

// app\Traits\UserTimezoneAware.php
namespace App\Traits;
trait UserTimezoneAware
{
    /**
     * The attribute name containing the timezone (defaults to "timezone").
     *
     * @var string
     */
    public $timezoneAttribute = 'timezone';
     
    /**
     * Return the passed date in the user's timezone (or default to the app timezone)
     *
     * @return string
    */
    public function getDateToUserTimezone($date, $timezone = null)
    {
        if ($timezone == null) {
            if (Auth::check()) {
                $timezone = Auth::user()->timezone;
            } else {
                $timezone = Config::get('app.timezone');
            }
        }
        $datetime = new DateTime($date);
        $datetime->setTimezone(new datetimezone($timezone));
        
        return $datetime->format('c');
    }   
}

It’s a simple trait you can drop onto one of your eloquent models to add timezone support like so:

// app\Models\User.php
namespace App\Models;

use App\Traits\UserTimezoneAware

class User
{
    use UserTimezoneAware;

    public function getLastLoginAttribute()
    {
        return $this->getDateToUserTimezone($this->attributes['last_login']);
    }
}

Now when you access the $user->lastLogin attribute anywhere in your app, you’ll get the date in the user’s timezone.

The UserTimezoneAware trait expects the model to have a timezone attribute. If your column/attribute is named something other than timezone simply override the $timezoneAttribute property on the UserTimezoneAware trait.

namespace App\Models;

use App\Traits\UserTimezoneAware
 
class User
{
    use UserTimezoneAware;

    public $timezoneAttribute= 'time_zone';
}

Enjoy!

Useful Laravel Model Traits: Gravatar

Fri, 09 Sep 2016 14:38:45 GMT

Starting a little series here on useful Laravel model traits.

This first one I use quite often.

// app\Traits\HasGravatar.php
namespace App\Traits;

trait HasGravatar
{
    
    /**
     * The attribute name containing the email address.
     *
     * @var string
     */
    public $gravatarEmail = 'email';
    
    /**
     * Get the model's gravatar
     *
     * @return string
     */
    public function getGravatarAttribute()
    {
        $hash = md5(strtolower(trim($this->attributes[$this->gravatarEmail])));
        return "https://www.gravatar.com/avatar/$hash";
    }

}

It’s a simple trait you can drop onto one of your eloquent models to add gravatar support like so:

// app\Models\User.php
namespace App\Models;

use App\Traits\HasGravatar

class User
{
    use HasGravatar;
}

Now you can do something like this in your blade views:

<img src="{{ Auth::user()->gravatar }}">

And you’ll get the gravatar.com URL you’re expecting. No need to create a gravatar column, variable, method, or anything else.

The HasGravatar Trait expects the model to have an email attribute. If your column/attribute is named something other than email simply override the $gravatarEmail property on the HasGravatar trait.

namespace App\Models;

use App\Traits\HasGravatar

class User
{
    use HasGravatar;

    public $gravatarEmail = 'email_address';
}

Enjoy!

Laravel Transformable – An Eloquent Model Trait for Consumable Models

Thu, 08 Sep 2016 21:37:31 GMT

In working on a new Laravel-based REST API over an existing database, I quickly realized the need to shield API consumers from my underlying database structure, especially since I knew the structure would be changing. This is a common concern in API design and many times I would turn to creating DTOs (Data Transfer Objects) or transformer classes using either a scaled-down Transformer pattern or the excellent Fractal package. However, for this project time was of the essence so I needed a very quick way to simply provide a transformation map without having to create new transformer classes for each model and without having to update the visible and appends attributes on every model.

Hence, the Transformable trait was born. It’s a simple PHP trait that you drop into your model and then override the $transformation_map property to specify your consumable model attributes.

Here’s an example:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use App\Traits\Transformable;

class Group extends Model
{
    use Transformable;

    protected $transformation_map = [
        'Group_ID' => 'id',
        'Name' => 'name',
        'PublicGroup' => 'public',
    ];
}

A quick explanation: we’re importing the Transformable trait (which I’ll cover shortly) and then we’re providing a database column name-to-consumable attribute name mapping. That’s it.

A consumer of this model will not see the underlying database column names on the left hand of the mapping such as “Group_ID”, “Name”, or “PublicGroup.” Instead, they’ll see the names on the right hand side: “id”, “name” and “public.” In essence, it’s a simple transformer. Here’s an example usage:

use App\Models\Group;

class GroupsController
{
    public function index()
    {
        return Group::all();
    }
}

With a call to the above GroupsController@index method, we’d end up with the following JSON:

[
    {
        "id": 1,
        "name": "Group 1",
        "public": "0"
    },
    {
        "id": 2,
        "name": "Group 2",
        "public": "0"
    }
}

Additionally, we can create the model specifying the consumable attribute names (not the database column names):

$group = new App\Models\Group(['name' => 'Group 3', 'public' => true]);

// Calling this
$group->toJson();

// Will yield this
{
    "id": 3,
    "name": "Group 3",
    "public":"1"
}

The magic of this is in the Transformable trait. Normally, to achieve this, we’d have to specify the $visible and $appends properties on our model and provide get and set mutators for each attribute mapping. Instead, with Transformable, we simply provide the $transformation_map and the Transformable trait takes care of the rest.

It does this by overriding several methods of the Eloquent model that determine if get and set mutators exist to include checking the $transformation_map property. This is how it can return you an instance of your model as well as create an instance of your model with the consumable attribute names without you needing to specify the source database column names.

I’m working on an enhancement to Transformable to allow queries (i.e. where* methods) on the models so that you can query with the consumable attribute names and not the database column names. As soon as I wrap up those changes, I’ll look at making this a composer package.

Here’s the entire trait implementation:

namespace App\Traits;

use Illuminate\Support\Str;

Trait Transformable
{
	protected $transformation_map = [];

    /**
     * Determine if a get mutator exists for an attribute.
     *
     * @param  string  $key
     * @return bool
     */
    public function hasGetMutator($key)
    {
        return $this->keyExistsInTransformationMap($key) || parent::hasGetMutator($key);
    }

    /**
     * Determine if a set mutator exists for an attribute.
     *
     * @param  string  $key
     * @return bool
     */
    public function hasSetMutator($key)
    {
        return $this->keyExistsInTransformationMap($key) || parent::hasSetMutator($key);
    }

    /**
     * Get the value of an attribute using its mutator.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return mixed
     */
    protected function mutateAttribute($key, $value)
    {
        if ($this->keyExistsInTransformationMap($key)) {
            return $this->{$this->getTransformationMapInverse()[$key]};
        }
        return parent::mutateAttribute($key, $value);
    }

    /**
     * Set a given attribute on the model.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return $this
     */
    public function setAttribute($key, $value)
    {
        if ($this->keyExistsInTransformationMap($key)) {
            if (method_exists($this, 'set'.Str::studly($key).'Attribute')) {
                parent::setAttribute($key, $value);
            }
            $key = $this->getTransformationMapInverse()[$key];
        }
        return parent::setAttribute($key, $value);
    }

    public function keyExistsInTransformationMap($key)
    {
        return array_key_exists($key, $this->getTransformationMapInverse());
    }

    public function getTransformationMapInverse()
    {
        return array_flip($this->transformation_map);
    }
}

This could certainly be enhanced further to support casting to/from datatypes and supporting compound properties via a Closure or similar.

Let me know what you think in the comments.

Gravity Forms + Microsoft Dynamics CRM

Wed, 02 Sep 2015 21:57:43 GMT

I’ve been hard at work on a brand new WordPress plugin that brings you easy web-to-lead and web-to-contact forms for Microsoft Dynamics CRM through the powerful Gravity Forms plugin for WordPress.

At my company, Saint Systems, we have a non-profit client that uses Office 365 and Microsoft Dynamics CRM plus WordPress for their front-end website. Initially we searched for an existing plugin, add-on or integration between Gravity Forms and Dynamics CRM to no avail. So, we decided to build one and scratch our own itch.

The result is the Gravity Forms Dynamics CRM Add-On – a WordPress plugin that allows you to quickly integrate Gravity Forms with Microsoft Dynamics CRM. Easily create leads or contacts in Microsoft Dynamics CRM when a form is submitted.

Key Features

Quickly and easily integrate with Dynamics CRM when a form is submitted.
Create a lead in Dynamics CRM when a form is submitted.
Create a contact in Dynamics CRM when a form is submitted.
Update a lead in Dynamics CRM when a form is submitted.
Update a contact in Dynamics CRM when a form is submitted.
Choose a Dynamics CRM user as the lead or contact owner.
Avoid duplicates by checking for existing leads and contacts by email address.
Use Gravity Forms built-in Conditional Logic to only integrate with Dynamics CRM when you want to!

~~We’re planning on an October 2015 release and are anxious to get it in your hands.~~ The plugin is now available for purchase.

Find out more about it on the Gravity Forms Dynamics CRM Add-On product page.

DNS from the command line: dnsimple-cli for Node.js

Mon, 27 Oct 2014 14:47:21 GMT

Too busy to do a full write-up now, but I’m working on a new Node.js dnsimple-cli package based on azure-cli.

Of course, it starts with ASCII art:

After logging in, you can do something like this:

dnsimple domain list

And, you’ll get:

Initially, the command structure I’ve stubbed out is as follows (subject to change):

dnsimple
	|- domain
		|- list
		|- add
		|- show
		|- delete
		--------------
		|- reset (reset token)
		|- push
		--------------
		|- check
		|- register
		|- transfer (in)
		|- renew
		|- transferout
		|- autorenew [true|false]
		--------------
		|- member
			|- list
			|- add
			|- delete
		--------------
		|- record
			|- list
			|- add
			|- show
			|- update
			|- delete
		--------------
		|- ns (name server)
			|- update
			|- register (add)
			|- unregister (delete)
		--------------
		|- vns (vanity name server)
			|- enable
			|- disable
		--------------
		|- whois [true|false] (WHOIS privacy)
		--------------
		|- cert (ssl)
			|- list
			|- add (purchase/buy)
			|- show
			|- configure
			|- submit (update)
		--------------
		|- email (email forwards)
			|- list
			|- add
			|- delete
		--------------
		|- zone
			|- import
			|- export
	--------------
	|- contact
		|- list
		|- add
		|- show
		|- update
		|- delete
	--------------
	|- server
		|- list
		|- show
	--------------
	|- template
		|- list
		|- add
		|- show
		|- delete
	--------------
	|- extendedattributes
		|- list
	--------------
	|- user
	--------------
	|- subscription
		|- add
		|- show
	--------------
	|- price
		|- list

More to come!

WooCommerce MailChimp 1.2 Released

Fri, 10 Jan 2014 19:21:17 GMT

WooCommerce MailChimp version 1.2 is now available on the WordPress Plugin Repository which brings enhancements to provide even greater control over the opt-in settings to better support international laws. There were also a couple of changes to better support i18n (Internationalization) support and localization as well as a minor change to append interest groups to existing MailChimp subscribers. Below are the details on the changes included in version 1.2:

Added new setting to control whether or not the opt-in checkbox is checked or unchecked by default
Added new setting to control the placement of the opt-in checkbox on the checkout page (under billing info or order info)
Added .pot file to support international translations
Added wpml-config.xml file to support WPML translations for values stored in wp_options
Change to MailChimp API subscribe call to append interest groups to existing subscribers

Please update your plugin today to take advantage of these features and stay tuned for the upcoming release of WooCommerce MailChimp Pro!

Join our Trello Board to see what’s on our roadmap and vote on features. As always, please provide your feedback and/or enhancement requests here.

Enjoy!

WooCommerce MailChimp Update

Wed, 08 Jan 2014 17:07:00 GMT

WooCommerce MailChimp will soon surpass the 3,500 download mark after just under 3 months on the WordPress Plugin Repository. The response has been incredible, interest has been steadily gaining and many users have provided very constructive feedback, comments and suggestions. As such, I felt an update was in order to make you aware of what’s coming for WooCommerce MailChimp.

Version 1.2

We are currently working on version 1.2 of the plugin which will include the following requested features to name a few:

New setting to control whether or not the double opt-in checkbox is checked/unchecked by default on the checkout page.
Small modification to append to MailChimp interest groups for existing users so that group settings are not lost for users who were already subscribed.
Preparations for i18n (Internationalization) support. Several users have already asked and offered to translate the plugin into other languages. We had always planned on that, but now are making that a reality.

Trello Board

We have setup a public Trello board where you can see what’s next on our radar, vote on features and see the status of enhancements, bug fixes, etc.

WooCommerce MailChimp Pro

We are planning a paid/pro version of this plugin (coming soon) which will include advanced features for more fine-grained control over the integration with MailChimp and more “power user” features. This will allow us more time to dedicate to making this the best possible plugin to integrate WooCommerce and MailChimp, while also allowing us to feed our families. 🙂

While pricing has not yet been announced, there will be license options based on the number of sites you wish to install the plugin on. Stay tuned for further details.

What about the free version?

Don’t worry! There will always be a free version on the WordPress Plugin Repository which will include the current functionality plus some enhancements but support will happen as we can get to it.

That’s all for now!

Please subscribe to our Trello board and stay tuned for version 1.2 release and the upcoming Pro version.

Thank you so much for your support and feedback. The response to the plugin has been truly amazing!

WooCommerce MailChimp 1.1 Released

Tue, 12 Nov 2013 13:21:24 GMT

The response has been huge to my WooCommerce MailChimp plugin but there have been quite a few international users who haven’t been able to use it due to laws requiring the ability for customers to explicitly opt-in to the email list during checkout vs. the default behavior of automatically subscribing customers to the list after making a purchase. Well, the wait is over, WooCommerce MailChimp 1.1 is now available and adds this capability (see screenshot below) so that customers can choose whether or not to opt-in during the checkout process. This feature is completely optional and you have full control over the opt-in text displayed next to the checkbox (figure 2).

Figure 1: WooCommerce MailChimp Checkout Opt-In

Figure 2: WooCommerce MailChimp Options

This feature was contributed by Brent Shepherd (developer of the excellent WooCommerce Subscriptions extension). Many thanks Brent!

Please update your plugin today to take advantage of this feature. The update is also available for download on the WordPress plugin directory here: http://wordpress.org/plugins/woocommerce-mailchimp/

Enjoy!

WooCommerce MailChimp WordPress plugin now on MailChimp Integrations Directory

Thu, 24 Oct 2013 15:28:31 GMT

Quick Update: MailChimp users can now find the WooCommerce MailChimp WordPress plugin on the MailChimp Integrations Directory.

To find out more about the WooCommerce MailChimp WordPress plugin, see the plugin page or download it from the WordPress Plugin Directory.

New WordPress Plugin: Wistia Responsive

Thu, 24 Oct 2013 13:47:00 GMT

Wistia Responsive is a simple and straightforward WordPress plugin I developed while working on the website for the New Saint Thomas Institute (NSTI) that automatically makes all of your Wistia video embeds responsive.

Problem: On the NSTI site, we have lots of video content and we’re using a responsive theme because we know that many of the site’s members would be accessing content on mobile devices, smartphones or tablets. However, we quickly noticed that the Wistia video player was not inherently responsive and was hindering the experience for users on mobile and tablet devices.

The good news is the team at Wistia has a solution in the form of their “video foam” feature currently on their labs site. This works with their iframe api to make your Wistia embedded video players responsive.

The problem is that, because the video foam features uses the javascript iframe api, there wasn’t an easy way to have content authors easily make their videos responsive when generating embeds on Wistia’s site without manually appending the “videoFoam” parameter to the end of their embeds inside of WordPress.

Solution: What we came up with was a simple plugin that first registers the iframe api script needed for video foam to work and then hooks into the_content and the_excerpt filters to automatically append the video foam parameter to the end of all video embeds. The plugin looks for wistia video embeds, adds the video foam parameter, and the rest takes care of itself!

Simply activate the plugin and the rest will happen automatically!

See it in action in the embedded video below. Try resizing your browser or access this page from your phone or tablet and the Wistia player should resize automatically to fit your screen.

The plugin is now on the WordPress Plugin Repository and you can get it by clicking on the following link:

Download Wistia Responsive

Get the Source on GitHub

Multisite

All features should work for each blog in multisite installations but this has not yet been tested.

Feedback

Feedback is welcome!

If you need help, have problems, want to leave feedback or want to provide constructive criticism, please do so here at the Wistia Responsive plugin page.

Twitter

Follow @anderly on Twitter for updates on this and other plugins.

Installation

Upload or extract the wistia-responsive folder to your site’s /wp-content/plugins/ directory. You can also use the Add new option found in the Plugins menu in WordPress.
Enable the plugin from the Plugins menu in WordPress.
Voila! Your Wistia video embeds will now be responsive!

Changelog

1.0

This is the first public release.

New WordPress Plugin: WooCommerce MailChimp

Wed, 09 Oct 2013 15:57:17 GMT

The WooCommerce logo and MailChimp logo are trademarks of Automattic and MailChimp respectively.

After a frustrating and fruitless search for a simple and free solution to basic WooCommerce integration with MailChimp, I decided to sit down and write a little plugin to do just that. There are a couple of paid solutions, but, in my opinion, most are overpriced for providing such vanilla functionality. Also, it seems this functionality was previously bundled with WooCommerce and WooThemes has since removed it and made it a paid “extension.”

So, without further ado, here is my new WooCommerce MailChimp plugin for WordPress:

WooCommerce MailChimp provides simple MailChimp integration for WooCommerce.

Easily add customers to a designated MailChimp list and, optionally, MailChimp interest groups upon order creation or order completion.

Double opt-in option for anti-spam compliance.

The plugin is now on the WordPress Plugin Repository and you can get it by clicking on the following link:

Download WooCommerce MailChimp

Get the Source on GitHub

Join our Trello Board to see what’s on our roadmap and vote on features. As always, please provide your feedback and/or enhancement requests here.

Features

WooCommerce Event Selection

Subscribe customers to MailChimp after order creation
Subscribe customers to MailChimp after order completion

Works with MailChimp Interest Groups

Set one or more interest groups to add users to based on the selected MailChimp list.

Multisite

All features should work for each blog in multisite installations but this has not yet been tested.

Feedback

Feedback is welcome!

If you need help, have problems, want to leave feedback or want to provide constructive criticism, please do so here at the WooCommerce MailChimp plugin page.

Twitter

Follow @anderly on Twitter for updates on this and other plugins.

Translations

English (default)
No other translations yet.

Thanks in advance for your help on any translation efforts!

Installation

Upload or extract the woocommerce-mailchimp folder to your site’s /wp-content/plugins/ directory. You can also use the Add new option found in the Plugins menu in WordPress.
Enable the plugin from the Plugins menu in WordPress.

Usage

Go to WooCommerce > Settings > Integration > MailChimp
First, enable the plugin and set your MailChimp API Key and hit save.
Select whether you want customers subscribed to your MailChimp list after order creation or order completion (there’s a difference in WooCommerce).
Next, select your MailChimp list and set any interest group settings (optional) and hit save.
That’s it, now customers who purchase products from your WooCommerce store will automatically be subscribed to the selected list (and optional interest groups) in MailChimp!

Screenshots

WooCommerce MailChimp options screen.

Sublime Text 2/Textmate port of studiostyl.es “Son of Obsidian” theme for Visual Studio

Fri, 15 Feb 2013 14:59:26 GMT

I’ve been a fan of the popular Son of Obsidian theme for Visual Studio since it came out a couple of years ago. However, I’ve found myself using Sublime Text 2 more and more because it’s lightweight, fast and has some great features that almost make it full like a full IDE without the bulk. However, I missed my Son of Obsidian theme, so awhile back I decided to port the theme and create a Sublime/Textmate compatible version.

You can find it on GitHub here.

If you have any changes, please feel free to fork it and contribute.

Enjoy!

Why Microsoft Developers Should Care About Node.js

Fri, 06 Jul 2012 17:08:53 GMT

I’ve been a Microsoft developer since I started programming straight out of college and I know there are many others out there just like me. It’s been a comfortable space that has grown steadily over the past 10+ years. However, in the last 3-5 years or so, I branched out of my Microsoft comfort zone and dipped my toes into other languages, platforms and frameworks such as iOS development, Android, Ruby on Rails, PHP and most recently Node.js.

There’s been a lot of debate since Node’s arrival as to whether or not this is a step backwards for software development. JavaScript on the server? You mean the almost 20-year-old scripting language that I’m still using on the client but only because jQuery makes it look easy? Yes, that JavaScript!

Likewise, if you came from a Classic ASP development background like me, then you probably knew that with Classic ASP, you usually had 2 languages to pick from: VBScript (the most common) and JScript (Microsoft’s Implementation of ECMAScript). Other languages such as PerlScript, Python and others could also be installed via third-party Active Scripting Engines, but the two main ones that came built-in were VBScript and JScript/JavaScript.

While most folks (myself included) used VBScript for Classic ASP development, JScript (JavaScript) was (and still is) an interesting option. It’s dynamic like VBScript, but more structured and case-sensitive like C#. Personally, I always liked JavaScript because of this blend between its dynamic nature and its structured C roots. If you’re in a corporate Microsoft-shop environment like I was up until a year and a half ago, you may still find yourself maintaining some legacy Classic ASP systems. If so, I encourage you to experiment with JavaScript and Classic ASP. It will prepare you for getting used to JavaScript on the server with Node.js. If you’re strictly a .NET developer, think a malleable C# without so many rules. To use JavaScript for Classic ASP, you simply add the following language directive to the top of your .asp files:

<%@ language="javascript"%>

And then you can do something like:

<%
// CustomerRepository class

var CustomerRepository = function() {
  this.save = function(customer) {
    // insert/update in db
  };

  this.findById = function(id) {
    // retrieve from db by id
  };

  this.delete = function(id) {
    // delete from db by id
  };
};

var customerRepository = new CustomerRepository();

// In Classic ASP or other programming languages, this would block the current thread until the database returned the customer
var customer = customerRepository.findById(12345);
%>

If you’re a C# developer, this probably looks very familiar. It’s not statically typed like C#, but the syntax is familiar and clean.

Now, as far as Node.js goes, this same “class” could be made into a simple Node.js module with some minor changes:

First, we’d remove the angle-bracket percent (<%%>) tags
Next, we’d rename the file to CustomerRepository.js and export this as a module
Finally, using Node’s callback convention, we’d add a callback parameter to our methods like below. Or, we could use an event-driven approach by inheriting from Node’s EventEmitter.

Then, we’d end up with:

// CustomerRepository class

var CustomerRepository = function() {
  this.save = function(customer, callback) {
    // insert/update in db
  };
  this.findById = function(id, callback) {
    // in a real app, we'd kick off some I/O and retrieve the customer from
    // a database, web service or somewhere else
    // since this isn't a real app, we need to throw this on the event loop/queue 
    // so as not to block the current thread. We do that using process.nextTick
    // if I hadn't wrapped this in process.nextTick, then this would actually
    // fire immediately which would block Node's main thread which is a
    // bad thing since there's only one of them!!!
    process.nextTick(function() {
      callback({ id:123456, name:'Joe Customer', email:'joe@somewhere.com' });
    });
  };

  this.delete = function(id, callback) {
    // delete from db by id
  };
};

module.exports = new CustomerRepository();

Using Node’s require statement (akin to include in Classic ASP or using in C#), we could then import this module like so:

var customerRepository = require('./lib/CustomerRepository.js');

// In Node.js this will not block the current thread since this is an I/O operation
customerRepository.findById(12345, function(err, customer){
  if (err) {
    console.log('Oh no, something bad happened: ' + err);
  } else {
    console.log('Yippee! We got a customer back: ' + customer.name);
    // now, do something with the customer object
  }
});

Nothing revolutionary here. My point is to simply show you that there is nothing inherently magical or complicated about JavaScript on the server. It’s still the same JavaScript you use on the client today with libraries like jQuery etc. and the same JavaScript you could have used with Classic ASP 15 years ago.

However, the part that does make JavaScript magical on the server is Node. It’s built on top of Google Chrome’s V8 JavaScript Engine. For those of you that are using Chrome, you know how fast Google Chrome is. Well, V8 is the magic behind Chrome’s speed performance when it comes to JavaScript.

What Node does is bring that speed and performance to the server in the form of a fast, lightweight, single-threaded event loop. Wait! Hold Up! Did you say “single-threaded?” Yes, I said “single-threaded.” Rather than spawn new threads or use a pool of worker threads to service new requests, Node takes a different approach to performance in the form of a non-blocking evented model that is designed to be asynchronous. This is good for developers because it means we don’t have to worry about thread pool management, sync locks, mutexes, race conditions and the joy (sarcasm) that is debugging multi-threaded programs. However, in order for Node to allow a single thread to handle multiple concurrent requests, you can never allow the main thread to wait on blocking, synchronous or CPU-bound operations. Note the phrase “you can never allow” in the previous sentence. Node will not prevent you from writing blocking, synchronous or high CPU-bound operations. Node will handle making I/O operations non-blocking for you, but for anything else, It is your responsibility as the developer to make sure you are writing non-blocking, asynchronous code. Node simply gives you the framework and conventions for doing so, but it does not mandate this. You read more about how Node works here.

Still, you may ask, “Why JavaScript on the server?” Well, if you’re doing web development these days you are probably using JavaScript on the client for things like form validation, DOM manipulation, ajax, lazy content-loading, etc. If you’re working with web services, you have probably consumed JSON through an API like Twitter, Facebook or maybe you’ve rolled your own. So, you’re using JavaScript on the client. JavaScript in transport (in the form of JSON) and you may even be storing some JSON on the server whether as serialized data in a relational-database such as SQL Server, Oracle, MySQL or PostGres. Or, maybe you’re using a NoSQL database such as MongoDB, CouchDB or even Azure Table Storage.

So, if you’re using JavaScript on the client, JavaScript in-transport and JavaScript for persistence. It only begs the question, should JavaScript be used on the server?

Node’s answer is “yes” and many developers have come to that same conclusion (end-to-end JavaScript) and that is why Node.js has gone from an obscure project just a few short years ago to one of the most actively followed projects on GitHub today.

Now, we get to the part of why you should care about Node.js as a Microsoft / .NET developer.

Microsoft has taken notice of Node’s growing popularity and its merits and they have worked with the Node.js community on Windows support for node and IIS support through iisnode. Microsoft has embraced Node.js as a first-class citizen in Windows Azure, going from MIA a little over a year ago to being listed as the first language (below .NET) on their Window Azure Developer Center, ahead of Java, PHP and Python.

Node.js on Azure is actually a great story that has many benefits aside from running Node yourself.

As this article points out, Microsoft doesn’t adopt outside technologies that aren’t established. Just like their official support for jQuery, Microsoft’s support of Node.js signifies a shift from “cool fringe technology that carries too much risk to use on a real project” to “something I should at least start becoming familiar with in case it becomes the next jQuery.”

Despite this, you may ask yourself, “Is JavaScript-development the direction I want to take my career?” Well, look no further than Windows 8 and its support for building Metro apps with HTML5, CSS and…..JavaScript. I submit that just like writing Classic ASP with JavaScript wouldn’t make you any less of a Microsoft developer 15 years ago, writing Node.js apps with JavaScript won’t make you any less of a Microsoft developer today. JavaScript is here to stay. If you don’t like the language or its syntax, then take a look at CoffeeScript, a little syntactic sugar over JavaScript.

Who knows, your next project might be an HTML5, CSS and JavaScript Windows 8 Metro App that communicates with a Node.js server running on Windows Azure backed by MongoDb. Sneak in a little JavaScript into that Classic ASP app you’re still supporting 12 years later and you’ll feel right at home.

If you’re a Microsoft developer, let me know what you think of Node.js in the comments.

Happy JavaScripting!

Status of SimpleMembership.Mvc3 and SimpleMembership.Mvc3.Sample

Fri, 09 Mar 2012 16:56:29 GMT

I have received a couple of questions and requests over the past 6 months or so regarding my plans to update both the SimpleMembership.Mvc3 and SimpleMembership.Mvc3.Sample packages.

In short, I’m planning on updating these but I just haven’t gotten to it yet. I’ve been very busy lately with some other projects such as Expansive and my C# wrapper for the DNSimple REST API.

However, in preparation for these changes I have started a Trello board here: https://trello.com/board/simplemembership/4f23419c0fa7e50d34585d9e

I’m using this to track requests I have received and to communicate the status of the features that have been requested.

Please feel free to comment on them or vote or request new features.

However, these being open source projects on GitHub, please also feel free to fork them, add your desired features and submit a pull request to me to merge your changes back into the trunk.

Both projects can be found on GitHub using the following links:

I am going to try to get these changes done soon, but I just haven’t been able to dedicate any time to them yet.

In the meantime, thanks again for your interest, feedback, questions and requests regarding SimpleMembership.

Stay tuned…

Expansive 1.5 Released

Fri, 14 Oct 2011 19:43:27 GMT

Yesterday, I blogged about my new .NET string expansion library called Expansive.

Today, I made some key changes to, hopefully, make it easier to use and more flexible by providing 4 token style format providers out of the box.

Removed the startToken and endToken delimiters that could be set by the consumer as this was unreliable
Added 4 new Token Style Formats to pick from:
- MvcRoute Style “{token}” (default)
- Razor Style “@token” or “@(token)”
- NAnt Style “${token}”
- MSBuild Style “$(token)”

So, the following are all valid:

// MvcRoute-Style (default)
var mvcRouteStyleString = "Hello, {FirstName}".Expand(new { FirstName = "John" });

// Razor-Style
Expansive.DefaultTokenStyle = TokenStyle.Razor;
var razorStyleString = "Hello, @FirstName".Expand(new { FirstName = "John" });

// NAnt-Style
Expansive.DefaultTokenStyle = TokenStyle.NAnt;
var nantStyleString = "Hello, ${FirstName}".Expand(new { FirstName = "John" });

// MSBuild-Style
Expansive.DefaultTokenStyle = TokenStyle.MSBuild;
var msBuildStyleString = "Hello, $(FirstName)".Expand(new { FirstName = "John" });

// all return "Hello, John"

You can also specify the TokenStyle on the call to Expand() such as:

var expandedString = "Hello, @FirstName".Expand(new { FirstName = "John" }, TokenStyle.Razor);

The addition of TokenStyle makes the API a little cleaner and provide 4 popular token formats.

You can of course add your own by grabbing the source on GitHub and opening the hood.

Enjoy!

Expansive – A powerful string expansion library for .NET you never knew you always wanted.

Thu, 13 Oct 2011 19:23:30 GMT

Expansive

having a capacity or tendency to expand.
causing or tending to cause expansion
characterized by richness, abundance or magnificence

While working on a recent project involving lots of appSettings keys and values in my web.config/app.config files and some values that have overlapping information (server names, file paths, etc.), I realized how much I missed the property expansion capabilities of NAnt and, more recently, MSBuild. So, I set out to see if I could quickly build a simple string property expansion library to solve this common problem and maybe some others along the way.

While I knew that true string interpolation would be somewhat tricky and probably best left to the framework developers, I felt that an easy add-on API using extension methods and possibly some new helper classes could at least make my life easier.

Channeling Rob Conery, I named my new library Expansive as a play on Expansion and Expensive (sarcasm) as I wanted something that wasn’t expensive (technically) and was easy to implement and easy to learn.

You can check out the full capabilities via the readme over on GitHub, but I’ll give you a couple of examples and ideas on how it can be used.

1. Solve web.config / app.config nightmares

Many times I find that in large applications, I have many web.config / app.config appSettings keys, connection strings, etc and that many of the values have redundant information. For instance server names, IP Addresses or paths may be strewn throughout several appSettings keys and I find myself wishing I could just define the data once, so as to “normalize” my appSettings, and then simply reference one key from the value of another. What I really want is a composition model where I can compose different appSettings (or other strings for that matter) using previously defined values.

Here’s a common scenario:

I may have a connection string defined with a server name: dbserver01
I may have environment specific naming conventions like (dbserver01-dev, dbserver01-qa, dbserver01-stg, dbserver01-prod, etc)
I may have other server names in my appSettings like urls for services, unc paths for fileshares, report server urls, etc.
While I can certainly duplicate the server names and environment suffix throughout the various appSettings keys, it quickly becomes a chore to make sure these are all correct for a specific environment.
Web.config transforms help a little bit in that they allow me to define values for different configurations, but it still doesn’t give me a composition model where I can simplify my web.config / app.config settings so that they are easier to manage and maintain. Plus web.config transforms only help at build/deploy time. There is no story for runtime changes.

Expansive aims to solve that problem by allowing for NAnt-like property expansion (scroll down to section 6) whereby I can define an appSetting once such as:

<add key="env" value="dev"/>

And then be able to reuse that value in other settings such as:

<add key="ServerName" value="dbserver01-{env}"/>

And, then finally use that value inside of a connection string such as:

<add name="Default" connectionString="server={ServerName};Initial Catalog=master;uid=uid;pwd=pwd" provider="System.Data.SqlClient"/>

As you can see, I’m defining the “env“ setting once and then reusing that in the “ServerName” setting, which is then used in the connection string.

To get the “expanded” values, you simply call the Expand() extension method on string. For instance:

var connectionString = ConfigurationManager.ConnectionStrings["Default"].ConnectionString.Expand();
// returns "server=dbserver01-dev;Initial Catalog=master;uid=uid;pwd=pwd"

or you can use the dynamic ConfigurationManager wrapper “Config” as follows:

var connectionString = Config.ConnectionStrings.Default;
// returns "server=dbserver01-dev;Initial Catalog=master;uid=uid;pwd=pwd" without needing explicit call to Expand()

By default expansive looks in your web.config or app.config appSettings for the tokens to lookup and expand. However, you can change this or provide your own “source” in the form of a Func<string, string> lambda on the call to Expand() which you’ll see in one of the examples below.

While you obviously have to take care in setting this up the first time, it allows for easily making changes to a series of settings by following a composition model where settings build on one another.

This web.config / app.config example is probably the most common, but this can also be used for string formatting / templating.

2. String Formatting

How many times have you written something like:

var welcomeMessage = string.Format("Hello, {0}", "John");

While it’s a fairly simple example and pretty easy to see from the argument context that the name “John” will get substituted in place of the “{0},” often times these types of strings are in a resource file, config file or database and when looking at them alone and without argument context, it’s not always easy to see what the ‘expectations’ of that string are. For instance if this were localized, it might just read “{0}, {1}” in a resource file. While the key may be something like “welcomeMessage,” it still may not be immediately apparent what that string format requires.

How much more readable and explicit would it be if we could write:

// Simple positional based formatting
// Essentially gets transformed into string.Format("{0} {1}","Hello", "John")
var welcomeMessage = "{greeting}, {firstName}".Expand("Hello", "John");

This is is the simple alternative to string.Format() that Expansive provides in the form of an a simple Expand() extension method on string.

Remember, if I hadn’t provided the arguments (“Hello” and “John”) to the Expand() method, it would have looked for “greeting” and “firstName” keys in my web.config / app.config appSettings. Again, this is just the default, but you can change it globally or on a per call basis. For instance, you could tell Expansive to pull these values out of resource file, a database table, from a webservice, what have you.

Some other ways in which you could accomplish the same thing with Expansive would be:

// Same as above just with variables defined first
// NOTE: This is positional replacement, not actual string interpolation based on variable names
// Again, this gets tranformed into string.Format("{0}, {1}", "Hello", "John")
var greeting = "Hello";
var firstName = "John";
var welcomeMessage = "{greeting}, {firstName}".Expand(greeting, firstName);

// Example using a Dictionary<string, string> and containing key/value pairs for expansion
// This could come from a database, file, web service, etc.
var resourceDictionary = new Dictionary<string, string> {
 {"greeting","Hello"}
 ,{"firstName","John"}
};

// call Expand() passing in a custom Func<string, string> lamda for key/value lookup
var welcomeMessage = "{greeting}, {firstName}".Expand(key => resourceDictionary[key]);

Note, you could also do this:

// Example of reusing tokens inside of another string
// NOTE: This is positional replacement, not actual string interpolation based on variable names
// This essentially becomes string.Format("FirstName: {0}, LastName:{1}, FullName: {0} {1}", "John", "Smith")
var firstName = "John";
var lastName = "Smith";
var fullName = "{firstName} {lastName}"
var welcomeMessage = "FirstName: {firstName}, LastName: {lastName}, FullName: {fullName}".Expand(firstName, lastName, fullName);

// NOTE: For fullName to work above, the "{firstName}" "{lastName}" tokens must have been in the string to be expanded.

So, as you can see this is pretty powerful and easy to read in that you can assign friendly names to the tokens vs. just have {0}, {1}, {2}… etc.

3. Model-based Templating

Additionally, Expansive can be used for model-based templating using the Expand(object model) method.

This allows you to do the following:

var model = new { FirstName = "John", LastName = "Smith" };

var testString = "First:{FirstName}, Last:{LastName}".Expand(model);
// returns "First:John, Last:Smith";

Here, Expansive replaces the tokens in the string with the values of the corresponding properties on the passed model object. Nice and clean!

Arguably, this is the most powerful feature and my favorite to use, but I’m curious to get your take.

Download it from GitHub or install it using NuGet and let me know what you think.

Enjoy!

Using SimpleMembership in MVC3

Thu, 11 Aug 2011 21:43:53 GMT

I have received a couple of questions over the past few weeks regarding how to properly get SimpleMembership to work with an MVC3 application. While it is pretty straightforward, the purpose of this post is to serve as a step-by-step “How To” setup SimpleMembership with an MVC 3 application from start to finish.

The following 4 simple steps will get you up and running with SimpleMembership in your MVC3 application in a matter of minutes. We’ll go into each step in more detail below.

Create new Mvc3 Internet Application or use an existing one.
Create your SqlServer, SqlExpress or SqlCompact4 database (we’ll be using SqlCompact4 in this example)
Update Web.config with connection string to point to your database from step 2
Install & Configure SimpleMembership.Sample package

Creating your MVC 3 Application

Select File > New Project and Select ASP.NET MVC 3 Web Application.
Pick your desired folder location and click Ok.
Next, make sure Internet Application is selected and Razor is the View engine.
In this case, we chosen to create a unit test project automatically for testing purposes.
Choose OK to create your project.

Creating your database (SqlCompact4)

Before we do anything else, we are going to create a SqlCompact4 database rather than using SQLExpress which is the default for new projects.
To do so, right-click the App_Data directory and select Add > New Item.
In the next dialog, select SQL Server Compact 4.0 Local Database, use “Database.sdf” as the filename and click Add.

Updating Web.config connection string

Now that our database is created, we need to update our connection string in Web.config to point to our SqlCompact4 database we just created.

Open Web.config and locate the connection string named “Application Services”.
Next, change the “Application Services” connectionString and providerName to the following:

Installing & Configuring SimpleMembership

Now, that we have our application ready, SqlCompact database created and ready to go, now we can install SimpleMembership. For the sake of simplicity, I’m going to install the SimpleMembership.Mvc3.Sample package which include the sample account controller pre-wired for use with SimpleMembership.

In Visual Studio, navigate to Tools > Library Package Manager > Manage NuGet Packages.
Select Online from the left-hand pane and type in SimpleMembership in the search box at the top right.
Select the SimpleMembership.Mvc3.Sample package and click Install.
Next, delete the existing Controllers/AccountController.cs file that Visual Studio created for you.
Rename Controllers/SimpleMembershipAccountController.cs to AccountController.cs
Open App_Start/SimpleMembershipMvc3.cs and update it to point to the “ApplicationServices” connection string or your appropriate connection string.

That’s It!

You’re application is now ready to use SimpleMembership and you have a fully-functional AccountController.cs pre-wired to use the SimpleMembership API.

Enjoy!

Please post a comment if you have questions or run into issues.

The code is available here: SimpleMembership.Mvc3.Example.zip

SimpleMembership.Mvc3 – 1.1 Published

Wed, 18 May 2011 18:18:48 GMT

If you’re unfamiliar with SimpleMembership.Mvc3, please see this post.

Update: May 18, 2011 – Version 1.1 published to NuGet.org

This includes:

Minor fix to WebSecurityService to address bug reported by Phil Haack.
Added assembly reference to web.config.transform to reference WebMatrix.Data. Some users have reported exceptions being thrown trying to reference that namespace.
New SimpleMembershipAccountController which can be used as a drop-in replacement for the default AccountController in new Mvc projects. This controller uses WebSecurityService instead of the FormsAuthenticationService and MembershipService for authentication and membership. The SimpleMembershipAccountController has been moved to a new sample package: SimpleMembership.Mvc3.Sample It can be used as a drop-in replacement for the default AccountController in the Mvc3 Visual Studio project template. It uses the WebSecurityService from SimpleMembership.Mvc3 instead of the FormsAuthenticationService and MembershipService which come in the default project template.

SimpleMembership.Mvc3 NuGet Package

Tue, 18 Jan 2011 17:39:19 GMT

SimpleMembership.Mvc3 – 1.0

Enables the SimpleMembership API from WebMatrix/WebPages (i.e. WebSecurity) to be used with ASP.NET MVC3. This allows you to use the WebSecurity helper found in the WebMatrix.WebData namespace.

Update: February 28, 2011 – Version 1.0 released

This includes:

The App_Start convention from David Ebbo’s post.
An updated dependency on WebActivator 1.3.2 or greater (This allows us to use the new PostApplicationStartMethod in WebActivator which allows us to remove the need to modify global.asax.cs).
Removed need to modify global.asax.cs
Now, the call to WebSecurity.InitializeDatabaseConnection() is in the new Post App Startup method called Initialize() inside App_Start/SimpleMembershipMvc3.cs. This is where you’ll need to specify your connection string and user table.

Features

Includes a web activator and web.config transforms that enable the SimpleMembershipProvider
Includes an abstraction of the WebSecurity helper (IWebSecurityService) and an implementation (WebSecurityService) to enable use with DI/IoC frameworks such as NInject, etc.

Usage

Modify the Initialize() method in App_Start/SimpleMembershipMvc3.cs to point to your connection string and user table.
That’s It!

Using the IWebSecurityService abstraction

This package includes an abstraction of the WebSecurity interface (Services/IWebSecurityService) as well as an implementation of this interface (Services/WebSecurityService). This is useful for scenarios like using WebSecurity with Ninject or another IoC/DI framework to avoid hard references to WebSecurity and improve testability. To use this:

First, make sure you register WebSecurityService as an IWebSecurityService with your IoC container.
Next, remove the call to WebSecurity.InitializeDatabaseConnection from the Initialize() method in App_Start/SimpleMembershipMvc3.cs
Finally, uncomment the following lines and modify the call to InitializeDatabaseConnection() to point to your connection string and user table:

var webSecurityService = DependencyResolver.Current.GetService<IWebSecurityService>();

webSecurityService.InitializeDatabaseConnection(connectionStringName: "Default", userTableName: "Users", userIdColumn: "ID", userNameColumn: "Username", autoCreateTables: true);

Currently, the package includes the actual WebMatrix.WebData.dll assembly. I’m looking into changing the package to instead use powershell to add the reference to the project if it already exists on the user machine.

Enjoy!

Adam

ASP.NET MVC, Dependency Injection and The Bliss of Truly Decoupled Applications

Tue, 09 Nov 2010 22:05:00 GMT

In traditional software and web applications application layering is one of the tenets of good application design and architecture. It stems from the separation of concerns principle in computer science which is the process of separating applications and programs into distinct features that overlap in functionality as little as possible. Hence, the single responsibility principle and DRY concepts in software engineering and object-oriented programming.

Typically, in layered applications, a given application layer should only communicate with and depend on the layer directly below it.

Take the following diagram for example, taken from the Microsoft Application Architecture Guide v2 (I added the red arrow indicators that typically represent where dependencies are):

In this example, the Presentation Layer would talk to and depend on the Business Layer. The Business Layer would talk to and depend on the Data Layer. The Data Layer would talk to and depend on the database.

This is generally considered good application design despite there being dependencies between layers. However, traditionally, layer n-1 dependency (one layer dependency) has been the normal and accepted practice. But experience tells us that all-too-often we find dependencies on more than just one layer. In fact, we may find dependencies between multiple layers…or worse….between all layers, ending up with something like this:

The application may work fine. In fact, it may work perfectly. But the net effect, in the case of either diagram, is that, with each dependency, change becomes more difficult. Our apps become more difficult to maintain, more difficult to test, and more difficult to change which can result in longer development cycles, higher costs and increased risk of failure on our projects.

Usually, these dependencies come in the form of concrete class names. For example:

MyService service = new MyService();

As Scott Hanselman would say, “anytime you find yourself writing code like this, quit your job and go do something else.” No seriously, you should at least stop and acknowledge what this really is – a dependency on an implementation. Sure, factory classes and singletons come in handy to remove the need to new things up, but we still end up with a dependency – only now we’re dependent on the Singleton or the Factory.

Ideally, we want to declare a dependency on “some thing” without saying what that “some thing” is.

A simplified analogy

If you are hungry, you could ask your friend, “do you have a hamburger?” in which case you are expressing a need for an explicit implementation of something that satisfies hunger (a hamburger). If your friend has a hamburger, great! He would give it to you, you would eat it, and you wouldn’t be hungry anymore. Problem solved! But if your friend does not have a hamburger, you’d still be hungry – mainly because you were too specific in your request. Now, instead of asking for the hambuger, you could ask your friend, “do you have anything to eat?” In this case, you are expressing the “need” (food or something that satisfies hunger) vs. a concrete implementation. This way, if your friend has anything to eat he can give it to you (regardless of whether it is a hamburger or not) and you won’t go hungry. Any food would suffice.

What’s the point?

The point is that by being less specific in our request for food, we are more adaptable. The same is true with software. If we simply declare dependencies on contracts (interfaces), rather than implementations, our software becomes more adaptable and easier to change. Dependency Injection exists to help you do just that.

The goal of Dependency Injection (DI for short) is to separate behavior (or implementation) from dependency resolution, which is really just encapsulation – one of the main principles of computer science and object-oriented programming. I like to think of Dependency Injection as “intra-app SOA”; the end result being a highly decoupled application composed of “services” with explicit service boundaries and contracts (or service interfaces) where any given application layer has no knowledge of any other layers. It cares not the number of layers nor the implementation within each layer. Each layer simply depends on a contract and can be reasonably sure that at runtime there will be at least one implementation available to satisfy that contract. With Dependency Injection on our side, the above diagram might change to look something like this:

At first glance, this doesn’t look much different from the first diagram. We still have “dependencies.” However, now we are dependent on a contract, not an actual implementation. This provides enormous benefits to us as application developers because our application layers are now plug-n-play. They are hot-swappable like hard drives in a RAID configuration. We can change the implementation of a layer and as long as we implement the agreed upon interface, we can rest assured we won’t break something in another layer.

Of course, we still have to unit test our new layer to make sure we don’t have any internal bugs, but as long as other layers only depend on the interface (not the implementation) we know we can reliably swap out an implementation without affecting other parts of an application or system. Ideally, each implementation of an application layer becomes a “black box” to the other layers with which it interacts.

In the case of our MyService above. Instead of writing our code like: MyService service = new MyService();
Using Dependency Injection, we would instead write; IService service { get; set; }; as a property on our class or we would use constructor injection and have something like.

public class HomeController(IService service)
{

}

As you can see, we are now expressing a dependency on a contract (an interface) rather than an implementation and we are now “wired” for a Dependency Injection/IoC framework to resolve these dependencies for us without explicitly identifying them in our code.

You might say, “that’s all fine and good, but how do I make sure that my application is only dependent on contracts/interfaces?” More importantly, for existing applications that might not have been written this way, how do I find all the application dependencies and extract them into interfaces in order to move to a DI-friendly application architecture.

This is where being a .NET developer in this day and age makes your life much easier. Thanks to some new features in Visual Studio 2010, you can now answer those questions fairly easily. If you have one of the higher level VS2010 SKUs (Premium and Ultimate), you have the ability to create Application Architecture Layer diagrams. While you may have known that, you may not be aware that you can also validate an application against a layer diagram and have Visual Studio generate the dependencies between your layers so that you can see the dependencies between layers.

Using this feature, not only can you say, “my application should look like this” by creating an application layer diagram, but with the validation feature, you can ask the question, “does my application look like this?”

To get started with this feature, let’s take the following ASP.NET MVC project that I’ve setup as an example for this post. (I’ve circled the areas of immediate interest)

As you can see, I have actually organized my solution folders to mimic my application layering. We have a Repository/Data Access layer, we have a Services layer and we have a Presentation/UI layer. You’ll also notice that we have a Contracts project (or layer) which contains our interfaces.

So our dependencies go something like this:

Site (our ASP.NET MVC app) depends on an IUserService.
Our Services, depend on an IUserRepository and IUser.
Our Repositories depend on the IUser contract since that is the contract they return from their operations.

There are no dependencies between layers. They only depend on interfaces in the Contracts project.

You may have also noticed that there are four different “repository” projects and three different “services” projects. This is where the plug-n-play concept I discussed above comes in to play. ASP.NET MVC 2 comes with great support for Dependency Injection (which MVC 3 builds upon) which allows you to plug-in your DI/IoC framework of choice for all your DI needs. In my case, I’m using Autofac. ASP.NET MVC provides an extensibility point that allows you to say, “anytime my application needs something to satisfy a contract/interface, here’s where to find it.” That “where to find it” part is where an DI/IoC framework plugs-in to satisfy the dependencies of your application without having to declare explicit dependencies between your application layers and/or components.

Frameworks such as Autofac, Ninject, Castle Windsor, StructureMap and Unity, all have some concept of a “registry” which is basically an Interface-to-Implementation mapping or dictionary. With our MyService example above, we would be able to register our implementation MyService as the service that satisfies all dependencies on IService. Then, any time the application needs an implementation of IService, it will ask the DI container to provide one from its registry.

I won’t go into the details of how these dependencies get registered with or resolved by the DI/IoC frameworks. I’ll leave that for you to read about on your own or to explorer by digging through the attached sample code.

Instead, we’ll jump right into the benefits that using Dependency Injection provide.

So, in the diagram, we happen to have four different implementations of a DataAccessLayer.

DatabaseRepository – persists data to a SQL database
FakeRepository – fakes the peristence to an underlying data store (ideal for UnitTesting )
MongoDbRepository – persists data to a MongoDb database
XmlRepository – persists data to an Xml file

All four Repository projects implement the IUserRepository contract/interface that our Services layer depends on. This allows us to reliably swap out one for another without affecting any code in the services layer at all. So, it would be trivial to add another repository that persisted data to Oracle, SQL Azure, Amazon SimpleDB, Microsoft Access, Excel, a flat-file, what have you – just so long as the repository implements the IUserRepository interface, we’re good.

Likewise, we have three different implementations of our Services layer.

CachingService – retrieves data from an IUserRepository and caches the results
FakeUserService – a services that fakes retrieving data from an IUserRepository (again, ideal for unit testing)
UserService – same as the caching service (just without caching)

These services all implement the IUserService contract/interface that our presentation layer (UI) depends on.

Now, on to creating an application architecture and validating these stated dependencies.

From the Architecture menu in Visual Studio, you select New Diagram.

In the dialog box that opens, select Layer Diagram and give it an appropriate name.

You should end up with a blank architecture diagram that looks like this:

Now, using either the Toolbox or by right-clicking, we can begin adding layers to your diagram. After adding our application layers, our diagram should look like the following:

Now, to validate our architecture (and dependencies), we first need to tell Visual Studio, what code/projects are in what layers. We start by dragging our projects (or solution folders) into the associated application layer. For example, in my sample solution, I would drag the entire DataAccessLayer solution folder into the Data Access layer on the diagram:

Here’s what we should end up with when we’re done:

It looks very similar to when we started, but now we have a small indicator in the upper-right-hand corner which tells us how many projects are associated with each layer.

Now for the magic!

Simply, right-click anywhere in the white space on the application layer diagram and click Generate Dependencies.

If what I told you above about how my application is architected is true, then you should get an updated diagram that looks like the following:

Ah, now isn’t that diagram a breath of fresh air? In this diagram, Visual Studio is telling us there there are absolutely NO dependencies between the layers of our application! Rather, all application layers depend only on the Contracts project which is simply a collection of interfaces. This is the epitome of encapsulation and tells us that our application layers are decoupled from one another and can be swapped out for other implementations without risk to the rest of our application.

This is ideal for TDD scenarios and allows for simultaneous development on different application layers if we have already ironed out our contracts/interfaces. This means more parallel development can occur which can potentially reduce project timelines. And of course, with TDD on our side, we can reliably test individual layers and sign-off on them knowing that they are not dependent or affected by other layers/components whatsoever. End-result: higher-quality software developed in a shorter amount of time.

Now, if your application doesn’t look like this and looks more like the second picture with dependencies between every layer, don’t worry! Visual Studio can also help you find those dependencies so that you can factor out the concrete references into interfaces/contracts.

First, start by removing the dependencies from your diagram that you don’t want to have in your app – do this by rick-clicking on the dependency arrow and selecting Delete. Next, after you have removed all the unwanted dependencies, simply right-click anywhere in the whitespace of the diagram and select Validate Architecture. Visual Studio will proceed to build your projects and determine if your application actually validates against your stated (desired) architecture. If it does not, the violations will show up in the Error list window and you can start going through these dependencies and replacing the concrete implementations with contracts/interfaces. Additionally, application architects can use this functionality in conjunction with TFS to prevent code check-ins that violate an application architecture diagram.

With Visual Studio 2010, ASP.NET MVC 2 & 3 and the rich support for Dependency Injection, you can begin extracting interfaces from your concrete classes to remove the hard-dependencies in your apps, increase the maintainability of your apps. These features aren’t limited to MVC either. Many DI/IoC frameworks also work with ASP.NET WebForms as well as Windows Forms, WPF, and Silverlight. With these tools in your toolbox you too can begin enjoying the bliss that is a truly decoupled application that is easy to maintain, easy to test, easy to change and easy to replace when the next technology comes along!

Download the sample code: MvcDI.zip

For more reading on ASP.NET MVC and Dependency Injection I suggest you check out the following blogs:

http://weblogs.asp.net/scottgu/
http://hanselman.com
http://haacked.com
http://bradwilson.typepad.com/

Happy Injecting!

Recreating the MobileMe Gallery in Silverlight – Part 1 Updated

Thu, 01 Jul 2010 15:49:12 GMT

Originally, in Part 1 of my soon-to-be multi-part series on recreating the MobileMe Gallery in Silverlight I used a separate WCF project (under .NET 3.5) to create my Gallery Service to serve as a proxy between my Silverlight client and the Apple MobileMe service that provides MobileMe Gallery data in JSON format.

Since then, I have upgraded the project to Silverlight 4 and .NET 4 and have decided to move the service code into the Web project that hosts the Silverlight application. More importantly, I have changed the service to use the new config-free RESTful model available in WCF 4.

You can download the latest source from CodePlex here: http://silverlightmobileme.codeplex.com/SourceControl/list/changesets

Now, our web project looks like this:

Now, our service code is as simple as one file – GalleryService.cs which is as follows:
(Notice no .svc file needed anymore thanks to the WebServiceHostFactory in WCF 4)

using System;
using System.Configuration;
using System.IO;
using System.Net;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Web;

namespace Gallery.Web.Services
{
	[ServiceContract(Namespace = "urn:silverlightmobileme.codeplex.com")]
	[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
	[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
	public class GalleryService
	{
		string galleryUrlFormat = ConfigurationManager.AppSettings["GalleryUrlFormat"];
		string albumUrlFormat = ConfigurationManager.AppSettings["AlbumUrlFormat"];

		[WebGet(UriTemplate = "/{username}",
				ResponseFormat = WebMessageFormat.Json,
				BodyStyle = WebMessageBodyStyle.Bare)]
		[OperationContract]
		public Stream GetGallery(string username)
		{
			// TODO: add exception-handling using WebFaultExceptions and HttpStatusCode enumeration
			var webClient = new WebClient();
			string photocastUrl = string.Format(galleryUrlFormat, username);
			return webClient.OpenRead(photocastUrl);
		}

		[WebGet(UriTemplate = "/{username}/{id}",
				ResponseFormat = WebMessageFormat.Json,
				BodyStyle = WebMessageBodyStyle.Bare)]
		[OperationContract]
		public Stream GetAlbum(string username, string id)
		{
			var webClient = new WebClient();
			string albumUrl = string.Format(albumUrlFormat, username, id);
			return webClient.OpenRead(albumUrl);
		}

	}
}

The magic of WCF 4 config-free RESTful services is handled in Global.asax.cs

using System.Web;
using System.ServiceModel.Activation;
using System.Web.Routing;
using Gallery.Web.Services;

namespace Gallery.Web
{
	public class Global : HttpApplication
	{
		public static void RegisterRoutes(RouteCollection routes)
		{
			//routes.Add("GalleryService", new Route(
			//    "GalleryService",
			//    new CustomRouteHandler("~/Services/GalleryService.svc")
			//));
			routes.Add("Default", new Route(
				"{username}",
				new CustomRouteHandler("~/Default.aspx")
			));
			RouteTable.Routes.Add(new ServiceRoute("GalleryService", new WebServiceHostFactory(), typeof(GalleryService)));
			RouteTable.Routes.Add(new ServiceRoute("ConfigService", new WebServiceHostFactory(), typeof(ConfigService)));
		}

		protected void Application_Start()
		{
			RegisterRoutes(RouteTable.Routes);
		}
	}
}

Here, after registering our main route for the gallery, we simply add two more routes (of type ServiceRoute), passing it the path we want to map to our services, then the ServiceHostFactory (which handles the config-free RESTful WCF), followed by the type of the service.

That’s it!

Now our service has nice RESTful service endpoints and there is no special WCF configuration needed and it just works.

Try out the new config-free RESTful service here: http://gallery.restazured.com/GalleryService/emily_parker

With WCF 4 config-free RESTful services, we also get handy helper pages for our service consumers to help them understand how to call our services and what type of response to expect.

Try it out here:

http://gallery.restazured.com/GalleryService/help
http://gallery.restazured.com/ConfigService/help

As you’ll see, this displays what operations are available and even provides sample responses. Now that’s RESTful!

Stay tuned for Part 2 where we’ll cover the details of the Silverlight project (now Silverlight 4) where we’ll be using MEF, MVVM and our config-free RESTful WCF services.

Create your own branded url-shortener in under 10 minutes using ASP.NET MVC 2

Thu, 10 Jun 2010 07:41:13 GMT

UPDATE: bit.ly now allows custom domains without having to pay. Additionally, there are services like Droplr, CloudApp and JumpShare. Currently, I use Droplr for my personal short links and file sharing. and we use CloudApp for my company short links and file sharing. This article mainly discusses how you could have achieved this in the past before bit.ly made branded short domains available and before these other services existed.

Overview

These days, URL shortener services like bit.ly are a dime a dozen. However, the latest craze are branded, shortened URLs like amzn.to instead of amazon.com, nyti.ms instead of nytimes.com, tcrn.ch instead of techcrunch.com, huff.to instead of huffingtonpost.com. You’ve probably seen URLs like these floating around Twitter, Facebook, IM and even email. These abbreviated domains offer the same benefits of a short URL provided by a service like bit.ly (ideal for use on Twitter, etc.) without sacrificing the branded experience and marketing that is achieved by using a “full-size” URL. They are the “compact car” of URLs and they are your friend!

Hence the reason for new services like bitly.Pro. In case your unfamiliar, bitly.Pro is a new service offered by bit.ly that allows companies and individuals to brand their shortened URLs using their own abbreviated domains. Amazon.com already uses http://amzn.to. The New York Times uses http://nyti.ms. Many other companies are using bitly.Pro as well. You may already have your very own abbreviated domain that you’d like to use to brand your shortened urls. If not, go get one. So, like me, you figure you’ll head on over to http://bitly.pro/signup to sign up for the free beta only to find out that the beta is closed to new users at this time. (Update: bitly.Pro beta has re-opened and you can signup here: http://bit.ly/a/pro_request).

But wait…before you begin cursing bit.ly about their closed beta, allow me to present a quick solution that still allows you to brand your shortened links and track traffic to your branded service. It won’t give you the analytics regarding how your content is begin distributed across Twitter, Facebook, etc. (although you could build that in fairly easily), but for someone who just wants a simple branded url shortener solution, it will fit the bill.

So, without further ado, here’s the simple ASP.NET MVC-based solution that provides a simple bitly.Pro-like solution of your very own. Best of all, you can get it going in under 10 minutes. Of course, you could build the same solution entirely with javascript and an html page, but where’s the fun in that?

Getting Started

The easiest way to get started is to head over to http://www.asp.net/ and use the Web Platform Installer to install Visual Web Developer 2010 and ASP.NET MVC 2.

Once you’ve got these installed, fire up VS2010 and add a new “ASP.NET MVC2 Empty Web Application.”

You should end up with something that looks like this:

The Controller

The first thing we want to do is setup a controller to handle our requests, so right-click the Controllers directory in the Solution Explorer and select Add > Controller.

We’ll name ours “HomeController” and, since we won’t be doing anything with an actual model, we’ll leave the box unchecked that prompts us to create actions methods for Create, Update and Delete scenarios.

Our HomeController is going to be very simple and will look like this:

using System.Web.Mvc;

namespace bitlyProSimple.Controllers
{
	[HandleError]
	public class HomeController : Controller
	{
		public ActionResult Index(string linkid)
		{
			Response.StatusCode = 302;
			Response.RedirectLocation = (string.IsNullOrWhiteSpace(linkid)
								 ? "http://anderly.com"
								 : string.Format("http://bit.ly/{0}", linkid));
			return new ContentResult();
		}

	}
}

Our controller is going to accept a string (the linkid) and then contstruct a 302 redirect to bit.ly to finish the job. This allows us to simply use the bit.ly analytics when you have a bit.ly account.

As you can see, we are using bit.ly, but you could very well use any other URL shortener service. Essentially, what we’ll be doing is mapping requests that match the format http://[yourdomain]/[linkid] to our HomeController which will accept the linkid as a parameter and then prepare to forward our request to bit.ly. So in my case, my abbreviated domain is http://ander.ly. So, I’ll be mapping any requests that match the http://ander.ly/[linkid] format to be forwarded to http://bit.ly/[linkid].

In case there isn’t a link id, we will simply redirect to the blog home page.

Wrapping Up

Last but not least, we need to head on over to Global.asax.cs to setup our Routes and we’ll be done.

Open up Global.asax.cs and replace the default route of:

{controller}/{action}/{id}

with

{linkid}

That’s it!

Fire up the solution and test it out for yourself. Don’t forget to bookmark the location of this post: http://ander.ly/13UVK

Now any requests that come in that match the format http://ander.ly/[linkid] will be sent to our HomeController which will extract the linkid and construct a new bit.ly URL of the same format and do a simple redirect for the user.

With this solution, we can simply use the existing bit.ly URL shortener service without having to roll our own and we can simply replace bit.ly in any shortened URLs with our very own branded abbreviated domain.

Now you too can start branding the links you share.

Let the shameless self-promotion begin!

Source Code

bitlyProSimple.zip

Silverlight MobileMe Gallery now on CodePlex!

Tue, 24 Nov 2009 23:49:44 GMT

I have published the initial source for my project “Recreating the MobileMe Gallery in Silverlight 3” on CodePlex.

You can now access the Alpha release of the code here: http://silverlightmobileme.codeplex.com/

I will be updating I have updated the working example (http://gallery.restazured.com/emily_parker) as well to reflect the latest version on CodePlex.

Please leave your comments and let me know if you have any questions…or if you would like to be a contributor to the project.

Enjoy!

Recreating the MobileMe Gallery in Silverlight 3 – Part 1

Wed, 21 Oct 2009 07:15:53 GMT

In my introductory post I detailed the features needed to successfully recreate the MobileMe Gallery in Silverlight 3. While a bit late, this is Part 1 of a multi-part series where I will detail out step-by-step the process of Recreating the MobileMe Gallery in Silverlight 3.

The Tools

I will assume you already know what tools are required to do Silverlight development. If not, go here: http://timheuer.com/blog/articles/silverlight-get-started-part-1-hello-world.aspx

For this post, you will also need a tool such as Fiddler or Web Development Helper in order to do some HTTP tracing.

Getting Started

For this post we are going to focus on the initial plumbing required to retrieve the data from the MobileMe Gallery. The first thing we’ll need is the underlying data (album definitions, etc.) stored on the MobileMe site so that we can populate our Silverlight Gallery. To do so, we’ll need to see what the Apple MobileMe Gallery does under the covers.

So, if you head over to the MobileMe Sample Gallery you should see the following:

Click Here for a Larger View

In order to find out if the underlying album data is accessible, I’m going to use the Web Development Helper IE Add-In to do some HTTP Tracing on the Apple MobileMe Gallery. After firing up Web Development Helper and turning on HTTP logging (HTTP > Enable HTTP Logging), I can then refresh the browser and should see a long list of HTTP requests in the console like so:

Click Here for a Larger View

If you scroll up in the list, you should find the entry highlighted above. This is the main request we are concerned with. Double-clicking on this request and then selecting the “Reponse Content” tab at the bottom provides more details.

Click Here for a Larger View

There you have it! A good ‘ol fashion HTTP GET request returning JSON. A quick glance over this data shows you that this JSON response contains the gallery details we’re after. So far, so good.

Getting the Data

Now we know where to get the data, but how do we get it? You may say just use the WebClient class in Silverlight to do an HTTP GET request. However, Silverlight requires client access policy files for cross-domain HTTP requests in order to provide a security mechanism to service authors to specify who can and cannot access their services. There are some public web services that already have these files in place for Flash, but Silverlight requires its own flavor. Additionally, the Apple MobileMe Gallery doesn’t have one. Therefore, we need our own service (WCF service that-is) that will serve as a proxy between the Apple MobileMe Gallery service and our Silverlight MobileMe Gallery client. In short, we’ll call our WCF service (that we’ll author) and our service will call the Apple MobileMe Gallery service. This is a common workaround as the Silverlight client performs the check for the client access policy file while WCF doesn’t do any checks because it’s a server technology.

Writing our Service

We’ll start off by creating an empty Visual Studio Solution called Gallery. Then, we’ll add a new “WCF Service Application” project to the solution – giving it the name Gallery.Service. Here is the structure of the service project after being built out.

IGallery.cs is our service contract that will define the signatures for the methods we’ll need to call to retrieve gallery and album details. It looks like this:

IPolicyProvider.cs is our policy provider contract that will define the signature for the method that will return the Silverlight client access policy file. It looks like this:

As you’ll notice, both of these interfaces are using the WebGet attribute to map specific UriTemplates to these service methods. For instance, in IPolicyProvider, we are saying if an HTTP GET request comes in to our root service folder followed by “/clientaccesspolicy.xml,” then that means run this method. We do this because anytime a Silverlight client makes any cross-domain request, it first makes a request to “clientaccesspolicy.xml” to see if it has rights to access the service.

Finally, our implementation of Gallery.svc.cs looks like this:

Click Here for a Larger View

Here, you’ll notice that our GetGallery and GetAlbum methods are simply using WebClient to call the gallery service and album service using url formats defined in Web.config. These are:

Click Here for a Larger View

You’ll notice that the first entry (PhotocastUrlFormat) is the same format as the HTTP request we observed using Web Development Helper. And we simply, leave a curly-brace placeholder for the MobileMe username which we’ll substitute at run-time.

Minus WCF configuration settings which are included in the source, we now have a working service which will forward calls to the Apple MobileMe service to retrieve gallery and album details. This service is currently available at http://igallery.restazured.com/GalleryService.svc

Feel free to wire up your WCF client of choice (Silverlight, WPF, etc.) add a service reference and try calling one of the methods passing your own MobileMe username or the sample “emily_parker”. You can even see the client policy provider in action here: http://igallery.restazured.com/clientaccesspolicy.xml

Wrapping Up

Now, we have a WCF service setup to forward our requests for MobileMe Gallery and Album details to the Apple MobileMe Service. In Part 2, we’ll start creating the Silverlight project to call our WCF service and start building the home page to look like: http://gallery.me.com/emily_parker

In the meantime, checkout the working example (using Silverlight 3) here: http://gallery.restazured.com/emily_parker

Silverlight Midpoint Rounding Solution

Sat, 08 Aug 2009 07:20:40 GMT

As a follow up to my previous Shakespearean-titled post on rounding, I decided to provide a quick follow up to provide a solution for midpoint rounding in Silverlight. Based on some traffic that I’ve been getting it looks like people are searching for a rounding solution in Silverlight since the Silverlight core framework lacks the traditional Math.Round() overloads we get with the full .NET framework that allow specifying the desired midpoint rounding behavior.

Remember, Silverlight contains a pared-down version of the .NET framework.

So, here is a simple solution to take what we learned in the previous post and develop our own MathExt helper class that provides static Round methods similar to the Math.Round() methods that allow us to specify the desired midpoint rounding behavior. Using this you can now control midpoint rounding behavior in Silverlight.

public enum MidpointRounding
{
	ToEven,
	AwayFromZero
}

public static class MathExt
{
	public static decimal Round(decimal d, MidpointRounding mode)
	{
		return MathExt.Round(d, 0, mode);
	}

	/// <summary>
	/// Rounds using arithmetic (5 rounds up) symmetrical (up is away from zero) rounding
	/// </summary>
	/// <param name="d">A Decimal number to be rounded.</param>
	/// <param name="decimals">The number of significant fractional digits (precision) in the return value.</param>
	/// <returns>The number nearest d with precision equal to decimals. If d is halfway between two numbers, then the nearest whole number away from zero is returned.</returns>
	public static decimal Round(decimal d, int decimals, MidpointRounding mode)
	{
		if (mode == MidpointRounding.ToEven)
		{
			return decimal.Round(d, decimals);
		}
		else
		{
			decimal factor = Convert.ToDecimal(Math.Pow(10, decimals));
			int sign = Math.Sign(d);
			return Decimal.Truncate(d * factor + 0.5m * sign) / factor;
		}
	}
}

Or if you prefer an extension-method approach:

public enum MidpointRounding
{
	ToEven,
	AwayFromZero
}

public static class DecimalExtensions
{
	public static decimal Round(this decimal d, MidpointRounding mode)
	{
		return d.Round(0, mode);
	}

	/// <summary>
	/// Rounds using arithmetic (5 rounds up) symmetrical (up is away from zero) rounding
	/// </summary>
	/// <param name="d">A Decimal number to be rounded.</param>
	/// <param name="decimals">The number of significant fractional digits (precision) in the return value.</param>
	/// <returns>The number nearest d with precision equal to decimals. If d is halfway between two numbers, then the nearest whole number away from zero is returned.</returns>
	public static decimal Round(this decimal d, int decimals, MidpointRounding mode)
	{
		if (mode == MidpointRounding.ToEven)
		{
			return decimal.Round(d, decimals);
		}
		else
		{
			decimal factor = Convert.ToDecimal(Math.Pow(10, decimals));
			int sign = Math.Sign(d);
			return Decimal.Truncate(d * factor + 0.5m * sign) / factor;
		}
	}
}

Remember, the non-extension-method version could easily be used in any legacy .NET projects that still may be on 1.0 or 1.1 to give us the ability to control midpoint rounding behavior which didn’t arrive in the framework until .NET 2.0.

Once again, Happy Rounding!

To round ‘up’, or to round ‘down’: that is the question

Tue, 28 Jul 2009 18:16:23 GMT

In troubleshooting a rounding discrepancy a couple of years ago in a software component, I discovered what may be a lesser known fact – the Microsoft programming languages (VBScript, VBA, VB6, VB.NET, C#, etc.) implement what is commonly referred to as “banker’s rounding” or “rounding to the nearest” – which follows the IEEE Standard 754, section 4. My reason for posting about this is that, in some cases, this can yield unexpected results.

As we all know traditional arithmetic rounding (the kind we all learned in grade school) says .5 always rounds up. However, the IEEE Standard 754, section 4 does not implement this form of symmetrical arithmetic rounding.

Here’s the explanation:

Given the range 0 – 1

[.1 .2 .3 .4] – always rounds down

[.6 .7 .8 .9] – always rounds up

However, .5 is the midpoint between 0 and 1 and always rounding .5 in the same direction results in a bias that grows with the more numbers you add together.

So, the IEEE Standard says that one way to minimize the bias is with “banker’s rounding” which is as follows:

Banker’s rounding rounds .5 up sometimes…and down sometimes. I know it sounds inconsistent, but the convention is to round to the nearest even number, so that both 1.5 and 2.5 round to 2, and 3.5 and 4.5 both round to 4. Banker’s rounding is symmetric.

Here are a few sample results using the IEEE Standard (banker’s rounding):

Value	Rounded to 2 Decimal Places
0.1250	0.12 (Rounds down when the number to the left of the 5 is even)
0.1350	0.14 (Rounds up when the number to the left of the 5 is odd)
0.1251	0.13 (Rounds up because the 1 to the right of the 5 since it is not exactly the midpoint between .12 and .13)
0.125000001	0.13 (Rounds up for the same reason as the one above)

You may already be aware of this seemingly odd behavior, but many of you may be surprised by this result (as I was).

In any case, I wanted to share my findings in case you were expecting a rounding implementation different than that which is actually implemented in the products/programming languages you are using.

Microsoft acknowledges that their rounding implementation is inconsistent across products (VBScript, VBA, VB6, .NET, SQL Server, EXCEL) and says that this is only done for historical reasons. Here is the link to the Microsoft KB article that details the different rounding implementations in their products and how to implement a custom rounding method based on your need: http://support.microsoft.com/?kbid=196652

Here’s the breakdown of the rounding implementations for Microsoft Products:

Product	Implementation
VBScript, VBA, VB 6.0	Banker’s Rounding
Excel Worksheet	Symmetric Arithmetic Rounding
SQL Server	Either Symmetric Arithmetic Rounding or Symmetric Round Down (Fix) depending on arguments
.NET 1.0, 1.1	Banker’s Rounding
.NET 2.0 (or greater)	Banker’s Rounding but provides additional overloads to the Math.Round() method for specifying desired midpoint rounding behavior.

So, the good news is that if you are using SQL Server or Excel rounding, you are fine – you’re gonna get good ‘ol traditional arithmetic rounding (.5 always rounds up).

Also of interest, is that the Java Math library (including JavaScript) implements Asymmetric Arithmetic Rounding.

The key difference between this and Symmetric Arithmetic Rounding (the kind we learned in grade school) is as follows:

Symmetric Arithmetic Rounding always rounds up, where “up” is defined as “away from zero.”

So, 0.1250 rounds to 0.13 and -0.1250 rounds to -0.13.

Asymmetric Arithmetic Rounding always rounds up, where “up” is defined as “heading towards positive infinity.”

So, 0.1250 rounds to 0.13 and -0.1250 rounds to -0.12 (i.e. in a positive direction).

As for my case, I wanted Symmetric Arithmetic Rounding and followed the instructions in the KB article above for implementing my own custom Round method to achieve this result.

Here is the final implementation:

/// <summary>
/// Implements alternate rounding methods, in contrast to Decimal.Round()
/// and Math.Round(), which implement banker's rounding (5 rounds to even).
/// See http://support.microsoft.com/?kbid=196652 for other methods.
/// </summary>

public static class MathExt

{

	/// <summary>
	/// Rounds using arithmetic (5 rounds up) symmetrical (up is away from zero) rounding
	/// </summary>
	/// <param name="d">d: A System.Decimal number to be rounded.</param>
	/// <param name="decimals">The number of significant fractional digits (precision) in the return value.</param>
	/// <returns>The number nearest d with precision equal to decimals. If d is halfway between two numbers, then the nearest whole number away from zero is returned.</returns>
	public static decimal Round(decimal d, int decimals)
	{
		decimal factor = Convert.ToDecimal(Math.Pow(10, decimals));
		int sign = Math.Sign(d);
		return Decimal.Truncate(d * factor + 0.5m * sign) / factor;
	}
}

I would encourage you to review any rounding code in your apps and verify that the rounding implementation is the one you expected.

Happy Rounding!

Recreating the MobileMe Gallery in Silverlight 3

Thu, 23 Jul 2009 06:48:10 GMT

Background:

Even though I am an avid fan of many Microsoft products (especially their developer tools), Apple has just done certain things “right” for the home user where it seems Microsoft has struggled or been late to the table. As you may have read on my About Me page, I use Macs at home. They have their own set of issues, but for most of the “home stuff” I need a computer for (photos, movies, music) they do the job and they do it well.

One of my favorite tools is iPhoto (Aperture too) and the one-click publishing to MobileMe Gallery – Apple’s web-based photo/movie gallery tool that creates good looking, easy-to-use, web-based galleries that I use to share photos and movies with friends and family. Take a look for yourself and visit the MobileMe sample gallery for the ficticious user “Emily Parker.”

Problem:

So for the most part, the features here meet my needs with one exception – movies require the Apple QuickTime plug-in to view them. Well, you may say, ‘no big deal’ and you’re right…unless you’re one of my many family members who is still on Windows 2000 (or earlier) and can’t install the latest version of QuickTime because it requires Windows XP. So, needless to say, a fair amount of people are unable to view any of the movies that I publish to MobileMe Gallery. So, I end up having to also publish them to YouTube as well (which is a kind of a hassle). Not to mention that they don’t get the same focused user experience of my photos and movies in one nice and neat presentation and not a bunch of other junk detracting from the experience. I know, I know, my family members should upgrade, but the simple fact of the matter is that many of them are happy with their computers and they’re not going to upgrade just so they can view my measly ol’ MobileMe Gallery.

Solution:

So, now for the solution. I attended a Guerilla.NET event back in March (put on by DevelopMentor) and while at the class I got up to speed on Silverlight 2 as well what features were coming in Silverlight 3. Voila! Silverlight 3 was going to support additional media formats including MPEG-4, which is the format used by iTunes and MobileMe Gallery. So, you see where I’m going. My solution would be to use the features of Silverlight 3 to create a solution that would allow my family to view the MPEG-4 format movies stored on MobileMe Gallery using the Silverlight 3 plug-in (once it became available). I knew it would be sometime before it came out of beta and I knew it would take me awhile to develop, so I knew I had some time.

But remember, I didn’t want to sacrifice the clean, simple, focused UX of MobileMe Gallery by simply giving my family a silverlight media player as an alternate location to view movies. Plus, there are already Silverlight media players that would handle the job once Silverlight 3 was available. I wanted my family to have the full, beautiful MobileMe Gallery experience in all its glory. So, I decided I would recreate the MobileMe Gallery using Silverlight. I figured it would be a good learning experiment since I hadn’t played with Silverlight much before the class.

So, this is the introductory post of a multi-part series where I will detail out step-by-step the process of Recreating the MobileMe Gallery in Silverlight 3. I hope you’ll follow along as I go down to meticulous detail to ensure my Silverlight Gallery looks exactly like Apple’s MobileMe Gallery.

Key Features and Success Criteria:

1. Play MPEG-4 (.m4v) files using Silverlight without the need for QuickTime

2. Photo Album and Movie “Scrubbing” (if you view the sample above, you’ll see what I mean when you mouse over an album or movie)

3. Full featured photo album with all the features (and views) of the one built-in to MobileMe Gallery

4. Utilize the photos/movies already stored on MobileMe Gallery (no separate upload or storage required…we’ll do this by tapping into the existing APIs and RSS/JSON feeds that MobileMe uses itself by using a little Fiddler detective work)

5. 100% Silverlight implementation

The goal in one sentence is by the time we finish we should have an exact replica, feature-for-feature match of the MobileMe Gallery using Silverlight 3 (see below for a preview).

As for legal disclaimer, I should note that Apple, the Apple logo, MobileMe, the MobileMe logo, and MobileMe Gallery are registered trademarks of Apple.

Also, I am a multi-Mac owner, multi-iPhone owner, paying member of the iPhone developer program and MobileMe subscriber, so Apple don’t sweat this too much. I’m still a big fan, but needed a good project to develop my Silverlight skills and figured recreating the beautiful MobileMe Gallery would be an excellent challenge.

Here’s the breakdown:

Part 1: Getting Started – WCF and the initial plumbing required to retrieve the data from the MobileMe Gallery
Part 2: The Silverlight Project (Coming Soon) – creating the Silverlight project to call our WCF service and start building the home page
…

Please check back for updates as I’ll continue to update this post with the links to new segments as I complete them.

Adam Anderly

Publisher is gone. Here’s why I built PubKeep.

First, save the files

Then, keep editing

The people who helped build it

Launch

What’s next

Cross-Cutting Concerns with MediatR Pipeline Behaviors

Laravel User Timezone Aware Trait

Useful Laravel Model Traits: Gravatar

Laravel Transformable – An Eloquent Model Trait for Consumable Models

Gravity Forms + Microsoft Dynamics CRM

Key Features

DNS from the command line: dnsimple-cli for Node.js

WooCommerce MailChimp 1.2 Released

WooCommerce MailChimp Update

Version 1.2

Trello Board

WooCommerce MailChimp Pro

What about the free version?

That’s all for now!

WooCommerce MailChimp 1.1 Released

WooCommerce MailChimp WordPress plugin now on MailChimp Integrations Directory

New WordPress Plugin: Wistia Responsive

Multisite

Feedback

Twitter

Installation

Changelog

1.0

New WordPress Plugin: WooCommerce MailChimp

Features

WooCommerce Event Selection

Works with MailChimp Interest Groups

Multisite

Feedback

Twitter

Translations

Installation

Usage

Screenshots

Sublime Text 2/Textmate port of studiostyl.es “Son of Obsidian” theme for Visual Studio

Why Microsoft Developers Should Care About Node.js

Status of SimpleMembership.Mvc3 and SimpleMembership.Mvc3.Sample

Expansive 1.5 Released

Expansive – A powerful string expansion library for .NET you never knew you always wanted.

Expansive

1. Solve web.config / app.config nightmares

2. String Formatting

3. Model-based Templating

Additionally, Expansive can be used for model-based templating using the Expand(object model) method.

Using SimpleMembership in MVC3

Creating your MVC 3 Application

Creating your database (SqlCompact4)

Updating Web.config connection string

Now that our database is created, we need to update our connection string in Web.config to point to our SqlCompact4 database we just created.

Installing & Configuring SimpleMembership

That’s It!

SimpleMembership.Mvc3 – 1.1 Published

If you’re unfamiliar with SimpleMembership.Mvc3, please see this post.

Update: May 18, 2011 – Version 1.1 published to NuGet.org

SimpleMembership.Mvc3 NuGet Package

SimpleMembership.Mvc3 – 1.0

Update: February 28, 2011 – Version 1.0 released

Features

Usage

Using the IWebSecurityService abstraction

ASP.NET MVC, Dependency Injection and The Bliss of Truly Decoupled Applications

A simplified analogy

What’s the point?

Recreating the MobileMe Gallery in Silverlight – Part 1 *Updated*

Create your own branded url-shortener in under 10 minutes using ASP.NET MVC 2

Overview

Getting Started

The Controller

Wrapping Up

Source Code

Silverlight MobileMe Gallery now on CodePlex!

Recreating the MobileMe Gallery in Silverlight 3 – Part 1

The Tools

Recreating the MobileMe Gallery in Silverlight – Part 1 Updated