var uri = new Uri( string.Format( "{0}?unique={1}", "SamePage.xaml, Guid.NewGuid() ), UriKind.RelativeOrAbsolute );
RemoveBackEntry = true;
NavigationService.Navigate( uri );

using System.Windows.Navigation;
using Microsoft.Practices.Prism.ViewModel;

namespace RememberIt.WP7.App.ViewModels
{
	public abstract class ViewModelBase : NotificationObject
	{
		protected bool RemoveBackEntry { get; set; }

		public NavigationService NavigationService { get; set; }

		public NavigationContext NavigationContext { get; set; }

		public virtual void OnNavigatedTo( NavigationEventArgs e ) {}

		public virtual void OnNavigatingFrom( NavigatingCancelEventArgs e ) {}

		public virtual void OnNavigatedFrom( NavigationEventArgs e )
		{
			if( RemoveBackEntry )
			{
				RemoveBackEntry = false;
				NavigationService.RemoveBackEntry();
			}
		}
	}
}

using Microsoft.Phone.Controls;
using RememberIt.WP7.App.ViewModels;

namespace RememberIt.WP7.App.Views
{
	public class PageBase : PhoneApplicationPage
	{
		protected PageBase()
		{
			Loaded += PageBaseLoaded;
		}

		private void PageBaseLoaded( object sender, System.Windows.RoutedEventArgs e )
		{
			var viewModel = DataContext as ViewModelBase;
			if( viewModel != null )
			{
				viewModel.NavigationService = NavigationService;
			}
		}

		protected override void OnNavigatedTo( System.Windows.Navigation.NavigationEventArgs e )
		{
			base.OnNavigatedTo( e );			
			var viewModel = DataContext as ViewModelBase;
			if( viewModel != null )
			{
				viewModel.NavigationContext = NavigationContext;
				viewModel.OnNavigatedTo( e );
			}
		}

		protected override void OnNavigatingFrom( System.Windows.Navigation.NavigatingCancelEventArgs e )
		{
			base.OnNavigatingFrom( e );
			var viewModel = DataContext as ViewModelBase;
			if( viewModel != null )
			{
				viewModel.NavigationContext = NavigationContext;
				viewModel.OnNavigatingFrom( e );
			}
		}

		protected override void OnNavigatedFrom( System.Windows.Navigation.NavigationEventArgs e )
		{
			base.OnNavigatedFrom( e );
			var viewModel = DataContext as ViewModelBase;
			if( viewModel != null )
			{
				viewModel.NavigationContext = NavigationContext;
				viewModel.OnNavigatedFrom( e );
			}
		}
	}
}

CREATE TABLE [dbo].[Audit]
(
    [Id] INT NOT NULL IDENTITY,
    [User] NVARCHAR( 100 ) NOT NULL,
    [Trail] NVARCHAR( MAX ) NOT NULL,
    [Created] DATETIME NOT NULL
)

ALTER TABLE [dbo].[Audit]
    ADD CONSTRAINT [PK_Audit_Id]
    PRIMARY KEY (Id)

public class NHibernateAuditAppender : AppenderSkeleton
{
    private static IKernel kernel;

    protected override void Append( LoggingEvent loggingEvent )
    {
#if !DEBUG
        if( loggingEvent.RenderedMessage.StartsWith( "SELECT" ) )
        {
            return;
        }
#endif

        var session = kernel.Get<ISession>();
        var audit = new Audit
        {
            Created = DateTime.UtcNow,
            Trail = loggingEvent.RenderedMessage,
            User = Thread.CurrentPrincipal.Identity.Name
        };
        session.Save( audit );
    }
}

public class NHibernateAuditAppender : AppenderSkeleton
{
    private static IKernel kernel;

    protected override void Append( LoggingEvent loggingEvent )
    {
#if !DEBUG
        if( loggingEvent.RenderedMessage.StartsWith( "SELECT" ) )
        {
            return;
        }
#endif

        var session = kernel.Get<ISession>();
        var audit = new Audit
        {
            Created = DateTime.UtcNow,
            Trail = loggingEvent.RenderedMessage,
            User = Thread.CurrentPrincipal.Identity.Name
        };
        session.Save( audit );
    }

    public static void RegisterAppender( IKernel kernel )
    {
        NHibernateAuditAppender.kernel = kernel;

        var repository = (Hierarchy)LogManager.GetRepository();
        var appender = new NHibernateAuditAppender { Name = "NHibernateAuditAppender" };
        var logger = (Logger)repository.GetLogger( "NHibernate.SQL" );
        logger.Level = Level.Debug;
        logger.Additivity = false;
        logger.AddAppender( appender );
        appender.ActivateOptions();
        repository.Configured = true;
    }
}

var processes = Process.GetProcessesByName( "MyProcess" );

var managementObjectSearcher = new ManagementObjectSearcher( "select CommandLine from Win32_Process where Name='MyProcess.exe'" );
var managementObjects = managementObjectSearcher.Get();
foreach( var managementObject in managementObjects )
{
    var command = (string)managementObject["CommandLine"];
}

using System.Collections.Generic;
using System.ServiceModel;
using Wnn.Service.Contract.DataContracts;

namespace Wnn.Service.Contract.ServiceContracts
{
    [ServiceContract]
    public interface IBlogService
    {
        [OperationContract]
        Post GetPostById( int id );
        [OperationContract]
        User GetUserById( int id );
        [OperationContract]
        User GetUserByUserNameAndPassword( string userName, string password );
        [OperationContract]
        List<Post> GetPosts();
        [OperationContract]
        List<Post> GetPostsFromAuthor( string userName );
    }
}

Post.cs

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;

namespace Wnn.Service.Contract.DataContracts
{
    [DataContract]
    public class Post
    {
        [DataMember]
        public int Id { get; set; }
        [DataMember]
        public string Title { get; set; }
        [DataMember]
        public string Content { get; set; }
        [DataMember]
        public DateTime Created { get; set; }
        [DataMember]
        public string Author { get; set; }
        [DataMember]
        public List<string> Tags { get; set; }
    }
}

using System.Runtime.Serialization;

namespace Wnn.Service.Contract.DataContracts
{
    [DataContract]
    public class User
    {
        [DataMember]
        public int Id { get; set; }
        [DataMember]
        public string UserName { get; set; }
        [DataMember]
        public string Email { get; set; }
        [DataMember]
        public string FirstName { get; set; }
        [DataMember]
        public string LastName { get; set; }
    }
}

using System;
using System.Security.Cryptography;
using System.Text;

namespace Wnn.Business.Objects
{
    public class User
    {
        private string password;

        public virtual int Id { get; protected set; }
        public virtual string UserName { get; set; }
        public virtual string Email { get; set; }
        public virtual string Password
        {
            get { return password; }
            set
            {
                var md5 = MD5.Create();
                var passwordBytes = Encoding.UTF8.GetBytes( value );
                md5.ComputeHash( passwordBytes );
                password = Convert.ToBase64String( md5.Hash );
            }
        }

        public virtual string FirstName { get; set; }
        public virtual string LastName { get; set; }
    }
}

namespace Wnn.Business.Objects
{
    public class Tag
    {
        public virtual int Id { get; protected set; }
        public virtual string Name { get; set; }
        public virtual Post Post { get; set; }
    }
}

using System;
using System.Collections.Generic;

namespace Wnn.Business.Objects
{
    public class Post
    {
        public virtual int Id { get; protected set; }
        public virtual string Title { get; set; }
        public virtual string Content { get; set; }
        public virtual DateTime Created { get; set; }
        public virtual User Author { get; set; }
        public virtual List<Tag> Tags { get; set; }

        public virtual void AddTag( Tag tag )
        {
            tag.Post = this;
            Tags.Add( tag );
        }
    }
}

using FluentNHibernate.Mapping;
using Wnn.Business.Objects;

namespace Wnn.Business.Mappings
{
    public class UserMap : ClassMap<User>
    {
        public UserMap()
        {
            SetupMapping();
        }

        private void SetupMapping()
        {
            Table( "Users" );
            Id( m => m.Id );
            Map( m => m.Email );
            Map( m => m.FirstName );
            Map( m => m.LastName );
            Map( m => m.Password ).Access.CamelCaseField();
            Map( m => m.UserName );
        }
    }
}

using FluentNHibernate.Mapping;
using Wnn.Business.Objects;

namespace Wnn.Business.Mappings
{
    public class TagMap : ClassMap<Tag>
    {
        public TagMap()
        {
            SetupMapping();
        }

        private void SetupMapping()
        {
            Table( "Tags" );
            Id( m => m.Id );
            Map( m => m.Name );
            References( m => m.Post, "PostId" );
        }
    }
}

using FluentNHibernate.Mapping;
using Wnn.Business.Objects;

namespace Wnn.Business.Mappings
{
    public class PostMap : ClassMap<Post>
    {
        public PostMap()
        {
            SetupMapping();
        }

        private void SetupMapping()
        {
            Table( "Posts" );
            Id( m => m.Id );
            Map( m => m.Content );
            Map( m => m.Title );
            References( m => m.Author, "UserId" );
            HasMany( m => m.Tags )
                .Inverse()
                .Cascade.AllDeleteOrphan()
                .KeyColumns.Add( "PostId" )
                .Fetch.Subselect();
        }
    }
}

using System;
using System.Data;
using System.Linq;
using NHibernate;
using NHibernate.Linq;

namespace Wnn.Business
{
    public class SessionManager
    {
        private readonly ISession session;

        public SessionManager( ISession session )
        {
            if( session == null )
            {
                throw new ArgumentNullException( "session" );
            }

            this.session = session;
        }

        public virtual IQueryable<T> Linq<T>()
        {
            return session.Linq<T>();
        }

        public virtual T Get<T>( int id )
        {
            return session.Get<T>( id );
        }

        public virtual ISQLQuery CreateSqlQuery( string queryString )
        {
            return session.CreateSQLQuery( queryString );
        }

        public virtual void SaveOrUpdate( object obj )
        {
            session.SaveOrUpdate( obj );
        }

        public virtual void Delete( object obj )
        {
            session.Delete( obj );
        }

        public virtual ITransaction BeginTransaction()
        {
            return session.BeginTransaction();
        }

        public virtual IDbConnection Close()
        {
            return session.Close();
        }

        public virtual void Dispose()
        {
            session.Dispose();
        }
    }
}

using System.Collections.Generic;
using System.Linq;

namespace Wnn.Business.Repositories
{
    public abstract class RepositoryBase<T>
    {
        protected SessionManager SessionManager { get; set; }

        protected RepositoryBase( SessionManager sessionManager )
        {
            SessionManager = sessionManager;
        }

        public T Get( int id )
        {
            return SessionManager.Get<T>( id );
        }

        public List<T> GetAll()
        {
            return SessionManager.Linq<T>().ToList();
        }

        public void SaveOrUpdate( T obj )
        {
            SessionManager.SaveOrUpdate( obj );
        }

        public void Delete( T obj )
        {
            SessionManager.Delete( obj );
        }
    }
}

using System.Linq;
using Wnn.Business.Objects;

namespace Wnn.Business.Repositories
{
    public class UserRepository : RepositoryBase<User>
    {
        public UserRepository( SessionManager sessionManager ) : base( sessionManager ){}

        public User GetByUserNameAndPassword( string userName, string password )
        {
            return ( from u in SessionManager.Linq<User>()
                     where u.UserName == userName && password == u.Password
                     select u ).SingleOrDefault();
        }
    }
}

using Wnn.Business.Objects;

namespace Wnn.Business.Repositories
{
    public class TagRepository : RepositoryBase<Tag>
    {
        public TagRepository( SessionManager sessionManager ) : base( sessionManager ){}
    }
}

using System.Collections.Generic;
using System.Linq;
using Wnn.Business.Objects;

namespace Wnn.Business.Repositories
{
    public class PostRepository : RepositoryBase<Post>
    {
        public PostRepository( SessionManager sessionManager ) : base( sessionManager ){}

        public List<Post> GetAllForUser( string userName )
        {
            return ( from p in SessionManager.Linq<Post>()
                     where p.Author.UserName == userName
                     select p ).ToList();
        }
    }
}

using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using Wnn.Business.Repositories;
using Wnn.Service.Contract.DataContracts;
using Wnn.Service.Contract.ServiceContracts;

namespace Wnn.Service
{
    [ServiceBehavior( InstanceContextMode = InstanceContextMode.PerCall )]
    public class BlogService : IBlogService
    {
        private readonly UserRepository userRepository;
        private readonly PostRepository postRepository;
        private readonly TagRepository tagRepository;

        public BlogService( UserRepository userRepository, PostRepository postRepository, TagRepository tagRepository )
        {
            this.userRepository = userRepository;
            this.postRepository = postRepository;
            this.tagRepository = tagRepository;
        }

        public Post GetPostById( int id )
        {
            return ConvertPost( postRepository.Get( id ) );
        }

        public User GetUserById( int id )
        {
            return ConvertUser( userRepository.Get( id ) );
        }

        public User GetUserByUserNameAndPassword( string userName, string password )
        {
            return ConvertUser( userRepository.GetByUserNameAndPassword( userName, password ) );
        }

        public List<Post> GetPosts()
        {
            return ( from p in postRepository.GetAll()
                     select ConvertPost( p ) ).ToList();
        }

        public List<Post> GetPostsFromAuthor( string userName )
        {
            return ( from p in postRepository.GetAllForUser( userName )
                     select ConvertPost( p ) ).ToList();
        }

        private static User ConvertUser( Business.Objects.User userData )
        {
            User user = null;
            if( userData != null )
            {
                user = new User
                {
                    Email = userData.Email,
                    FirstName = userData.FirstName,
                    Id = userData.Id,
                    LastName = userData.LastName,
                    UserName = userData.UserName,
                };
            }
            return user;
        }

        private static Post ConvertPost( Business.Objects.Post postData )
        {
            Post post = null;
            if( postData != null )
            {
                post = new Post
                {
                    Author = postData.Author.UserName,
                    Content = postData.Content,
                    Created = postData.Created,
                    Id = postData.Id,
                    Title = postData.Title,
                    Tags = ( from t in postData.Tags
                             select t.Name ).ToList()
                };
            }
            return post;
        }
    }
}

using System.Collections.Generic;
using System.ServiceModel;

namespace Wnn.Service.Host
{
    public class ServiceHostEngine
    {
        private readonly List<ServiceHost> serviceHosts = new List<ServiceHost>();

        public ServiceHostEngine()
        {
            // We can have multiple services listed here.
            // We could actually have a list of services in a config
            // file that is dynamically loaded here also.
            serviceHosts.Add( new ServiceHost( typeof( BlogService ) ) );
        }

        public void Start()
        {
            foreach( var serviceHost in serviceHosts )
            {
                serviceHost.Open();
            }
        }

        public void Stop()
        {
            foreach( var serviceHost in serviceHosts )
            {
                serviceHost.Close();
            }
        }
    }
}

using System.Collections.Generic;
using FluentNHibernate.Cfg;
using NHibernate;

namespace Wnn.Business
{
    public static class SessionFactoryFactory
    {
        private static readonly object locker = new object();
        private static readonly Dictionary<string, ISessionFactory> sessionFactories = new Dictionary<string, ISessionFactory>();

        public static ISessionFactory GetSessionFactory( string connectionStringKey )
        {
            ISessionFactory sessionFactory;
            sessionFactories.TryGetValue( connectionStringKey, out sessionFactory );

            // Double check locking is used here because
            // WCF could have many instances accessing this
            // code at the same time.
            if( sessionFactory == null )
            {
                lock( locker )
                {
                    sessionFactories.TryGetValue( connectionStringKey, out sessionFactory );
                    if( sessionFactory == null )
                    {
                        sessionFactory = Fluently.Configure()
                            .Database(
                            FluentNHibernate.Cfg.Db.MsSqlConfiguration.MsSql2005.ConnectionString(
                                c => c.FromConnectionStringWithKey( connectionStringKey ) )
                                .ProxyFactoryFactory( "NHibernate.ByteCode.LinFu.ProxyFactoryFactory, NHibernate.ByteCode.LinFu" ) )
                            .Mappings( m => m.FluentMappings.AddFromAssembly( typeof( SessionFactoryFactory ).Assembly ) )
                            .ExposeConfiguration( cfg => cfg.SetProperty( "generate_statistics", "true" ) )
                            .ExposeConfiguration( cfg => cfg.SetProperty( "adonet.batch_size", "10" ) )
                            .BuildSessionFactory();

                        sessionFactories[connectionStringKey] = sessionFactory;
                    }
                }
            }

            return sessionFactory;
        }
    }
}

using NHibernate;
using Ninject.Modules;
using Wnn.Business;

namespace Wnn.Service.Host
{
    public class NinjectSetup : NinjectModule
    {
        private readonly string connectionStringKey;

        public NinjectSetup( string connectionStringKey )
        {
            this.connectionStringKey = connectionStringKey;
        }

        public override void Load()
        {
            Bind<ISession>()
                .ToMethod( ctx => SessionFactoryFactory.GetSessionFactory( connectionStringKey ).OpenSession() )
                .InSingletonScope();

            Bind<SessionManager>()
                .ToSelf()
                .InSingletonScope();
        }
    }
}

using System;
using System.Runtime.Remoting.Messaging;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Dispatcher;
using NHibernate;
using Ninject;
using Wnn.Business;

namespace Wnn.Service.Host
{
    public class NHibernateInstanceProvider : IInstanceProvider
    {
        private const string sessionKey = "ThreadSession";
        private const string transactionKey = "ThreadTransaction";
        private readonly Type serviceType;

        private static SessionManager SessionManager
        {
            get { return CallContext.GetData( sessionKey ) as SessionManager; }
            set { CallContext.SetData( sessionKey, value ); }
        }

        private static ITransaction Transaction
        {
            get { return CallContext.GetData( transactionKey ) as ITransaction; }
            set { CallContext.SetData( transactionKey, value ); }
        }

        public NHibernateInstanceProvider( Type serviceType )
        {
            this.serviceType = serviceType;
        }

        public object GetInstance( InstanceContext instanceContext )
        {
            return GetInstance( instanceContext, null );
        }

        public object GetInstance( InstanceContext instanceContext, Message message )
        {
            var connectionStringKey = GetConnectionStringKey( serviceType );

            var kernel = new StandardKernel( new NinjectSetup( connectionStringKey ) );

            SessionManager = kernel.Get<SessionManager>();
            Transaction = SessionManager.BeginTransaction();

            var instance = kernel.Get( serviceType );

            return instance;
        }

        public void ReleaseInstance( InstanceContext instanceContext, object instance )
        {
            try
            {
                Transaction.Commit();
            }
            catch
            {
                Transaction.Rollback();
            }
            finally
            {
                SessionManager.Close();
                SessionManager.Dispose();
            }
        }

        private static string GetConnectionStringKey( Type serviceType )
        {
            // All of our database connections should
            // go here. We could also put all of these types
            // into a config file and load them dynamically.
            string connectionStringKey;
            if( serviceType == typeof( BlogService ) )
            {
                connectionStringKey = "Dashboard";
            }
            else
            {
                throw new Exception( "Service type '{0}' does not match any database connection." );
            }
            return connectionStringKey;
        }
    }
}

<system.serviceModel>
    <extensions>
        <behaviorExtensions>
            <add name="nhibernateServiceBehavior" type="Wnn.Service.Host.NHibernateBehaviorExtensionElement, Wnn.Service.Host, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
        </behaviorExtensions>
    </extensions>

    <behaviors>
        <serviceBehaviors>
            <behavior name="nhibernateServiceBehavior">
                <nhibernateServiceBehavior />
                <serviceMetadata />
            </behavior>
        </serviceBehaviors>
        <endpointBehaviors>
            <behavior name="HttpEnableBehavior">
                <webHttp/>
            </behavior>
        </endpointBehaviors>
    </behaviors>

    <services>
        <service name="Wnn.Service.BlogService" behaviorConfiguration="nhibernateServiceBehavior">
            <host>
                <baseAddresses>
                    <add baseAddress="net.tcp://localhost:8761/Services/" />
                </baseAddresses>
            </host>
            <endpoint address="Blog" binding="netTcpBinding" contract="Wnn.Service.Contract.ServiceContracts.IBlogService" />
        </service>
    </services>
</system.serviceModel>

using System;
using System.ServiceModel.Configuration;

namespace Wnn.Service.Host
{
    public class NHibernateBehaviorExtensionElement : BehaviorExtensionElement
    {
        protected override object CreateBehavior()
        {
            return new NHibernateServiceBehavior();
        }

        public override Type BehaviorType
        {
            get { return typeof( NHibernateServiceBehavior ); }
        }
    }
}

using System;
using System.Collections.ObjectModel;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;

namespace Wnn.Service.Host
{
    public class NHibernateServiceBehavior : Attribute, IServiceBehavior
    {
        public void Validate( ServiceDescription serviceDescription, ServiceHostBase serviceHostBase )
        {
        }

        public void AddBindingParameters( ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters )
        {
        }

        public void ApplyDispatchBehavior( ServiceDescription serviceDescription, ServiceHostBase serviceHostBase )
        {
            foreach( var channelDispatcherBase in serviceHostBase.ChannelDispatchers )
            {
                var channelDispatcher = channelDispatcherBase as ChannelDispatcher;
                if( channelDispatcher == null )
                {
                    continue;
                }

                foreach( var ed in channelDispatcher.Endpoints )
                {
                    ed.DispatchRuntime.InstanceProvider = new NHibernateInstanceProvider( serviceDescription.ServiceType );
                }
            }
        }
    }
}

namespace Wnn.Service.Host.Console
{
    class Program
    {
        static void Main( string[] args )
        {
            var service = new ServiceHostEngine();
            service.Start();
            System.Console.WriteLine( "Press any key to stop the services" );
            System.Console.ReadKey();
        }
    }
}

using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;

public class ScreenShot
{
    [ComImport]
    [InterfaceType( ComInterfaceType.InterfaceIsIUnknown )]
    [Guid( "0000010d-0000-0000-C000-000000000046" )]
    private interface IViewObject
    {
        [PreserveSig]
        int Draw( [In] [MarshalAs( UnmanagedType.U4 )] int dwDrawAspect, int lindex, IntPtr pvAspect,
                  [In] /*tagDVTARGETDEVICE*/ IntPtr ptd, IntPtr hdcTargetDev, IntPtr hdcDraw,
                  [In] /*COMRECT*/ Rectangle lprcBounds, [In] /*COMRECT*/ IntPtr lprcWBounds, IntPtr pfnContinue,
                  [In] int dwContinue );

        [PreserveSig]
        int GetColorSet( [In] [MarshalAs( UnmanagedType.U4 )] int dwDrawAspect, int lindex, IntPtr pvAspect,
                         [In] /*tagDVTARGETDEVICE*/ IntPtr ptd, IntPtr hicTargetDev, [Out] /*tagLOGPALETTE*/ IntPtr ppColorSet );

        [PreserveSig]
        int Freeze( [In] [MarshalAs( UnmanagedType.U4 )] int dwDrawAspect, int lindex, IntPtr pvAspect, [Out] IntPtr pdwFreeze );

        [PreserveSig]
        int Unfreeze( [In] [MarshalAs( UnmanagedType.U4 )] int dwFreeze );

        void SetAdvise( [In] [MarshalAs( UnmanagedType.U4 )] int aspects, [In] [MarshalAs( UnmanagedType.U4 )] int advf,
                        [In] [MarshalAs( UnmanagedType.Interface )] /*IAdviseSink*/ IntPtr pAdvSink );

        void GetAdvise( [In] [Out] [MarshalAs( UnmanagedType.LPArray )] int[] paspects,
                        [In] [Out] [MarshalAs( UnmanagedType.LPArray )] int[] advf,
                        [In] [Out] [MarshalAs( UnmanagedType.LPArray )] /*IAdviseSink[]*/ IntPtr[] pAdvSink );
    }

    public static Bitmap Create( string url )
    {
        using( var webBrowser = new WebBrowser() )
        {
            webBrowser.ScrollBarsEnabled = false;
            webBrowser.ScriptErrorsSuppressed = true;
            webBrowser.Navigate( url );

            while( webBrowser.ReadyState != WebBrowserReadyState.Complete )
            {
                Application.DoEvents();
            }

            webBrowser.Width = webBrowser.Document.Body.ScrollRectangle.Width;
            webBrowser.Height = webBrowser.Document.Body.ScrollRectangle.Height;

            var bitmap = new Bitmap( webBrowser.Width, webBrowser.Height );
            var graphics = Graphics.FromImage( bitmap );
            var hdc = graphics.GetHdc();

            var rect = new Rectangle( 0, 0, webBrowser.Width, webBrowser.Height );

            var viewObject = (IViewObject)webBrowser.Document.DomDocument;
            viewObject.Draw( 1, -1, (IntPtr)0, (IntPtr)0, (IntPtr)0, hdc, rect, (IntPtr)0, (IntPtr)0, 0 );

            graphics.ReleaseHdc( hdc );

            return bitmap;
        }
    }
}

<use file="MyPartialView" />

<MyPartialView />

#Html.RenderPartial( myPartialViewVariable );

<ul>
    <li each="var item in items">
        #ViewData["item"] = item;
        #Html.RenderPartial( "path/to/" + item.Name );
    </li>
</ul>

<viewdata item="Item" />

protected void Application_Error( object sender, EventArgs e )
{
    var exception = Server.GetLastError();

    Response.Clear();

    var httpException = exception as HttpException;

    var routeData = new RouteData();
    routeData.Values.Add( "controller", "Error" );

    if( httpException == null )
    {
        routeData.Values.Add( "action", "Index" );
    }
    else //It's an Http Exception, Let's handle it.
    {
        switch( httpException.GetHttpCode() )
        {
            case 404:
                // Page not found.
                routeData.Values.Add( "action", "HttpError404" );
                break;
            case 500:
                // Server error.
                routeData.Values.Add( "action", "HttpError500" );
                break;

            // Here you can handle Views to other error codes.
            // I choose a General error template
            default:
                routeData.Values.Add( "action", "General" );
                break;
        }
    }

    // Pass exception details to the target error View.
    routeData.Values.Add( "error", exception );

    // Clear the error on server.
    Server.ClearError();

    // Call target Controller and pass the routeData.
    IController errorController = new ErrorController();
    errorController.Execute( new RequestContext( new HttpContextWrapper( Context ), routeData ) );
}

using System;
using System.Globalization;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace Ninject.Web.Mvc
{
    /// <summary>
    /// A controller factory that creates <see cref="IController"/>s via Ninject.
    /// </summary>
    public class NinjectControllerFactory : DefaultControllerFactory
    {
        /// <summary>
        /// Gets the kernel that will be used to create controllers.
        /// </summary>
        public IKernel Kernel { get; private set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="NinjectControllerFactory"/> class.
        /// </summary>
        /// <param name="kernel">The kernel that should be used to create controllers.</param>
        public NinjectControllerFactory(IKernel kernel)
        {
            Kernel = kernel;
        }

        /// <summary>
        /// Creates the controller with the specified name.
        /// </summary>
        /// <param name="requestContext">The request context.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <returns>The created controller.</returns>
        public override IController CreateController(RequestContext requestContext, string controllerName)
        {
            var controller = Kernel.TryGet<IController>(controllerName.ToLowerInvariant());

            if(controller == null)
                return base.CreateController(requestContext, controllerName);

            var standardController = controller as Controller;

            if(standardController != null)
                standardController.ActionInvoker = new NinjectActionInvoker(Kernel);

            return controller;
        }

        /// <summary>
        /// Releases the specified controller.
        /// </summary>
        /// <param name="controller">The controller to release.</param>
        public override void ReleaseController(IController controller) { }
    }
}