Rory Primrose

I have released the new versions of my BE related projects in CodePlex.

Neovolve.BlogEngine.Web 1.1

Neovolve.BlogEngine.Net.Web 1.1 contains a redirector module that translates Community Server url formats into BlogEngine.Net urls. This module will redirect Community Server pages, posts, month post lists, day post lists, tags, syndication and tagged syndication urls to the most appropriate location in BlogEngine.Net. BlogEngine.Net relies on its own friendly written urls when the urls are processed. This module cannot rewrite Community Server urls as BlogEngine.Net will not be able to understand what the requested resource is. The module must redirect requests to the equivalent BlogEngine.Net friendly url so that BlogEngine.Net url writing can occur such that resources are resolved correctly.

In Community Server, tags and categories are the same thing and it supports tag filtering by allowing multiple tags to be defined. BlogEngine.Net supports both tags and categories as separate entities and has a concept of a category hierarchy, but doesn't support tag filtering. When a Community Server url is encountered where multiple tags are defined, the first Community Server tag in the url that can be matched to either a BlogEngine.Net category or tag will be the resource used to response to the client request. Preference is given to categories over tags.

Neovolve.BlogEngine.Extensions 1.2

Contains updated CatTagLink, Snippets and SyntaxHighlighter extensions.

Tags: BlogEngine.Net

I was reminded this morning of an email that I sent to the junior developers on my team when they joined us. It is an overview of some of the development practices, patterns and products that they would get exposed to on our project. I have included it here as a reference collection for others.

Principles and Patterns

These are things that I often use and are still learning to use.

• SOLID – Originally put together by Bob Martin (http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod). A good overview to read is at http://www.davesquared.net/2009/01/introduction-to-solid-principles-of-oo.html.
• LoD - Law of Demeter (or Principle of Least Knowledge) (http://en.wikipedia.org/wiki/Law_of_Demeter). Often referred to as loose coupling.
• DRY – Do not Repeat Yourself (http://en.wikipedia.org/wiki/Don't_repeat_yourself). Many say that this principle should not apply to unit testing.
• DIP – Dependency Injection Pattern which is the D in SOLID. Jeremy Miller has a good overview at http://codebetter.com/blogs/jeremy.miller/archive/2005/10/06/132825.aspx. Dependency Injection frameworks (Unity, Castle Windsor, Spring.Net etc) often use a Service Locator pattern for their implementation. Like Jeremy, my preference is constructor injection because it defines a contract of how to use a class whereas setter (or property) injection doesn’t. Setter injection should only be used for optional dependencies and usually requires additional defensive coding.
• TDD – Test Driven Development (http://en.wikipedia.org/wiki/Test-driven_development)
• DDD – Domain Driven Design is gaining popularity but still seems to be not well understood or widely used (including by me). See http://en.wikipedia.org/wiki/Domain-driven_design and MSDN Mag introduction article at http://msdn.microsoft.com/en-us/magazine/dd419654.aspx.
• AOP – Aspect Orientated Programming (http://en.wikipedia.org/wiki/Aspect-oriented_programming)
• Service Locator – See http://en.wikipedia.org/wiki/Service_locator_pattern and http://msdn.microsoft.com/en-us/library/cc707905.aspx. Keep in mind that this is starting to be considered as an anti-pattern and should probably be avoided in favour of Dependency Injection.
• GOF - Gang of Four patterns (http://www.dofactory.com/Patterns/Patterns.aspx). I tend to use the following in GoF:
  • Factory Method- See http://www.dofactory.com/Patterns/PatternFactory.aspx
  • Facade - See http://www.dofactory.com/Patterns/PatternFacade.aspx
  • Proxy – See http://www.dofactory.com/Patterns/PatternProxy.aspx
  • Chain of Responsibility – See http://www.dofactory.com/Patterns/PatternChain.aspx. While I haven’t used this one, it would be very helpful for processing items in a queue.
• Testing - http://en.wikipedia.org/wiki/Software_testing. Lots of areas to cover such as white box, black box, grey box, regression, non-functional (performance, load, globalisation), unit vs. integration testing, code coverage etc.
  • Mocking – Used to provide mock dependencies for unit testing. See http://en.wikipedia.org/wiki/Mock_object, http://martinfowler.com/articles/mocksArentStubs.html and http://msdn.microsoft.com/en-us/magazine/cc163904.aspx.
  • Stubbing – Used to provide a dependency for unit testing with predetermined answers and behaviour. See http://en.wikipedia.org/wiki/Test_stubs.

Jeremy Miller also writes a series called Patterns in Practice for MSDN Magazine (see list at http://msdn.microsoft.com/en-au/magazine/cc720886.aspx). They are all a good read, especially:

• Cohesion and Coupling - http://msdn.microsoft.com/en-au/magazine/cc947917.aspx
• Design for Testability - http://msdn.microsoft.com/en-au/magazine/dd263069.aspx

Tools

These are tools that are good to get experience using. Most of them relate to the patterns above. There are other tools used like ReSharper, dotTrace, StyleCop, WinMerge etc, but they don’t have the up skill requirement that the following tools do.

• Reflector - http://www.red-gate.com/products/reflector/. This is a .Net assembly disassembler that has really good search and analysis tools. This is the most important development tool for me. It is as critical to my development as Visual Studio itself.
• Rhino Mocks - http://ayende.com/projects/rhino-mocks.aspx. Mocking framework for testing.
• Unity - http://www.codeplex.com/unity. Dependency Injection framework included in Microsoft Patterns and Practices Enterprise Library.
• PostSharp - http://www.postsharp.org/. Used for AOP.
• MSTest – Unit testing integrated into Visual Studio.

Probably the most important tool to start using is Rhino Mocks. The only way to get experience with it is to start writing unit tests in VS. See the documentation at http://ayende.com/wiki/Rhino+Mocks+Documentation.ashx.

Tags: Useful Links, Performance, StyleCop, ReSharper, Unit Testing, PostSharp, AOP, Dependency Injection, Unity

I have created a new version of my SyntaxHighlighter extension for BlogEngine.Net that works with SyntaxHighlighter 2.1. It will work with earlier PRE tag formats from version 1.5 by enabling the Legacy Support option.

This version allows you to define the following options. The default values for the extension are indicated.

Brushes are automatically determined by finding script files that are in the format shBrush*.js. If I don’t want a brush to be included, I just rename its extension from .js to .js.ignored.

SyntaxHighlighter.cs (8.59 kb)

Tags: BlogEngine.Net

I have updated my snippets extension for BlogEngine.Net. There are minor bug fixes to a regex that finds html tags and PRE tags are now skipped.

Snippets.cs (12.18 kb)

Tags: BlogEngine.Net

Like Dave, I was keen to upgrade my site to the latest BlogEngine.Net release (download here). I did find a few issues with the upgrade though as I was also migrating from ASP.Net user/roles management to the BlogEngine.Net implementation. To help with this process, I wrote a SQL script that did the following:

1. Enabled error logging (useful for troubleshooting)
2. Removed the Commentor extension configuration (new comment support is in this release)
3. Upgraded post contents to migrate from SyntaxHighlighter 1.5 to 2.1
4. Migrated my permissions for the site from ASP.Net to BlogEngine.Net user/roles (Note: This resets the admin password to blank which will default it to "admin")
5. Removed all the ASP.Net user/roles objects from the database.

Script is attached.

BE Upgrade 1.5 - 1.6.sql (19.67 kb)

Tags: ASP.Net, BlogEngine.Net