Christoph De Baene (de p0l)

SQL Server 2008 RTM

Christoph De Baene — Wed, 06 Aug 2008 19:40:44 GMT

SQL Server 2008 is now available on MSDN and TechNet, see the announcement here. To have an overview of the new features, you can have a look here and you may download the SQL Server 2008 Books Online. Apparently has SQL Server 2008 powershell support!

SyntaxColor4Writer 0.28 Released

Christoph De Baene — Fri, 20 Jun 2008 20:20:31 GMT

Version 0.28 of SyntaxColor4Writer has been compiled with the latest bits of Windows Live Writer 2008 (12.0.1370.325). You can download it from here.

Links & Pieces - May 2008 (1)

Christoph De Baene — Mon, 19 May 2008 21:40:30 GMT

Visual Studio 2008 SP1

Download

What's New

Screencast

Application Blocks

Enterprise Library 4.0 (May 2008)

Service Packs

Microsoft Virtual PC 2007 SP1

Links & Pieces - April 2008

Christoph De Baene — Wed, 30 Apr 2008 19:32:43 GMT

Links & pieces - March 2008 (2)

Christoph De Baene — Mon, 31 Mar 2008 23:17:57 GMT

Introduction to the Unity Application Block

Christoph De Baene — Sun, 23 Mar 2008 13:38:43 GMT

The unity application block is a dependency injection container with support for constructor, property and method call injection. It simplifies the Inversion of Control (IoC) pattern and the Dependency Injection (DI) pattern. The Unity application block can be found on CodePlex.

The unity application block has two important methods for registering types and mappings into the container, namely RegisterType and RegisterInstance.

Method	Default Lifetime	Explanation
RegisterType	Transient lifetime	Container will create a new instance on each call to Resolve
RegisterInstance	Container-controller lifetime	Instance has the lifetime of the container

Below you find an example where we map the ILogger interface to ConsoleLogger (implements ILogger).

Copy Code


UnityContainer
container = new UnityContainer();
container.RegisterType<ILogger,
ConsoleLogger>();
ILogger logger = container.Resolve<ILogger>();

Assume you have the following class that contains a dependency to ILogger as a parameter on the constructor.

Copy Code


public class MyClass
{ ILogger _logger; public MyClass(ILogger
logger) { _logger = logger;
} }

If we use the Resolve method of UnityContainer it will automatically inject the ILogger (ConsoleLogger) object. This is called constructor injection.

Copy Code


UnityContainer
container = new UnityContainer();
container.RegisterType<ILogger,
ConsoleLogger>();
MyClass myClass = container.Resolve<MyClass>();

You can also map multiple types for the same interface. In that case you can use a key as a parameter.

Copy Code


UnityContainer
container = new UnityContainer();
container.RegisterType<ILogger,
ConsoleLogger>("console");
container.RegisterType<ILogger,
EventLogger>("event");

If you now try to resolve MyClass you will get an exception, because it cannot resolve which type (ConsoleLogger or EventLogger) to use. Therefore you can use the Dependency attribute where you can denote a key. For example:

Copy Code


public class MyClass
{ ILogger _logger; public MyClass([Dependency("console")]
ILogger logger) { _logger = logger;
} }

Below you find an example of property injection:

Copy Code


public class AnotherClass
{ ILogger _consoleLogger; ILogger _eventLogger; [Dependency("console")] public ILogger
ConsoleLogger { get { return _consoleLogger;
} set {
_consoleLogger = value;
} } [Dependency("event")] public ILogger
EventLogger { get { return _eventLogger;
} set {
_eventLogger = value;
} } }

Note that you can also map and register your types through a configuration file.

app.config - Copy Code


<?xml
version="1.0" encoding="utf-8" ?> <configuration> <configSections> <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,
Microsoft.Practices.Unity.Configuration" /> </configSections> <unity> <containers> <container> <types> <type name="console" type="IStaySharp.UnitySample.ILogger,
IStaySharp.UnitySample" mapTo="IStaySharp.UnitySample.ConsoleLogger,
IStaySharp.UnitySample" /> <type name="event" type="IStaySharp.UnitySample.ILogger,
IStaySharp.UnitySample" mapTo="IStaySharp.UnitySample.EventLogger,
IStaySharp.UnitySample" /> </types> </container> </containers> </unity> </configuration>

The following code shows you how to use a configuration file with UnityContainer.

Copy Code


UnityContainer
container = new UnityContainer();
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
section.Containers.Default.GetConfigCommand().Configure(container); ILogger logger = container.Resolve<ILogger>("console");

Edit and Continue not supported on 64-bit target machine

Christoph De Baene — Tue, 18 Mar 2008 12:50:14 GMT

When trying to edit some code during debug, I received the following dialog of Visual Studio:

It appears that the edit and continue feature is not supported when the target is a 64-bit application. On this page you find a nice overview of the scenarios where the edit and continue features are not supported. To resolve the problem, you have to set the target to x86, which can be found in the project properties.

Running a x86 libray on a x64 machine

Christoph De Baene — Fri, 14 Mar 2008 20:11:47 GMT

In my current sample project when the runtime tried to access the MyMeta library (see following post) I always get the following FatalExecutingEngineError exception:

It turns out that the problem is that the MyMeta library is compiled under a x86 platform whereas the application is running on a x64 platform. In the properties settings of your visual studio project you have to set the platform target to x86! It was set to 'Any CPU', but now everything works fine.

Links & Pieces - March 2008 (1)

Christoph De Baene — Thu, 13 Mar 2008 06:19:03 GMT

Object Orientation
Internet Explorer 8 Beta 1
- Discovering the Internet Explorer 8 Developer Tools
- Packages
ASP.NET
- ASP.NET MVC Preview 2
- ASP.NET MVC Cheesy Northwind Sample Code
Silverlight 2 Beta 1
Visual Studio 2008
- PowerCommands for Visual Studio 2008
- Source Code Outliner PowerToy
Misc
- Continuous Integration: From Theory to Practice 2nd Edition
- NDepend Metrics Poster (.pdf)

Component Dropper v0.9 - Add-in for Visual Studio

Christoph De Baene — Tue, 04 Mar 2008 16:28:38 GMT

Component Dropper is a component that resides in the toolbox of VS.NET and enables you to choose a component (controls, datasets, providers, components, etc.) from the assemblies that are referenced in the current project.

In Visual Studio .NET you can auto populate the controls in the toolbox by setting the AutoToolboxPopulate property to true in menu Tools -> Options -> Windows Forms Designer.

Component Dropper is an alternative way for dropping a component on the designer surface. It gives you a dialog with all the components that reside in the assemblies that are referenced in the current project. This means that it is not limited to the assemblies that reside in the current solution. This way you can easily browse and search throughout the assemblies and controls, this is very handy if you have bunch of assemblies and controls. There is never a need to refresh the toolbox, because it dynamically searches throughout the references in the current project.

Download: ComponentDropper v0.9 (35.04 KB)

There is also a demo (1.11 Mb) that illustrates the use of Component Dropper. Note that the demo uses an older version of Component Dropper, namely version 0.5, and it's not an VS add-in anymore.

If after installation you don't see the component dropper appearing in the toolbox, you can simply drag-and-drop the IStaySharp.RazorToolbox.dll to the toolbox.
Any suggestions or remarks are welcome!