Simply download the latest source code from CodePlex (I used changed set 88372a0b4ab9).
Like it is mentioned on CodePlex you have to obtain the NuGet Packages first and after that you can build.

build RestorePackages
build

To test some things out I created a simple console application (inside the same solution) and added the following references with the following code

static void Main(string[] args)
{
   var baseAddress = "http://localhost:7777/";
   var config = new HttpSelfHostConfiguration(baseAddress);
   config.Routes.MapHttpRoute(
      name: "DefaultApi",
      routeTemplate: "api/{controller}/{id}",
      defaults: new
      {
         id = RouteParameter.Optional
      });

   var server = new HttpSelfHostServer(config);
   server.OpenAsync().Wait();
   Console.WriteLine("The server is running...");
}

When you have installed ASP.NET MVC4 Beta you will get the following error

Because the signed assembly has the same version it will always load the one that reside in the GAC. There are breaking changes in the new version and it clearly doesn’t load the latest ‘System.Web.Http’ assembly within the solution! This can be seen and monitored by using Fuslogvw.

To resolve this problem we can use DEVPATH. It’s an environment variable that you can set to a folder (typically you’re output folder). The runtime will use the DEVPATH folder for probing before looking into the GAC!
After setting the DEVPATH environment variable (I had to restart my Visual Studio to take effect) you have to add the following in the config file and after that everything worked fine.

<?xml version="1.0"?>
<configuration>
  <runtime>
    <developmentMode developerInstallation="true"/>
  </runtime>
</configuration>

In this post we are investigating source code formatting. Inside my projects I use as much as possible code generation and whether it is coming from T4 templates or some other mechanism, there is usually the need to format your code in a consistent way.

Inside Roslyn we can use the SyntaxTree class that resides in the Roslyn.Compilers.CSharp namespace to parse a text file (that contains C# of VB code). And after we can use the Format extension method that resides in the CompilationUnitSyntax class to reformat your code.

var code = File.ReadAllText("Sample.cs");

var tree = SyntaxTree.ParseCompilationUnit(code);
var root = (CompilationUnitSyntax)tree.Root;

var formattedCode = root.Format().GetFullText();

Take for example the code fragment below (Sample.cs) which is totally unformatted.

namespace Domain
{
using System;
using System
.Collections
.Generic;
using System.ComponentModel.DataAnnotations;

public class BankAccount
:Entity,
IValidatableObject
{
public BankAccountNumber BankAccountNumber {
get;
set; }

public string Iban
{
get
{
return string
.Format("ES{0} {1} {2} {0}{3}",
this.BankAccountNumber.CheckDigits,
this.BankAccountNumber
.NationalBankCode,
this.BankAccountNumber
.OfficeNumber,
this.BankAccountNumber
.AccountNumber);
}
set {

}
}

public decimal Balance { get;
private set; }

public virtual ICollection
BankAccountActivity
{
get
{
if (_bankAccountActivity
== null)
_bankAccountActivity =
new HashSet();

return _bankAccountActivity;
}
set
{
_bankAccountActivity =
new HashSet(value);
}
}
}
}

When passing the code fragment through the SyntaxTree and calling the Format extension method you get the following result which is formatted correctly.

namespace Domain
{
   using System;
   using System.Collections.Generic;
   using System.ComponentModel.DataAnnotations;

   public class BankAccount : Entity, IValidatableObject
   {
      public BankAccountNumber BankAccountNumber
      {   
         get;
         set;
      }

      public string Iban
      {
         get
         {
            return string.Format("ES{0} {1} {2} {0}{3}", this.BankAccountNumber.CheckDigits, this.BankAccountNumber.NationalBankCode, this.BankAccountNumber.OfficeNumber, this.BankAccountNumber.AccountNumber);
         }
         set
         {
         }
      }

      public decimal Balance
      {
         get;
         private set;
      }

      public virtual ICollection BankAccountActivity
      {
         get
         {
            if (_bankAccountActivity == null)
               _bankAccountActivity = new HashSet();
            return _bankAccountActivity;
         }
         set
         {
            _bankAccountActivity = new HashSet(value);
         }
     }   
   }
}

Note that when you are using for example lambda expressions or delegates that the formatter will add unnecessary newlines and whitespaces. Take for example the following code fragment after calling the Format method.

public void SomeMethod()
{
   this.Click += (s, e) =>
   {
      MessageBox.Show(((MouseEventArgs)e).Location.ToString());
   }
   ;
   treeView.AfterExpand += new TreeViewEventHandler(delegate (object o, TreeViewEventArgs t)
   {
      t.Node.ImageIndex = (int)FolderIconEnum.open;
      t.Node.SelectedImageIndex = (int)FolderIconEnum.open;
   }
);
}

Thankfully we have everything in control through the APIs and we can rewrite the expression (like the Format extension method is doing).

For that we need to create a class inheriting from SyntaxRewriter that resides in the Roslyn.Compilers.CSharp namespace and implements the Visitor pattern.

public class CodeBeautifier: SyntaxRewriter
{
   protected override SyntaxToken VisitToken(SyntaxToken token)
   {
      switch (token.Kind)
      {
         case SyntaxKind.SemicolonToken:

         if (token.GetPreviousToken().Kind == SyntaxKind.CloseBraceToken ||
            token.GetPreviousToken().Kind == SyntaxKind.CloseParenToken)
         {
            return token
            .WithLeadingTrivia()
            .WithTrailingTrivia(Syntax.ElasticCarriageReturnLineFeed);
         }

         break;

      case SyntaxKind.CloseBraceToken:

         if (token.GetNextToken().Kind == SyntaxKind.CloseParenToken ||
            token.GetNextToken().Kind == SyntaxKind.SemicolonToken)
         {
             return token
             .WithTrailingTrivia();
         }

      break;

      case SyntaxKind.CloseParenToken:

         if (token.GetPreviousToken().Kind == SyntaxKind.CloseBraceToken)
         {
            return token
            .WithLeadingTrivia();
         }

      break;
   }

    return token;
}
}

Note that I am visiting the syntax tokens, these are the terminals of the language grammar (representing the smallest syntactic fragments) and investigating the current kind of token with the next or previous kind of token. Syntax Trivia represents the parts such as whitespace, comments and preprocessor directives. Inside the VisitToken method I am replacing the syntax trivia parts.

To use the CodeBeautifier class you need to simply create an instance of it and using the Visit method to pass your node.

var code = File.ReadAllText("Sample.cs");

var tree = SyntaxTree.ParseCompilationUnit(code);
var root = (CompilationUnitSyntax)tree.Root;

var formattedCode = new CodeBeautifier().Visit(root.Format()).GetFullText();

After the syntax rewriting you will see that the code now looks like below

public void SomeMethod()
{
this.Click += (s, e) =>
{
MessageBox.Show(((MouseEventArgs)e).Location.ToString());
};
treeView.AfterExpand += new TreeViewEventHandler(delegate (object o, TreeViewEventArgs t)
{
t.Node.ImageIndex = (int)FolderIconEnum.open;
t.Node.SelectedImageIndex = (int)FolderIconEnum.open;
});
}

It turns out you need to enable the IO APIC setting, like below

Make WLW portable

I love portable applications, it enables you to store them on a USB drive or in the cloud without losing your settings and data. It turns out that it’s pretty easy to make WLW portable, and thankfully the investigation I did 3 years ago is still valid for version 2011!

The steps are very simple

1. Copy all the contents of your installation folder (C:\Program Files (x86)\Windows Live\Writer) to your destination folder (e.g. USB stick)
2. Create a folder called ‘UserData’ in your destination folder (same level with the folders Dictionaries, Plugins, …)

You will see after launching WLW and configuring your blog site it will create all necessary files and folders for you settings and posts inside the UserData folder!

Edit existing posts

With WLW it’s possible to edit existing posts (that originally were not posted with WLW) on your blog. It’s not directly clear from the user interface how to do that!

Click on the app menu in the ribbon bar en click on Open recent post, not the items that appear on the right!

After that you get a dialog where you can choose your blog site on the right. It retrieves all post items of your blog and you simply pick the one that you want to edit!

Use DropBox to sync your local drafts across computers

I use DropBox a lot, it’s a free hosting service that enables you to store and share files and folders across the internet. I use it to share my portable utilities and tools, and also WLW (after making it portable). This way I can always access my drafts and edit them when and where I want!

More information and a quickstart can be found on the project site.

In the next couple of weeks I will add more documentation and features!

The goals of ArchiMate are

• To describe architectures and their relations
• Communicate enterprise architectures with all stakeholders
• Judge the impact of changes
• Realise architecture by relating to existing standards, techniques and tools

Archi is a free open source java application to create ArchiMate models.

[custom_frame_center]

[/custom_frame_center]

You can also find a quick reference card of Archimate here and you can also download Archimate stencils for Visio.

First download Topshelf from GitHub, I used version 2.2 (direct link).

1. Create a console application named ‘SampleWindowsService‘ inside Visual Studio
   [message type="info"]Be sure to change the target framework to ‘.NET Framework 4‘[/message]
2. Reference the binaries TopShelf.dll and log4net.dll (included in Topshelf).
3. Create a simple service called ‘SampleService’ that simply write every 5 seconds to the log. Note that we create explicit a Start and Stop method which is conceptually the minimum that a windows service need.[csharp]
   public class SampleService
   {
   private Timer _timer = null;
   readonly ILog _log = LogManager.GetLogger(
   typeof(SampleService));

   public SampleService()
   {
   double interval = 5000;
   _timer = new Timer(interval);
   _timer.Elapsed += new ElapsedEventHandler(OnTick);
   }

   protected virtual void OnTick(object sender, ElapsedEventArgs e)
   {
   _log.Debug("Tick:" + DateTime.Now.ToLongTimeString());
   }

   public void Start()
   {
   _log.Info("SampleService is Started");

   _timer.AutoReset = true;
   _timer.Enabled = true;
   _timer.Start();
   }

   public void Stop()
   {
   _log.Info("SampleService is Stopped");

   _timer.AutoReset = false;
   _timer.Enabled = false;
   }
   }
   [/csharp]

4. In the main method of our console application we will use Topshelf to host our SampleService.
   We we are telling Topshelf how to start and stop the service, what the service name is, etc.
   Note that we need to configure log4net for Topshelf and our service![csharp]
   static void Main(string[] args)
   {
   XmlConfigurator.ConfigureAndWatch(
   new FileInfo(".\\log4net.config"));

   var host = HostFactory.New(x =>
   {
   x.EnableDashboard();
   x.Service(s =>
   {
   s.SetServiceName("SampleService");
   s.ConstructUsing(name => new SampleService());
   s.WhenStarted(tc =>
   {
   XmlConfigurator.ConfigureAndWatch(
   new FileInfo(".\\log4net.config"));
   tc.Start();
   });
   s.WhenStopped(tc => tc.Stop());
   });

   x.RunAsLocalSystem();
   x.SetDescription("SampleService Description");
   x.SetDisplayName("SampleService");
   x.SetServiceName("SampleService");
   });

   host.Run();
   }
   [/csharp]

5. The only thing we have to do now is to configure log4net. Create a file called ‘log4net.config‘ with the following configuration.[xml]
   <!–?xml version="1.0" encoding="utf-8" ?–>

   [/xml]

   This configuration enables to output to the console and through a UDP network protocol so that we can easily monitor the log statements when installed as a windows service. I used Log2Console (Codeplex) to monitor my log statements through UDP.
   [message type="info"]Make sure the output directory of log4net.config is set to ‘Copy always’[/message] [message type="warning"]Note that there is an issue with log4net related to IPv6 and Windows Vista/7. You can fix it by adding the following ’127.0.0.1 log4view-local’ to your hosts file which can be found in folder C:\Windows\System32\drivers\etc\hosts.[/message]

When you fit F5 you will see that Topshelf outputs some log statements and you will see that the log statements of our SampleService is included and everything is working properly.

In order to install SampleService as a Windows Service you simply need to do the following through the command prompt.

[message type="info"]Be sure to launch the command prompt as an administrator![/message]

[text]SampleWindowsService.exe install[/text]

After that when the windows service has been installed successfully we can start the service through services.msc or simply by typing

[text]SampleWindowsService.exe start[/text]

Now we can open Log2Console to monitor our log files that is send through the UDP appender.

To uninstall the service we simply write

[text]SampleWindowsService.exe uninstall[/text]

The sources can be found here (BitBucket)

Visual Studio uses 2 different types of analysis, block-based statement coverage (C1 coverage) and line-based coverage.

• Block-based statement coverage

  A block is defined as a sequence of instructions that have a single entry point and a single exit point. Exit points include branch instructions, a function call, a return instruction, or, for managed code, a throw instruction.

• Line-based coverage

  For line-based coverage, the tools identify all of the blocks that make up a line and then use this information to determine the level of coverage for the line. If all of the blocks that make up the line are covered, then the tools report that the line is covered. If no blocks in the line are covered, then the tools report that the line is not covered. If some, but not all, of the blocks in the line are covered, then the tools report that the line is partially covered.

Take for example the following class that reside in MyProject.BusinessLogic assembly

[csharp]
public class Foo
{
public int Calculate(int x, int y)
{
if (x > 0 && y < 0)
{
return -1;
}
else
{
return 1;
}
}
[/csharp]

And a unit test that reside in MyProject.BusinessLogic.Test assembly

[csharp]
[TestClass]
public class FooTest
{
[TestMethod]
public void Calculate()
{
Foo foo = new Foo();
Assert.AreEqual(1, foo.Calculate(3, 4));
}
}
[/csharp]

To enable code coverage you need to double-lick on the LocalTestRun.testrunconfig file that is located in the ‘Solution Items’ folder.

Inside the ‘Code Coverage’ tab you select the assembly that you want to instrument. In this case we select MyProject.BusinessLogic.dll assembly.

Now you will need to run your unit tests again. Note that code coverage doesn’t work when you debug your unit tests, so you will need to run your unit tests through the menu ‘Test –> Run –> All Tests in Solution (CTRL+R, A)’. After that you can view a report about the code coverage results through the menu ‘Test –> Windows –> Code Coverage Results’.

From the results we notice that we don’t have 100% code coverage because our unit test only reached one part of the condition inside the Calculate method. If you open the Foo class and enable the code coloring you see the parts that are covered, not covered or partially covered.

• Light Blue: Indicates that the entire line of code was exercised in the test run.
• Beige: Indicates that only a portion of the code blocks within the line of code were exercised in the test run.
• Reddish Brown: Indicates that the line was not exercised in the test run.

Code coverage inside Visual Studio uses statement coverage and in this case the number of IL instructions reached is taken into account. If we add some statements in the Foo class and run again our code coverage we notice that the coverage has been raised form 71,43% to 92,59%. It’s important to notice, that when you refactor your class it influences the code coverage even when the contract of the class is the same! This is very different from Branch coverage where each control structure is evaluated to true and false. In this case we would have 50% code coverage.

[csharp]
public class Foo
{
public int Calculate(int x, int y)
{
if (x > 0 && y < 0)
{
return -1;
}
else
{
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());
Console.WriteLine(x.ToString());

return 1;
}
}
}
[/csharp]

Below is an iterator that starts from a solution or project and iterates through all project items inside the solution.

[csharp]
public class ProjectItemIterator : IEnumerable<EnvDTE.ProjectItem>
{
IEnumerable<EnvDTE.Project> projects;

public ProjectItemIterator(EnvDTE.Solution solution)
{
if (solution == null)
throw new ArgumentNullException("solution");

projects = solution.Projects.Cast<EnvDTE.Project>();
}

public ProjectItemIterator(IEnumerable<EnvDTE.Project> projects)
{
if (projects == null)
throw new ArgumentNullException("projects");

this.projects = projects;
}

public IEnumerator<EnvDTE.ProjectItem> GetEnumerator()
{
foreach (EnvDTE.Project currentProject in projects)
foreach (var currentProjectItem in Enumerate(currentProject.ProjectItems))
yield return currentProjectItem;
}

IEnumerable<EnvDTE.ProjectItem> Enumerate(EnvDTE.ProjectItems projectItems)
{
foreach (EnvDTE.ProjectItem item in projectItems)
{
yield return item;

if (item.SubProject != null)
{
foreach (EnvDTE.ProjectItem childItem in Enumerate(item.SubProject.ProjectItems))
yield return childItem;
}
else
{
foreach (EnvDTE.ProjectItem childItem in Enumerate(item.ProjectItems))
yield return childItem;
}
}
}

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
[/csharp]

To get started with .NET RIA Services you need Visual Studio 2008 SP1 and you need to install the following packages

• Microsoft Silverlight 3 Tools Beta 1 for Visual Studio 2008 SP1
• Microsoft .NET RIA Services March ’09 Preview

On the download page of .NET RIA Services there is a great PDF document (riaservicesoverviewpreview.pdf) that gives you a step-by-step guide.

Every time you compile a solution with .NET RIA Services, an MSBuild task is executed that generates code in your Silverlight project from the domain services (DomainService class) that reside in your ASP.NET server. After some investigation through reflector, you can actually modify or extend the code generation using CodeDom! For this you need to add an attribute called DomainIdentifier where you specify a type that inherits from CodeProcessor. Both classes reside in the System.Web.Ria.Data namespace.

[csharp]
[EnableClientAccess()]
[DomainIdentifier("Comment", CodeProcessor = typeof(CommentCodeProcessor))]
public class CityService : DomainService
{
//…
}
[/csharp]

In this example, we simply add some documentation in the summary tag.

[csharp]
public class CommentCodeProcessor : CodeProcessor
{
public CommentCodeProcessor(CodeDomProvider codeDomProvider)
: base(codeDomProvider)
{
}

public override void ProcessGeneratedCode(
DomainServiceDescription domainServiceDescription,
System.CodeDom.CodeCompileUnit codeCompileUnit,
IDictionary<Type, System.CodeDom.CodeTypeDeclaration> typeMapping)
{
Type domainServiceType = domainServiceDescription.DomainServiceType;
CodeTypeDeclaration declaration = typeMapping[domainServiceType];

declaration.Comments.Add(new CodeCommentStatement("<summary>", true));

foreach (var entityType in domainServiceDescription.EntityTypes)
{
declaration.Comments.Add(
new CodeCommentStatement(
string.Format("Entity Type: {0}", entityType.FullName), true));
}

foreach (var operationEntry in domainServiceDescription.DomainOperationEntries)
{
declaration.Comments.Add(
new CodeCommentStatement(
string.Format("Operation Entry: {0}", operationEntry.MethodInfo.Name), true));
}

declaration.Comments.Add(new CodeCommentStatement("</summary>", true));
}
}
[/csharp]

Below you find a sample of the generated file using the CommentCodeProcessor

[csharp]
/// <summary>
/// Entity Type: SilverlightApplication.Web.DataModels.City
/// Operation Entry: GetCities
/// Operation Entry: ReturnAllCities
/// </summary>
[DomainIdentifier("Comment")]
public sealed partial class CityContext : DomainContext
{
//…
}
[/csharp]