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

This seems a little odd, but whatever, let’s find a workaround. Here is some code to get the arguments of a process.

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"];
}

Command is the full command line used to start the process. This includes the path and all arguments.

First, create an assembly for each of the following: business logic, services, service contracts, and the service host.

We want to separate all these into different assemblies so we don’t have issues with circular dependencies. The other option is to have everything in a single assembly, but that usually isn’t an option, or a very good one for that matter.

Contracts

The contract assembly is where we keep all the contracts, or interfaces, that are used in our services. This makes it so that the services can reference and use the contracts, and so can a client to the services. If the service is visible to projects outside of yours, you can just give them the contract assembly.

Let’s create a service contract, and some data contracts for our blog application. I put them into folders to separate the service contracts from the data contracts.

IBlogService.cs

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; }
    }
}

User.cs

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; }
    }
}

Business Logic

Let’s create our business objects, repositories to access our database, and all the NHibernate guts. We don’t have a data layer here because NHibernate IS our data layer. There could still be a use of separating some stuff out into a data layer, but I will not be doing that. References will need to be added to NHibernate.dll, FluentNHibernate.dll, NHibernate.ByteCode.LinFu.dll, and NHibernate.Linq.dll.

Let’s create our POCO (plain old CLR object) business objects. All members need to be virtual so NHibernate can use them.

User.cs

In the password property we want to encrypt any password that gets 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; }
    }
}

Tag.cs

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; }
    }
}

Post.cs

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 );
        }
    }
}

The AddTag method is used to set both sides of the object association. Otherwise NHibernate will not save them properly if a tag is added to the tags list.

Let’s create our NHibernate mapping files now. I use FluentNHibernate to do this.

UserMap.cs

Since we’re using a backing field for the Password property, we need to have NHibernate use that instead. We don’t want NHibernate to use the property because the stored hash would get hashed again when set.

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 );
        }
    }
}

TagMap.cs

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" );
        }
    }
}

PostMap.cs

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();
        }
    }
}

Next we’re going to setup our repositories. This is where we access our data. Before we can do that though, we need to create a SessionManager object. SessionManager is just a wrapper around the NHibernate ISession object to allow for easier unit testing. We’re not hiding the fact that we’re using NHibernate though. The SessionManager wrapper still returns NHibernate objects. This could be completely abstracted so it didn’t matter which ORM or data layer is being used.

SessionManager.cs

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();
        }
    }
}

Now we can create the repositories and a base repository class for common methods.

RepositoryBase.cs

We put any common methods in the base class.

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 );
        }
    }
}

UserRepository.cs

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();
        }
    }
}

TagRepository.cs

using Wnn.Business.Objects;

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

PostRepository.cs

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();
        }
    }
}

Services

Now that we have our repositories setup, we can implement the services that will use the repositories.

BlogService.cs

We need to set the InstanceContextMode to PerCall. This makes it so WCF will create a new context instance per service call. This sets up NHibernate nicely because we can then start a transaction at the beginning of every service method call, and end the transaction at the end of the call, rolling back if an error occurred. More on that later.

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;
        }
    }
}

Service Host

The service host is what actually starts up all of our services. In this case, just one service, but this is being created so we can have as many as we want.

ServiceHostEngine.cs

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();
            }
        }
    }
}

We are now to a part where Ninject is used to create the NHibernate session instances. We need to create a factory for creating NHibernate SessionFactories. We need a factory for every database that is being used. So, we need a SessionFactoryFactory. This will be back in our business layer.

SessionFactoryFactory.cs

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;
        }
    }
}

Now that we are able to create NHibernate sessions, let’s setup Ninject to create the ISession an SessionManager objects for us. We need to pass the connection string in to our Ninject setup so the SessionFactoryFactory can use the correct database connection. We will be creating a new Ninject kernel each WCF call, passing in the connection string.

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();
        }
    }
}

Now we can create our instance provider. The provider is what creates the instances that WCF uses. This gets called for every service method call because we used InstanceContextMode.PerCall for our services.

In the GetInstance method (which again happens per call), we create a Ninject kernel that we can use to create our objects for us. A SessionManager is created and a transaction is started. A transaction is meant to be used for a unit of work. Our unit of work here is a single service method call. A new service instance is then created by Ninject. This means that all our repositories in the constructor of the services will be injected for us.

The ReleaseInstance method is then called when the request is complete. In here we commit our transaction. If there are any errors, they are rolled back. The session is then closed.

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;
        }
    }
}

Now you may be wondering how all of this is setup. How do we let WCF know that it should use our instance provider instead? There are a couple custom configuration classes we need to create and we need to add our provider to the WCF configuration. Whatever app is running the WCF service; console app, windows service, or web app; a custom behavior needs to be added to it. In the services section, we setup our service with our custom element.

<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>

The custom element returns a new instance of our service behavior.

NHibernateBehaviorExtensionElement.cs

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 ); }
        }
    }
}

The service behavior is what actually creates out custom instance provider, passing in the service that is being used.

NHibernateServiceBehavior.cs

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 );
                }
            }
        }
    }
}

The WCF setup is now complete. We able to have multiple services running and use multiple databases. All the services objects are created by Ninject. Our WCF application is now a lot more unit testable that it was before. This may seem like a lot of work to setup, but once it’s done, everything else is a breeze. You will be able to add services and databases easily, and you don’t have to worry about creating your objects in your service.

The last step is to actually host this service in a console app, windows service or web app. You are limited to only using HTTP bindings if you choose to use an IIS hosted service. All you have to do then is to create an instance of the ServiceHostEngine, and start it.

Here is an example of a console app:

Program.cs

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();
        }
    }
}

I put the code up on github. http://github.com/JoshClose/WcfNhibernateNinjectExample

The reason it was tough wasn’t because it was hard to do, but that there were many different ways of doing it, and each had different results. Some ways would only capture the visible screen. Some would be missing backgrounds. Some wouldn’t capture pages that loaded with JavaScript, such as google.com.

I was able to find a way that has worked on every site I’ve tested so far that is a combination of many of the other methods I’ve found. This way also does not require any assembly outside of the System namespace.

The code is pretty small and self explanatory, so here is how I did it.

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;
        }
    }
}

From here, it’s pretty simple to start adding features like min/max width/height, a capture delay for pages that have Flash on them, etc.

Note: For Flash to work properly, you need to set the project type to x86. If running on a 64-bit system and the project is set to “Any CPU”, Flash won’t work because it’s not compatible with 64-bit systems.

<use file="MyPartialView" />

And if you have name your files using the _MyPartialView.spark convention:

<MyPartialView />

Now what if you don’t know the name of the partial file until runtime and need to dynamically render the view? As far as I know, there is no way of doing this in Spark. How you can get around this is by doing some inline code using ASP.NET MVCs RenderPartial method.

#Html.RenderPartial( myPartialViewVariable );

This is assuming myPartialViewVariable is a string variable with the name of the view that needs to be rendered.

Update:

When you use ASP.NET’s Html.RenderPartial, your data isn’t automatically passed along to the spark view. To pass your data along, use the ViewData dictionary, like you would in a controller.

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

In the partial view, use the <viewdata /> spark attribute like you normally would in a spark file.

<viewdata item="Item" />

To do this, type “about:config” in the address bar and filter on “v6″. Turn off IPV6 and FireFox should be fast again.

Scott Gu has a couple good posts on this.

http://weblogs.asp.net/scottgu/archive/2005/10/06/426755.aspx

http://weblogs.asp.net/scottgu/archive/2006/04/09/442332.aspx

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 ) );
}

Although, this didn’t work for me because I’m using Ninject.Web.Mvc. Instead, I get this error:

The IControllerFactory ‘Ninject.Web.Mvc.NinjectControllerFactory’ did not return a controller for a controller named ‘blah’.

The NinjectControllerFactory.CreateController( RequestContext requestContext, string controllerName ) method is returning null when it can’t find a controller, when it should be throwing a 404 HttpException.

There apparently is a patch waiting to be merged into trunk for this, but until then, you can use this change to the controller factory. The factory now inherits from DefaultControllerFactory, CreateController and ReleaseController are now overrides, and a test for a null controller will call base.CreateController.

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) { }
    }
}

I checked the references of my test project, and NHibernate.ByteCode.LinFu.dll was referenced, but the assembly wasn’t being copied into the test folder when ran with the script. I opened the test assembly up with ildasm.exe and checked the manifest and the LinFu assembly wasn’t in there. It was being references in the project, but apparently since there is not code actually using the assembly, the reference isn’t built into the manifest.

The way I fixed this is, in the unit test class I added a deployment item for the assembly that I wanted copied.

[DeploymentItem( @"..\References\NHibernate\NHibernate.ByteCode.LinFu.dll" )]

This fixed the failing unit test. Life is good again.

While doing some WCF work using the System.Component.ClientBase<TChannel>, I was running into a few issues. I was creating client proxy classes that inherited from ClientBase<TChannel>, and when using these, I would just wrap them in a using block.

using( var proxy = new MyProxy() )
{
    // Do some work.
}

This seems like what you’re supposed to do, but in this case, it’s not. I ran across an article on MSDN “Avoiding Problems with the Using Statement” that explains why you can’t use the using block. Basically, the Close() method on the proxy can throw exceptions, such as a timeout, and if this occurs, you need to call Abort() instead.

Here is the correct way to handle a proxy:

var proxy = new MyProxy();
try
{
    // Do some work.
    proxy.Close();
}
catch( CommunicationException ex )
{
    proxy.Abort();
}
catch( TimeoutException ex )
{
    proxy.Abort();
}
catch( Exception ex )
{
    proxy.Abort();
    throw;
}

EDIT:

After doing this a couple times, it gets pretty repetitive. I ended up creating a base proxy class.

    public abstract class ProxyBase<TChannel> : ClientBase<TChannel>, IDisposable where TChannel : class

Then I implemented IDisposable.

protected void CheckDisposed()
{
    if( disposed )
    {
        throw new ObjectDisposedException( GetType().Name );
    }
}

public void Dispose()
{
    Dispose( true );
    GC.SuppressFinalize( this );
}

protected virtual void Dispose( bool disposing )
{
    if( !disposed )
    {
        if( disposing )
        {
            try
            {
                base.Close();
            }
            catch( CommunicationException ex )
            {
                base.Abort();
            }
            catch( TimeoutException ex )
            {
                base.Abort();
            }
            catch( Exception ex )
            {
                base.Abort();
                throw;
            }
        }

        disposed = true;
    }
}

Now we can wrap our proxy in a using block again, and we get our security blanket back.

First off, what does tinting mean? Basically, if you have red and want to tint it 10% lighter, you would add 10% of white to the red.

How this is done in .NET is by taking the System.Drawing.Color and converting it’s RGB values to HSL values. You then can bump the lighting up or down a certain percent. After it’s converted back into RGB color values it will be a tint of the original color.

Converting RGB to HSL:

This is simple in .NET. The color object has 3 methods for this: GetHue(), GetSaturation(), and GetBrightness(). But wait a second here, are brightness and lighting the same thing? No, they are not. Wikipedia has a good description on the difference http://en.wikipedia.org/wiki/HSL_and_HSV. So why are we not converting into HSB instead of HSL? Apparently .NET is actually giving back lighting and not brightness. Chris Jackson has a great post on this http://blogs.msdn.com/cjacks/archive/2006/04/12/575476.aspx. His conversion from HSL to RGB is also the one I’m using in this post. So we just assume that GetBrightness() is actually giving us the lighting that we need.

Converting HSL to RGB:

Here is the tricky part. Thanks to Chris Jackson for posting this code.

public static class ColorHelper
{
    /// <summary>
    /// Converts the HSL values to a Color.
    /// </summary>
    /// <param name="alpha">The alpha.</param>
    /// <param name="hue">The hue.</param>
    /// <param name="saturation">The saturation.</param>
    /// <param name="lighting">The lighting.</param>
    /// <returns></returns>
    public static Color FromHsl( int alpha, float hue, float saturation, float lighting )
    {
        if( 0 > alpha || 255 < alpha )
        {
            throw new ArgumentOutOfRangeException( "alpha" );
        }
        if( 0f > hue || 360f < hue )
        {
            throw new ArgumentOutOfRangeException( "hue" );
        }
        if( 0f > saturation || 1f < saturation )
        {
            throw new ArgumentOutOfRangeException( "saturation" );
        }
        if( 0f > lighting || 1f < lighting )
        {
            throw new ArgumentOutOfRangeException( "lighting" );
        }

        if( 0 == saturation )
        {
            return Color.FromArgb( alpha, Convert.ToInt32( lighting * 255 ), Convert.ToInt32( lighting * 255 ), Convert.ToInt32( lighting * 255 ) );
        }

        float fMax, fMid, fMin;
        int iSextant, iMax, iMid, iMin;

        if( 0.5 < lighting )
        {
            fMax = lighting - ( lighting * saturation ) + saturation;
            fMin = lighting + ( lighting * saturation ) - saturation;
        }
        else
        {
            fMax = lighting + ( lighting * saturation );
            fMin = lighting - ( lighting * saturation );
        }

        iSextant = (int)Math.Floor( hue / 60f );
        if( 300f <= hue )
        {
            hue -= 360f;
        }
        hue /= 60f;
        hue -= 2f * (float)Math.Floor( ( ( iSextant + 1f ) % 6f ) / 2f );
        if( 0 == iSextant % 2 )
        {
            fMid = hue * ( fMax - fMin ) + fMin;
        }
        else
        {
            fMid = fMin - hue * ( fMax - fMin );
        }

        iMax = Convert.ToInt32( fMax * 255 );
        iMid = Convert.ToInt32( fMid * 255 );
        iMin = Convert.ToInt32( fMin * 255 );

        switch( iSextant )
        {
            case 1:
                return Color.FromArgb( alpha, iMid, iMax, iMin );
            case 2:
                return Color.FromArgb( alpha, iMin, iMax, iMid );
            case 3:
                return Color.FromArgb( alpha, iMin, iMid, iMax );
            case 4:
                return Color.FromArgb( alpha, iMid, iMin, iMax );
            case 5:
                return Color.FromArgb( alpha, iMax, iMin, iMid );
            default:
                return Color.FromArgb( alpha, iMax, iMid, iMin );
        }
    }
}

Now that we can do the conversion, let’s create some extension methods on Color to do lightening and darkening.

public static class ColorExtensions
{
    /// <summary>
    /// Tints the color by the given percent.
    /// </summary>
    /// <param name="color">The color being tinted.</param>
    /// <param name="percent">The percent to tint. Ex: 0.1 will make the color 10% lighter.</param>
    /// <returns>The new tinted color.</returns>
    public static Color Lighten( this Color color, float percent )
    {
        var lighting = color.GetBrightness();
        lighting = lighting + lighting * percent;
        if( lighting > 1.0 )
        {
            lighting = 1;
        }
        else if( lighting <= 0 )
        {
            lighting = 0.1f;
        }
        var tintedColor = ColorHelper.FromHsl( color.A, color.GetHue(), color.GetSaturation(), lighting );

        return tintedColor;
    }

    /// <summary>
    /// Tints the color by the given percent.
    /// </summary>
    /// <param name="color">The color being tinted.</param>
    /// <param name="percent">The percent to tint. Ex: 0.1 will make the color 10% darker.</param>
    /// <returns>The new tinted color.</returns>
    public static Color Darken( this Color color, float percent )
    {
        var lighting = color.GetBrightness();
        lighting = lighting - lighting * percent;
        if( lighting > 1.0 )
        {
            lighting = 1;
        }
        else if( lighting <= 0 )
        {
            lighting = 0;
        }
        var tintedColor = ColorHelper.FromHsl( color.A, color.GetHue(), color.GetSaturation(), lighting );

        return tintedColor;
    }
}

Now this makes it easy to create a tint of any color. To use this in a web page, we can use the System.Drawing.ColorTranslator.ToHtml( Color c ) method to give us our html color.