Being Scott Densmore

Found my new home

scottdensmore — Fri, 01 Aug 2008 23:54:00 GMT

Now that I live in the outside world, I decided I needed a place of my own. You can now find me at http://scottdensmore.typepad.com.

See you there. All 3 of you.

Unity Lives! Get your copy today.

scottdensmore — Sat, 05 Apr 2008 02:19:19 GMT

Awesome work by the entire team! You can get it from MSDN here or from CodePlex. Please discuss and provide feedback so we can make this even better. Objects of the code Unite! [I know, corny].

Also: I have built an extension to Unity that i will be blogging about over the weekend. This is an extension to do Interception (ala PIAB) that I ported from the ObjectBuilder work that Brad and I did.

Enjoy!

xUnit.net 1.0 RC2 Released

scottdensmore — Mon, 17 Mar 2008 02:27:54 GMT

I am sure it would have been soon if it wasn't for the late night WoW session (we can blame any bugs on that too). Go read about it from Brad here.

How to get Enterprise Library 3.1 working in VS 2008

scottdensmore — Thu, 13 Mar 2008 23:08:00 GMT

Enterprise Library 3.1 was published for Visual Studio 2005. That is to say: the Guidance Packages and the integrated Configuration Tool were built to work with Visual Studio 2005. The rest of the library works against .NET 2.0 and continues to work with .NET 3.5 apps.

We have done some work to get the integrated tool to work in Visual Studio 2008. If you run the following registry script it will change the keys where VS looks to load the integrated tool package. After you run the script, you will need to run devenv /setup from the Visual Studio 2008 command prompt.

You can download the file from the EntLibContrib project on CodePlex from here.

[edit]

I will try and be a little clearer for the steps:

1. Install EL 3.1 (you don't need the Guidance Packages)

2. Run the script

3. Run devenv /setup from the VS 2008 command prompt

Wheels from the album "Pressure Chief" by Cake

Unity available on CodePlex

scottdensmore — Wed, 13 Feb 2008 03:14:00 GMT

The team has done some great work to get this ready. Please provide us feedback and track any issues.

I want to congratulate the team on their effort!

Get the bits and read about Unity here.

Technorati Tags: patterns & practices, Unity

Enterprise Library 4: Now with more Peace Love and Rock n' Roll

scottdensmore — Thu, 31 Jan 2008 19:14:00 GMT

At the p&p Summit in November here in Redmond I gave a talk called "EntLib Refactored". This talk was started by my work done on the EntLib contrib project under the same name. What I wanted to do was make Enterprise Library smaller, simpler and easier to consume. My first attempt was to rewrite the blocks to not depend on Configuration. This was a great first stab, yet I found that what I really wanted was to reduce the size of things (which factoring out config did not do). What I wanted to do was get rid of the factories and use a Dependency Injection Container to wire up the objects. Brad Wilson and myself had been working on Object Builder 2 and Containers on top of them to test it out. What we needed for Enterprise Library was a DI Container.

After working on previous versions of Enterprise Library, we have learned that we needed Dependency Injection (DI) without knowing it and did it at the most basic level. We created factories: which is a form of simple DI. The problem this created is that each individual block was responsible for it's own configuration and configuration was buried at the bottom of the stack. We need to change around the model a bit to make the responsibility of configuration built into the DI Container and remove all that extra code from each block.

Here is a picture of the old way: [BTW Enterprise Library Factory is buried at the bottom in the Core assembly that no one sees.]

Here is the new way:

This looks better. Configuration is about the container. WAHOOOOOO! This means that building a block, using a block adding your extensions and having the configuration all comes through the container. This will make it easier for you to use Enterprise Library with Unity or your current DI container and allow us to deliver more cool things to you, the customer. Look for more on this later.

That all sounds good, yet there is one lagging thing that needed to be addressed: the devil. Backwards compatibility is the work of the devil, and just like the devil, necessary. This is fueled by the fact that Enterprise Library has reached over a million downloads and not having a story would cause a lot of people to swing large baseball bats at us. So the old way will still work working with factories so you can upgrade and migrate slowly.

Unity is a lightweight container built on top of the work of Object Builder 2, with heavy tweeks by Chris Tavaras. You can read more from Grigori and Chris on Unity.

The funny story about Unity is the name. Grigori and I were trying to come up with a name for this DI block and mentioned it to Peter Provost when we settled on Unity (which is better than the Doohicky Application Block that was up on the board). Peter never thought we would get it pass legal... neener neener is what we said when we got it. He said "Enterprise Library 4: Now with more Peace love and Rock n' Roll".

Doesn't Remind Me from the album "Out Of Exile" by Audioslave

Technorati Tags: Enterprise Library, patterns & practices, Unity

Unity and Enterprise Library 4 Team

scottdensmore — Wed, 30 Jan 2008 08:40:00 GMT

I am back on the team (and no I am not writing configuration again).

Borrowed pic from Grigori's original post.

Technorati Tags: Enterprise Library, patterns & practices, Unity

Unite with Unity

scottdensmore — Wed, 30 Jan 2008 08:34:00 GMT

Unity is our new Dependency Injection Container that will soon be available. Read more from Grigori.

Doesn't Remind Me from the album "Out Of Exile" by Audioslave

Technorati Tags: Unity

My New Home - CodePlex

scottdensmore — Thu, 19 Oct 2006 19:01:42 GMT

For the last nine months I have been working in a group working on a project doing WinFX (.NET 3.0) with CAB. (No, the reports are wrong, I was not living under a rock). I can definitely say that it has been fun working with XAML. Turning a ListBox into a totally new thing with a few lines of code is wicked cool. Now it is time for the next evolution in my career.

To be honest, when I was looking at the next stage of my career 9 months ago, I contacted Jim about the CodePlex project. At that time, he was just getting traction and did not have a spot for me. Little did I know that after I accepted the offer with my current job space would open up. I know what you are thinking because I am thinking the same thing… “Why oh why did I not take the CodePlex pill?”. I saved it for a rainy day. [I live in Seattle.] I start October 24th!.

Now playing: Tool - Lost Keys (Blame Hofmann)

What do you know Joe... Enterprise Library is out the door

scottdensmore — Sat, 21 Jan 2006 01:32:03 GMT

Go get it while it is hot here. I can’t believe.. we could have waited a few more days and it would have been a full year.

Now playing: Collective Soul - Forgiveness

Enterprse Library V 2.0 - It must be the end of the world

scottdensmore — Wed, 18 Jan 2006 00:31:04 GMT

I have been really busy working on my new team, but I just noticed 3 new things that I found very cool that I thought I would pass along :

Enterprise Library should be out this week via Tom
Brian Button explains how we used Object Builder in Enterprise Library
The Seattle Seahawks are in the NFC title game.

All that being said, I have to say I am cheering on my Steelers to go all the way.

Now playing: Toad The Wet Sprocket - Walk On The Ocean

This is Scott... not saying goodbye.... just saying...

scottdensmore — Thu, 08 Dec 2005 04:19:46 GMT

Now that I have finally finished working on the Design Time Tool (for the last time) and Enterprise Library 2.0 is near the finish line. I can let the cat out of the bag.

What a long strange trip it has been. It is hard to believe that almost 3 years ago (January 6th), I started back at Microsoft and this small little group I had never heard of called patterns & practices. 3 years ago J.D. Meier e-mailed me and asked me to come do an interview. Believe it or not, I was the second developer they hired as a full time employee (FTE) (most development was done with MCS). It has been amazing to see the growth of this business and it’s following. Alas, it is time to move on.

When I first got here, I started working on small projects like the first Logging Block, Authorization and Profile, and a *research* project that would help integrate our deliverables into the developer environment (now known as GAT). That first year went by fast and led me straight in the middle of this small little project known as Enterprise Library. For the past 2 years, I have really enjoyed seeing the uptake by the community and helping everyone out. I am passing on the torch of dev lead to Brian Button. He will take very good care of you. And lets not forget Tom and Ed.

Where am I going? Well if I tell you I would have to kill you, but it is going to be really cool. I will still post random thoughts about technology etc and preach p&p. I just want to thank Gary for giving me the chance.

Along the way I have met and worked with some amazing people. For those who I forget, I apologize up front. (I feel like I am at some awards ceremony and like an awards ceremony, the comments will not make sense to most).
Jim Newkirk – the players coach
Brian Button – never gets angry or forgets his robe and sandles
Peter Provost – my little prodigy
Brad Wilson – we are to much alike music man
Tom Hollander – community bulldog
Jason Hogg – who needs a car in New York (that is why you ran out of gas)
J.D. Meier – dragon whip tail
Edjez – boy I wish I knew some spanish / polish
Darrell Snow – yes I am a prima donna
The rest of the team

tshak – the kid
olaf – the other kid

Kzu – system.componentmodel can solve everything
fds – DI guy
All those guys at Clarius – automate your life

And last but not least, the management team at patterns & practices.

Now playing: Queens Of The Stone Age - Song For The Deaf

December Release

scottdensmore — Tue, 06 Dec 2005 19:17:04 GMT

For all of those who wanted the tool because they hate figuring out the schema for the xml, here is a pretty solid preview. We have really been hard at work to finish this off. Don’t blame Olaf, most of it is my fault. I wanted to make things a bit easier to add your own design time nodes. Go and download it here.

Now playing: Adam & The Ants - Stand And Deliver

Enterprise Library Core Webcast

scottdensmore — Tue, 06 Dec 2005 19:13:32 GMT

As Tom and Ed have pointed out, there are some major changes to the core architecture of Enterprise Library 2.0. Join Tom and I to talk about our integration of object builder, Configuration Sources, and the new (kinda) design time for all the blocks. This will be the last time you get to here my annoying voice (more on that later). Sign up here.

Now playing: Alien Ant Farm - Quite

Enterprise Library 2.0 / Configuration 12.0

scottdensmore — Wed, 09 Nov 2005 01:13:10 GMT

We have done it again. Another drop another configuration change. You can read the marketing mojo from Tom. Read the MSDN announcement and download it here. All feedback welcome.

Now playing: Joe Satriani - Surfing With The Alien

Do you have what it takes?

scottdensmore — Wed, 26 Oct 2005 01:07:54 GMT

Ever wanted to work with some of the greatest minds on some great software? Well throw your hat in the ring and give it a try. We are hiring. The full job description is here.

Now playing: Green Day - American Idiot

CAB October 2005 CTP Available

scottdensmore — Mon, 10 Oct 2005 17:34:21 GMT

The team has been driving hard to get this to you. I would definetly download it and start playing with it. We (Enterprise Library) are going to be using the cool DI code in our project (yes everything you learned for the August CTP is useless now ). Take a look at the Object Builder code from Brad and Peter.

Read both Brad’s and Peter’s blog for great info.

Get the life changer at http://codegallery.gotdotnet.com/cab.

Is Your ASP.Net Process Hanging using Enterprise Library?

scottdensmore — Fri, 09 Sep 2005 20:16:37 GMT

I was debugging a app from our product support team where a customer’s ASP.Net app was hanging. The way we solved their problem was by putting the application name in their web.conifg. This is a little known feature (aka undocumented) that can cause you some pain. If you are seeing this problem you will need to add a key in your appSettings of your config file named Microsoft.Practices.EnterpriseLibrary.Configuration.ConfigurationManager.ApplicationName and you should be good. You can put any name you want and when you get messages in the Event Log you will get that name as the name of the application. The offending code can be found in the file PerformanceCounterInstances.cs in the project Common at line 81.

No interestingly enough , someone just posted the same thing plus a little more on the GDN site here. This is a good read and I congratulate them for being so thorough.

Now playing: Garbage - Wicked Ways

Architecture Testing Guide Released

scottdensmore — Wed, 31 Aug 2005 18:53:21 GMT

The patterns & practices Architecture Testing Guide is designed to help project stakeholders, software designers, developers, and testers understand the process of testing software architecture before the code is implemented. The paper describes an approach and methodology for testing the design of a system, and describes the user-specific viewpoints that you must consider during the testing process. The Architecture Testing Guide walks through the process of testing a system from each viewpoint, and provides instructions, examples, and best practices along the way. A draft version of the paper is for download here.

You can download it from GDN.

Enterprise Library : August CTP Available

scottdensmore — Sat, 27 Aug 2005 08:53:26 GMT

I am sure I am a little late to the party, but we have worked hard and here it is. We really want your feedback, so go get it.

A big thanks to the whole team for getting this out! Have fun while giving it a spin.

Fernandos Configuration and Dependecny Injection Post

scottdensmore — Tue, 16 Aug 2005 20:48:17 GMT

Fernando’s server is giving him problem so I am posting it here for everyone to enjoy .

Enterprise Library, System.Configuration and Dependency Injection

What we did

For the new version of EntLib, we did two major changes in the way to deal with configuration and in the way the blocks relate to configuration, as Scott announced a few days ago.

On the configuration side, we switched to the configuration management support provided by .NET Framework 2.0. This has a lot of implications that will be described in later posts, but the most important change is that now all configuration objects extend types from the System.Configuration namespace and its serialization behavior is no longer defined by Xml serialization attributes but by ConfigurationElement attributes. There’s an almost one to one mapping between the configuration support provided by the previous version of EntLib and new the configuration features in the .NET Framework, which makes the transition easier.

As for the relation between the feature objects and configuration, well, there were some major changes. A usual requirement for the previous version of EntLib was to make its features available without having to deal with configuration. One of the main goals for this new version was to make it possible to just create the feature objects, such as providers or databases, and use them without having to rely on any configuration whatsoever. Once we got that we were able to do very interesting stuff with Dependency Injection, as we will see later. For an introduction to Dependency Injection (DI) you can check out http://www.martinfowler.com/articles/injection.html.

Back to basics

We went back to the basics when analyzing how to simplify even further the usage patterns for EntLib.

To use a feature object, we need to get a reference to it. Usually, this means creating it or getting an existing reference to a previously created object.

So, what do we need to create an object? We just need to call the adequate constructor with the adequate parameters. Any user of the library should be able to do that.

What if we could have factories do the same? Just new up objects calling the constructors with the required parameters. And better yet, what if we could do it without writing specific factory code for each object? Well, that's what DI is all about.

Synergy between System.Configuration and DI

Our solution, which will be available on the first preview of this new version, is to make our Configuration objects collaborate with the factories in a generic way, so that the factories can get the appropriate parameters and call the right constructor on the feature objects without us having to write custom code for that.

The key for our solution to work is to annotate the configuration elements with what we call "InjectionParameter" attributes. These attributes let the factories know which constructor to use and how to acquire the parameters to call that constructor. This way, we only need a small injection engine that can interpret the attributes and fire the appropriate constructor lookup and parameter retrieval.

Even better, the configuration objects are not constrained to be ConfigurationElements in the System.Configuration sense for the factories to work well with them. The only requirement is that they have the adequate attributes for the mechanism to work. And of course, the use of these mechanisms is not limited to EntLib ;)

One very important design guideline we imposed ourselves was that feature objects should be completely unaware of configurations and factories. They should just do their job, as long as they were adequately constructed.

Main concepts

Factory Interfaces

The first concept we define is the abstraction of "Factories", which are an evolution of what we already had in the previous version of EntLib. These abstractions are not coupled with the injection mechanism; they just define an API to create objects, whether using DI to do so or not. They are, however, used by the DI mechanism to get objects when required, as we'll see later.

There are some different ways to ask a factory for an object:

To ask for the instance with a given name
To ask for the default instance
To give a configuration describing the instance we want the factory to build

A concept that surfaces here is that of "configuration source". It's very similar to the previous version’s ConfigurationContext, but the implementation differs. This will be explained in a later post.

Injection attributes & configuration decoration

Injection attributes are the way to indicate, in a configuration object, what constructor to use and how to get the parameters to call that constructor when creating the feature object described by the configuration object. There are several predefined injection attributes covering all the cases we came across, but the concept is extensible to suit whatever needs surface in the future. Again the concept is simple: provide an argument to a constructor. These are class attributes, used to annotate the configuration types.

This is how it looks:

[InjectionAttributeA(0, typeof(SomeType1), [extra argument parameters])]

[InjectionAttributeB(1, typeof(SomeType2), [extra argument parameters])]

[InjectionAttributeC(2, typeof(SomeType3), [extra argument parameters])]

public class MyObjectConfiguration

{

…

}

The first attribute parameter is the position of the constructor argument defined by it. Of course, these have to be consecutive and non-repeating, zero starting ints. The second attribute parameter is the declared type of the constructor argument. The rest of the parameters depend on the actual injection attribute.

This specification will match to a constructor like:

public class MyObject()

{

public MyObject(SomeType1 arg1, SomeType2 arg2, SomeType3 arg3)

{

…

}

...

}

(There’s no need for names to match in any way, it's just a naming convention).

Usually the arguments for the constructor will depend on the value of a property on the configuration object; however, some times they don't. That's the reason for the first classification for injection attributes: the ones that are related to properties in the configuration object and the ones that are not.

Since the property related injection attributes are by far the most common, we'll focus on them. All of them share an attribute parameter that specifies the name of the property they should deal with.

There are several interesting ways to deal with the properties of the configuration objects, and each has an injection attribute that represents that usage:

Value: The simplest usage of a configuration property is to use its value as the constructor argument. This is usually the case for primitive types. The injection attribute used to specify this usage doesn't need further configuration.
Nested configuration: in other cases the configuration object's aggregates a configuration object for another feature object type. In this case, we need a factory that can interpret this configuration. Not surprisingly, the injection attribute that represents this case needs a parameter to specify the factory type to use when getting the constructor argument. This is usually used with collections of configuration elements.
Reference: It's very common for blocks to have named references to other blocks' feature objects; a usual case is a block object that uses a database. In this case the configuration object will have a string property representing the name of the referenced object. But we don't want the feature object we're configuring to get the name of the referenced object it needs, we want it to get the actual object! So we specify a reference usage that will take the value of the property and, assuming its value is a name, it will ask a suitable factory for the object with that name. So again we have to specify the factory we want to use to get this constructor argument.

Injection factories

The interesting implementations of the factory interfaces are the ones that actually use the injection attributes to do the work for us. In fact, these implementations are built using .NET 2.0 generics, so this gives us a very convenient mix of abstraction and type safety.

The basic implementation of these generic injection factories is:

Get the configuration for the object to build. Depending on the overload called, this means:

Just use the configuration passed as an argument

Get the configuration from the configuration source based on a name

Do something else: get it from an unnamed configuration location, create a configuration based on pieces lying around. The possibilities are unbounded

Extract the injection configuration from the configuration object, based on the injection attributes from the configuration object type.

Get the type of the object to build. This might be known in advance in some cases, but for factories of polymorphic hierarchies there's usually some piece of information in the configuration object to hint the type of feature object to create.

Get the constructor of the object to build. This is just a matter of retrieving the constructor that matches the parameter types specified by the injection attributes.

Get the constructor parameters to build the object. This involves both the injection configuration and the actual configuration object. For each parameter injection specification, the factory will get the corresponding constructor parameter in the way specified. Actually, lazy as it is, the factory will gently ask the injection specification to get the parameter on its behalf; this makes it possible to plug new parameter acquiring strategies very easily.

Invoke the constructor with the arguments, and return it.

This is the default implementation, and will usually be enough for most of the factories. Concrete factories that support named object access must override the configuration lookup method; this usually involves just getting some configuration object from the configuration source, but it might be more involved in some cases.

Getting objects!

After all this, how do we get to the actual objects? We have several options.

We can ask the factory for the object with a given name:

MyObject object = myObjectFactory.Create(“myObjectName”);

We can ask the factory to create the object with a given configuration:

MyObjectData data = new MyObjectData();

data.PropertyA = XXX;

data.PropertyB = YYY;

...

MyObject object = myObjectFactory.Create(data);

Or we can just new up the object the old fashioned way:

MyObject object = new MyObject(XXX, YYY, ...);

Once we have the object, we can make it work for us just like we did before.

Summary

This was just a glimpse of what will be available in the EntLib CTP. Later posts from the EntLib dev team will address:

· In depth explanations of the DI support: how it works, what will be available out of the box and what can be extended

· The way System.Configuration is leveraged, what was extended and what types were created to make things even easier

· End to end samples to show these mechanisms, both with blocks’ code samples and with completely new implementations.

Stay tuned!

Now playing: Metallica - The Frayed Ends of Sanity

Enterprise Library : Configuraiton2 and Injection

scottdensmore — Tue, 16 Aug 2005 17:01:58 GMT

You knew it was coming. Configuration again. This time around it was fun because I got to work with Fernando. I have been bugging him about getting a blog and now that he has one, I thought I would let him write the first post on the new Configuration and Dependency Injection overview in Enterprise Library 2.0. Then he and I will start drilling down on the topics in the overview. Think of it as on-line hands on labs . I will try to focus on how you can upgrade / relate this to V1.x, because it is very similar. We wanted to get some information out there for the August CTP.

One of the best things about working at Microsoft is working with smart people, especially those people out in the world that are our customers. There are a lot of them at Clarius.

I am completely stoked about the new version! Get ready for a lot more. Be nice to Fernando he is new.

Update : If you can’t get to Fernando’s site the post is here now.

Now playing: Iron Maiden - Bring Your Daughter...To the Slaughter

More Enterprise Library 1.x Posts and Series

scottdensmore — Mon, 15 Aug 2005 04:43:29 GMT

Via TSHAK : two new cool posts. One is going to be a series on 1.x.

Managing enterprise library configuration over multiple environments
DotNetJunkies is doing a series on Enterprise Library, starting with an overview and then publishing a detailed article for each block. Check out the first in this series.

Now playing: Dokken - It's Not Love

Enterprise Library : Tom on Logging

scottdensmore — Sun, 14 Aug 2005 06:10:08 GMT

I am sure everyone is getting anxious, and I am definitely getting excited. Tom covers what you will see in the soon to be released preview of Enterprise Library 2.0. We have been rolling right along and making progress to get aligned with the new platform. Check it out here.

Thanks Tom!

Now playing: Rusted Root - Ecstasy

VB6 Upgrade Guide

scottdensmore — Sun, 14 Aug 2005 06:05:10 GMT

Another one from patterns & practices! Eugenio Pace can tell you all about the VB6 to VB.NET upgrade guide. If you need a painless way to get yourself to .NET, this is for you!

Now playing: Rusted Root - Drum Trip