Make NDoc compile the code examples contained in your documentation using NLiterate

using System;
using System.IO;
using System.Reflection;
using System.Diagnostics;

namespace NLiterate
{
	/// <summary>
	/// Execution result class.
	/// </summary>
	public class ExecutionResults
	{
		private const int NoOrErrorRetValue = -1;	

		private StringWriter consoleOut = new StringWriter();
		private StringWriter consoleError = new StringWriter();
		private Exception throwedException = null;
		private int returnedValue = NoOrErrorRetValue;

		/// <summary>
		/// Initializes an empty execution result class.
		/// </summary>
		public ExecutionResults()
		{}

		/// <summary>
		/// Gets or sets the console output stream
		/// </summary>
		/// <value>
		/// Console.Out stream.
		/// </value>
		public StringWriter ConsoleOut
		{
			get
			{
				return this.consoleOut;
			}
		}

		/// <summary>
		/// Gets or sets the console error stream
		/// </summary>
		/// <value>
		/// Console.Error stream
		/// </value>
		public StringWriter ConsoleError
		{
			get
			{
				return this.consoleError;
			}
		}

		/// <summary>
		/// Gets a value indicating if the execution has throwed.
		/// </summary>
		/// <value>
		/// true if it has throwed, false otherwise
		/// </value>
		public bool HasThrowed
		{
			get
			{
				return this.throwedException != null;
			}
		}

		/// <summary>
		/// Gets the exception throwed, a null reference if no exception
		/// were throwed.
		/// </summary>
		/// <value>
		/// Throwed <see cref="Exception"/>, a null reference (Nothing in
		/// Visual Basic) if not throwed.
		/// </value>
		public Exception ThrowedException
		{
			get
			{
				return this.throwedException;
			}
		}

		/// <summary>
		/// Gets the execution return value.
		/// </summary>
		/// <value>
		/// integer returned by the entry point method.
		/// </value>
		public int ReturnedValue
		{
			get
			{
				return this.returnedValue;
			}
		}

		/// <summary>
		/// Converts instance to string
		/// </summary>
		/// <returns>
		/// <see cref="String"/> representing the results.
		/// </returns>
		public override string ToString()
		{
			StringWriter sw = new StringWriter();

			sw.WriteLine("Success:\n{0}", !this.HasThrowed);
			sw.WriteLine("Return code:\n{0}",this.returnedValue);
			sw.WriteLine("Console.Out:\n{0}",this.consoleOut.ToString());
			sw.WriteLine("Console.Error:\n{0}",this.consoleError.ToString());
			if (this.HasThrowed)
				sw.WriteLine("Exception:\n{0}",this.throwedException.ToString());

			return sw.ToString();
		}

		/// <summary>
		/// Executes the method <paramref name="mi"/> and returns the result.
		/// </summary>
		/// <param name="mi">Method to execute</param>
		/// <returns></returns>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="mi"/> is a null reference (Nothing in Visual Basic).
		/// </exception>
		public static ExecutionResults Execute(MethodInfo mi)
		{
			if (mi==null)
				throw new ArgumentNullException("mi");
			lock(typeof(ExecutionResults))
			{
				TextWriter consoleOut = Console.Out;
				TextWriter consoleError = Console.Error;

				ExecutionResults result = new ExecutionResults();
				Console.SetOut(result.consoleOut);
				Console.SetError(result.consoleError);

				try
				{
					if (mi.ReturnType != typeof(int))
					{
						mi.Invoke(null,null);
						result.returnedValue = NoOrErrorRetValue;
					}
					else
					{
						result.returnedValue = (int)mi.Invoke(null,null);
					}

				}
				catch(Exception ex)
				{
					result.throwedException = ex;
				}
				finally
				{
					Console.SetOut(consoleOut);
					Console.SetError(consoleError);
				}

				return result;
			}
		}

		/// <summary>
		/// Execution results when the entry point method is not found.
		/// </summary>
		/// <returns></returns>
		public static ExecutionResults NoEntryPoint()
		{
			lock(typeof(ExecutionResults))
			{
				ExecutionResults results = new ExecutionResults();
				results.throwedException = new Exception("No entry point found.");
				return results;
			}
		}
	}
}