dead devs society

Altering VS Project Properties the easy way

2011-01-31T10:24:00.004+01:00

Often I need to "batch" alter visual studio project properties for very large solutions. Example we decided to disable mandatory xml comments on all 275 visual studio projects we have. The following sample can give you an idea of how easy it is to write a small program to do this:-)

recursively call a function...

2011-01-10T13:54:00.001+01:00

The following code fragment calls recursively a function calculating the sum of the Info integer property of every node in the tree...

If you like your func inside the method then in order to get rid of the definite assignment issue (the use of a local variable which isn't definitely assigned).

The Joel Test: 12 Steps to Better Code by Joel Spolsky

2010-10-27T18:46:00.001+02:00

The Joel Test (http://www.joelonsoftware.com/articles/fog0000000043.html)

Do you use source control?
Can you make a build in one step?
Do you make daily builds?
Do you have a bug database?
Do you fix bugs before writing new code?
Do you have an up-to-date schedule?
Do you have a spec?
Do programmers have quiet working conditions?
Do you use the best tools money can buy?
Do you have testers?
Do new candidates write code during their interview?
Do you do hallway usability testing?

I strongly recommend this post! Read it :-)

patterns & practices: Prism – A lap around build events!

2010-10-27T07:03:00.002+02:00

We all not and understand the notion of a Visual Studio Project and a Visual Studio Solution.

The point is that a solution has many projects and a project can belong to many solutions.

Solution & Project format

The format of a Visual Studio Project is MSBuild. The format of a Visual Studio Solution is something proprietary. It’s not even xml, it reminds me a basic(ish) lookBy the way I never understood the reason that they didn’t use MsBuild also for solutions. The following is simply a random solution file.

Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MVVM", "MVVM\MVVM.csproj", "{5071C191-7663-422C-AE32-4B638F6C12FA}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MVVM.Test", "MVVM.Test\MVVM.Test.csproj", "{2399D68D-7791-4979-B1F7-FD17A6399E2B}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{5071C191-7663-422C-AE32-4B638F6C12FA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{5071C191-7663-422C-AE32-4B638F6C12FA}.Debug|Any CPU.Build.0 = Debug|Any CPU
{5071C191-7663-422C-AE32-4B638F6C12FA}.Release|Any CPU.ActiveCfg = Release|Any CPU
{5071C191-7663-422C-AE32-4B638F6C12FA}.Release|Any CPU.Build.0 = Release|Any CPU
{2399D68D-7791-4979-B1F7-FD17A6399E2B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{2399D68D-7791-4979-B1F7-FD17A6399E2B}.Debug|Any CPU.Build.0 = Debug|Any CPU
{2399D68D-7791-4979-B1F7-FD17A6399E2B}.Release|Any CPU.ActiveCfg = Release|Any CPU
{2399D68D-7791-4979-B1F7-FD17A6399E2B}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

Build Events

What is a build event? Well by default every project gets to override two build events: Pre-Build and Post-Build. You can attach your own batch functionality here. Personally if you understand MsBuild well enough then there are better and more MsBuild friendly ways to do this. I consider this the poor mans approach to hook before and after the build. Stay tuned I will soon right a post on this…

Visual Studio provides also some help for you. If you click the “edit” buttons then you will get a simple editor with a list of “Macros”.

These macros are nothing more than PropertyGroups inside the hierarchy of MsBuild files that define the project. No wonder the convention for referening to any of these is $(macro_name).

Don’t abuse the build events

Wow, some very hard words. Abuse the build events? Well it can happen! Let’s take an example of a known open source project: Prism. You can download the sources at http://compositewpf.codeplex.com/

Prism offers some nicely written AcceptanceTests. I strongly recommend it for better understanding of UI Test Automation. Now the problem they try to address for the AcceptanceTest developer is solution decoupling. The AcceptanceTest Project being a black box, has no dependencies on any of the sources. On the other side the AcceptanceTest developer needs the possibility to make sure that the sources are build before executing the tests. In order to address this the Prism team has use a post-build event on the AcceptanceTest project.

$(MSBuildBinPath)\msbuild.exe "$(SolutionDir)..\MVVM.sln" /p:configuration=$(ConfigurationName)

The problems with this approach are the following:

You are obliged to build your app every single time you build your tests. In a larger system you partition solutions in order to avoid having to load (or build) too many projects. The cycle of change-build-run needs to be as fast as possible.
Making use of the $(SolutionDir) macro is not wise. Why? Well as I mention in the beginning of my post there can be a many-to-many relation between solutions and projects. As it’s easy to understand using the $(SolutionDir) macro forces you to be able to build the project ONLY within the context of the solution. Otherwise the relative path has a high risk to be wrong.
A better approach is you really like to use build events would be to use the $(ProjectPath) macro.

In a bigger system you will NEVER build solutions. Typically you build groups of projects in a well defined sequence. I include a sample of how to do this. My recommendation: don’t build solutions, build projects.

Configuration Patterns (a lap around ent lib configuration)

2010-10-24T03:02:00.004+02:00

I have being following the work of the Patterns & Practices team for many years now. My initial motivation was the Logging Application Block. Although the team has made significant progress the last 6-7 years it seems to me that they have being making circles in the area of configuration. Let me explain what I mean.

The Facade pattern (http://en.wikipedia.org/wiki/Facade_pattern)

A facade is an object that provides a simplified interface to a larger body of code. A facade can:

make a software library easier to use, understand and test, since the facade has convenient methods for common tasks;
make code that uses the library more readable, for the same reason;
reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system;
wrap a poorly-designed collection of APIs with a single well-designed API (as per task needs).

The Adapter Pattern (http://en.wikipedia.org/wiki/Adapter_pattern)

The adapter pattern (often referred to as the wrapper pattern or simply a wrapper) translates one interface for a class into a compatible interface. An adapter allows classes to work together that normally could not because of incompatible interfaces, by providing its interface to clients while using the original interface. The adapter translates calls to its interface into calls to the original interface, and the amount of code necessary to do this is typically small. The adapter is also responsible for transforming data into appropriate forms. For instance, if multiple boolean values are stored as a single integer but your consumer requires a 'true'/'false', the adapter would be responsible for extracting the appropriate values from the integer value.

Configuration equals to code

To my understanding a configuration file is nothing but source code. The fact that it’s format is XML for example and not csharp, doesn’t mean it is less important than the rest of your source code. As a rule of thumb: anything that alters the behavior of your system at runtime is source code. A good example is XAML, I guess nobody will disagree that XAML is source code. On the other side the customers table on your database is not source code. So if we have all agreed that the configuration of your logging facility is source code, I don’t understand why the two patterns above do not apply to configuration files also.

Configuration Façade Pattern

Let’s assume that your logging facility has say a complex and over engineered schema like the one that the Logging application block has. How can you shield your app from complexity, both in code and config?

In the few first iterations use the block as it is. Don’t try to upfront decide what features of the logging block you need and don’t rush into simplifying the configuration schema. You run into a serious risk here: you are aborting completely an agile approach and you risk loosing valuable time during the initial iterations with less significant issues such as your logging. In addition such cross-cutting concerns require the full attention of the high level architect. Well guess what: the architect has mainly to worry about the domain in the beginning of a project. Wrong decisions in the domain area cannot be easily reverted. the most important think in software development is to build a creative collaboration between technical and domain experts to iteratively cut ever closer to the conceptual heart of the problem.
Once you have delivered some bits and you have the team aligned and running it’s then time to start taking care of cross-domain facilities. Make a thorough investigation of what features of the logger you currently use. Most likely you will not need any more features from the block. Then based on your findings create a simple interface (something like an ILoggerFacade) that abstracts all you need from the logger. In addition create a simple xml schema to define the configuration you need for your logger. Try to keep it simple and as flat as possible.
Keeping the log configuration schema simple might be challenging. You as an architect might have problems with dev leads or crazy devs who cannot think out-of-the-box. They will argue that you need to leave a “window of opportunity” open for the future. I always answer back that the widest window of opportunity is simplicity.

When you design your configuration schema (I call also it Configuration Facade) you should also always have in mind your users. How is the app deployed? Where? Who is using it?

A web app needs to provide a configuration façade flexible enough to allow IT staff to alter it. I believe that the config tool that ent lib provides is a developer tool not something that IT can really utilize. The existence of the tool cannot hide the complexity of the xml schema.
On the other hand a desktop app needs to be able to be configured within the main user interface. You cannot expect your user to use another tool (say the ent lib config tool) to twist the log settings. Further more if things get really bad and your you are providing end-user support, then you should make sure that your support staff is in a position to guide the user through a simple process to change some settings.

Configuration Adapter Pattern

Let’s assume that you need to use a different log library. If you have a simple logger façade then inferring an adapter to do the switch is fairly simple. Don’t forget, the configuration. You also need to deal with config files. If you have a good and simple configuration façade then making a configuration adapter is also very simple. The problem I often have when changing from one library to another is all configuration. Don’t “vendor lock” your self. Don’t directly use the ent lib configuration. It will not be easy to change. Believe me.

3rdparty cherry picking / consistent configuration

There is no question that you need to have the possibility to cherry pick your 3rd party. Example: use logger from one vendor and caching from another. The ent lib has being designed to be cherry picked…. except the configuration. Why? Well because every 3rd party has a different configuration schema. Again: think your users… they have to be confronted with so many different xml config schemas. It doesn’t look consistent. It’s even confusing for developers. In addition your own app will need some kind of configuration. How many schemas are you going to maintain? Another issue is that in some cases you need the flexibility to play with config files at build and install time. The more files you have the more difficult and risky this process becomes.

StockTraderRI (a simple example)

The bla – bla – blabity above is pointless without an example. Instead of making my own sample, I have chosen to demonstrate the configuration patterns inside the latest (V4 drop 10) StockTraderRI application that ships with Prism. What we will do is replace the log configuration with our own adapter. The prism team has done an excellent job isolating the code from the logging block in this sample.

public class EnterpriseLibraryLoggerAdapter : ILoggerFacade
{
#region ILoggerFacade Members
public void Log(string message, Category category, Priority priority)
{
Logger.Write(message, category.ToString(), (int)priority);
}
#endregion
}

The immediate benefit we have from this simple adapter (could also call it facade) is that out of the 13 projects this solution has only one project needs references to “Microsoft.Practices.EnterpriseLibrary.Logging.dll”. This is simply beautiful design! Now we will do mthe same for the configuration.

public class EnterpriseLibraryLoggerAdapterConfiguration : ConfigurationSection
{
public Configure()
{
var builder = new ConfigurationSourceBuilder();

builder.ConfigureLogging()
.LogToCategoryNamed("General")
.SendTo.FlatFile("General Log File")
.FormatWith(new FormatterBuilder()
.TextFormatterNamed("Text Formatter")
.UsingTemplate("Timestamp: {timestamp}...{newline})}"))
.ToFile(FileName);

var configSource = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(configSource);
EnterpriseLibraryContainer.Current
= EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
}

[ConfigurationProperty("fileName")]
public string FileName
{
get { return this["fileName"] as string; }
}
}

I have kept the sample simple so the only parameter I configure for now is the file name. It’s not difficult to add more! Next you need to add the new typed section. Note the goodness here! You don’t need to add complex and loaded sections from ent lib. You have total control!

<configuration>
<configSections>
<section name="logAdapter" 
type="StockTraderRI.EnterpriseLibraryLoggerAdapterConfiguration,StockTraderRI"/>
<!--more sections follow-->

You also need of course to specify the settings for the section.

<logAdapter fileName="general.log" />

Somewhere you need to instantiate the ConfigSection in code and call the configure method

var section = (SomeConfig)ConfigurationManager.GetSection("logAdapter");
section.Configure();

This is it. Only for comparison I will show you what used to be inside the sample in respect to logging. I call this kind of configuration “THICK GLUE”. Don’t infer glue inside your application. Believe me it’s not a good idea. By the way: the glue is not harassing only you. It causes more pain to the patterns and practices team. Just imagine: they have to support all that, they have lost the right and the freedom to move on!

Log Format tips

If you are developing an application that is a web app or if you provide support for your desktop app the read the following lines very carefully.
The format of your log files is also an interface! You cannot change it anytime you like. Log files are usually read by IT staff and 1st level support staff before the ticket arrives to you as a bug. What most organizations do is attach log files together with the issues/bugs in order that they can search later in time (kind-of knowledge base). In addition you need to provide instructions to IT and support staff about how to interpret the log files at a high level. This is why I believe that the possibility to alter the format is a super-flexible way via configuration can be very tricky. So unless you have concrete requirements that formats need to change by configuration… hard code a simple format.

Conclusion

The ideas mentioned do not only apply to p&p libraries. WCF configuration is another example. I use WCF extensively. I have noticed that from all the noise inside the wcf config files (especially the client ones) nobody ever touches anything if the developer is not present. So what I do with WCF config files is exactly the same. Configuration Facades and Configuration Adapters!
I used the logging block of p&p as an example because I simply love the work and effort of this team!

Feedback

That’s all folks! The drop for the first iteration of this paper. Please send me feedback
I will post soon another related idea that I call configuration injection. It’s basically the idea of injecting typed configuration at a module level using either Unity extensions or the prism module catalog. Stay tuned.

Visual Studio 2010–Community Wallpapers

2010-10-24T00:10:00.001+02:00

If you are in love with visual studio… just as much as I am then you will definitely love this link!

http://vs2010wallpapers.com/

A non-Microsoft site, filled with Community Created Visual Studio 2010 Wallpapers!

… and many many more! Check it out

patterns & practices Symposium Redmond 2010

2010-10-23T00:44:00.002+02:00

The patterns and practices symposium in Redmond this year was just great. What I like about the p&p conferences is the personal contact that you get to have with the team. This is practically impossible in any bigger event. I have attended this event 4 years in row... had to travel all the way from Europe for this. It was worth it!

Speed up your Unity Container!

2010-10-19T20:59:00.002+02:00

The Unity Application Block (Unity) http://www.codeplex.com/unity is a lightweight extensible dependency injection container with support for constructor, property, and method call injection.
Unity offers supports 3 types of injection: Property, Constructor and Method Injection.
If you are prepared to trade Property and Method Injection for better performance... then continue reading. I will describe in simple steps how to disable Property and Method Injection.
Sadly you will need to comment out 4 lines from the Unity sources and recompile. I hope someday the Unity dev team provides the possibility to specify what types of injections your container should support upon container creation.

Step 1: UnityDefaultStrategiesExtension.cs

You need to comment out the following 4 lines:

Context.BuildPlanStrategies.AddNew(
UnityBuildStage.Initialization);

Context.BuildPlanStrategies.AddNew(
UnityBuildStage.Initialization);

Context.Policies.SetDefault(
new DefaultUnityPropertySelectorPolicy());

Context.Policies.SetDefault(
new DefaultUnityMethodSelectorPolicy());

Step 2: Recompile

Well Defined Model: Model+ViewViewModel

2010-09-28T17:00:00.003+02:00

The formal ModelViewViewModel pattern defines only 3 parts, the “View” and “ViewModel” are clearly defined and the rest we simply call “Model”. Is this enough? Absolutely not. There is a lot more to worry about than simply separating the visuals from code!

When building a composite application it’s vital to assign well define the responsibilities on each part and then stick with the rules you have defined.

I call the pattern “Model+” since in this case the Model has being well defined. So from this paper don’t expect anything special about the “View”-“ViewModel” pair. We all think we understand this one; the “Model” part is the key were all the problems arise!

The following design addresses many scenarios in a composite application. It’s simply one design, nothing more. You can find the source code with a sample application under: https://bakopanos.googlecode.com/svn/trunk/prism
The sample is a modified version of the original sample that ships with the Prism quickstarts.

Controller

The controller is responsible to create views and position the views on the appropriate placeholders. For example if you are using Prism (Composite WPF) these placeholders are called Regions and there is a RegionManager and a RegionRegistry to deal with regions. Another concern that the controller has is to activate views. For example activate the tab page in a tabstrip that contains the view you would like to show. It's appropriate to say that the controller orchestrates the User Interface Process.

It’s important to make sure that you decouple UIP from all the rest. This is the reason that an eventaggregator comes very handy here. The controller can subscribe to strongly types events and get notified about changes in the state. Typically in most cases this will be notification about selected item in a workflow or dirty items.

View

In order to implement correctly the Model-View-ViewModel pattern (Fowler: PresentationModel) you really need to restrict the View to only the visuals. The Passive View doesn’t require any unit testing and the visual designer can work decoupled from the developer.

ViewModel

When I think about ViewModels I really see them as facades. I am aware that most people see workflows as the place where all logic goes; the problem is that if you put too much in a ViewModel then better consider a ModelViewController approach. What I see sometimes is ViewModels being sub classed in order to allow reuse. To my understanding this is by definition wrong. A ViewModel should simply aggregate all that the view needs to display and provide them to the view in a simple structure. You can also have logic there that has to do with the current view, but nothing more.

WorkItem

The work item is the key to a composite application. Why? Because the workitem is where you store your state. Let’s consider an example: Your application should change to the current customer. In other words after you select the customer in a list box, anything that you do in any screen should consider that specific customer. So if you get a bug assigned to you that somewhere in the application the customer is not displayed properly, where is the place where you first look? What part of your architecture remembers that? To my understanding this should be the WorkItem. The ViewModel binds the selected item to the workitem, and when the selected item changes the workitem publishes an event. The interested controllers register for that event and drive in turn any UIP.

Services

BEWARE: services should be stateless. This is very important. If you would like your application to be easily changed and tested then model anything that has to do with state in a WorkItem.

There are two categories of services:

· Infrastructure Services, basically cross-domain functionality. Example ILogService

· Services, that interact with the business/service layer in order to support the application with domain specific functionality. Example IProjectService

Functional Construction Pattern: Parsing a csv file.

2010-09-11T16:18:00.001+02:00

The Functional Construction Pattern is used to construct a tree or graph of objects, with a code structure similar to what is used in functional programming languages. It is also called the Transform Pattern because it's used to create a new object graph based on a given one. Using the functional construction pattern you write code that is a lot more declarative (the structure of the generated object graph is visible in the code). One drawback is that code is not as easy to debug. In order to understand the pattern let's take the example of parsing a csv file into a collection of objects.

Sample csv file

Imperative approach for parsing a csv file

Declarative approach for parsing a csv file

Declarative approach for parsing a csv file, a more concise style

Streaming approach to save resources

When dealling with large files, better stream than read to end in order to reduce the memory used by your application.

Lines extension method

The following extension method (used previously) returns an IEnumerable reader.

The 5 minute Dependency Injection Container

2010-09-10T22:47:00.005+02:00

In order to decouple dependent components you have to make sure that the consumer component that depends on a service component doesn't need to create the service component.

This pattern is called Dependency Injection (Martin Fowler).

There are many DI frameworks available: Ninject, Spring.NET, Structuremap, Unity Application Block (Unity), Managed Extensibility Framework (MEF). It's not worth to worry about creating your own. However if you build a simple app and you need something light and simple, or if you just want to understand the concept of DI without the overhead of having to learn an API then you can use the following simple container to do some DI. The LightContainer has many limitations: supports only singletons, doesn't support named instances and doesn't inject dependencies automatically using typically reflection like the "good" libraries do. On the other hand it's simple to understand and thus it's easy to extend. In addition it's very fast since reflection is not necessary.

How to use it

Assume we have the following view-viewmodel and we'd like to wire them up using Dependency Injection. The first thing we need is an instance of the container. Then we need to register the lambdas that can create our services. Note that the sequence of the registration is not important. Now when we need an service instance, say a View, we simply resolve it from the container.

Modify your build process tutorial

2010-08-27T22:13:00.003+02:00

A visual studio project is an MSBuild script. If you would like to modify the project file use any xml or text editor.
You need to unload the project before you modify it...

… make modifications and then reloaded it again…

Don’t do this…

You will find the following lines inside any visual studio project

…don’t do this. You are better off making minimal changes in the project files. If you write your custom scripts inside seperate files then it's easier to share the msbuild code among your projects.

Organizing your msbuild files

Typically visual studio has reserved the *proj suffix for it’s own files.

c#	csproj
visual basic	vbproj
c++	vcproj
lightswitch	lsproj
vs deployment	vdproj

Unless you are creating a new visual studio project template don’t use a *proj suffixed file name. A good recomentation for msbuild filenames is the one that microsoft is using. Take a look inside the “C:\Windows\Microsoft.NET\Framework\v4.0.30319”. You will find some msbuild files there suffixed with *.tasks and *.targets

Microsoft.Common.Tasks

Microsoft.Common.targets

Microsoft.CSharp.targets

Microsoft.Data.Entity.targets

Microsoft.NETFramework.targets

Microsoft.VisualBasic.targets

Microsoft.WinFx.targets

*.Tasks files have only references to dlls with msbuild tasks

*.Targets files have all the code (msbuild scripts)

Creating custom msbuild files for your VS projects

Create 2 msbuild files with a text editor, or even in visual studio (add new xml file).
Example names: My.Tasks & My.Targets

Inside the *.tasks file you reference the necessary tasks

You need to import the *.tasks file insode the targets file

BuildDependsOn PropertGroup

The BuildDependsOn propertgroup overrides the BuildDependsOn of the visual studio build process. You can do here all you need. It’s much better than doing it inside the BeforeBuild and AfterBuild targets of the visual studio project file.
The only thing that is left now is to actually import the msbuild script inside the project file. In the following example I make the assumption that my msbuild scripts reside in the same directory as my solution.

Usefull property groups

Take a look at your project properties –> build events for nice examples of property groups that are already defined in the default build process.

Visual Studio LightSwitch, Beta 1 (x86) - DVD

2010-08-22T22:55:00.001+02:00

Wow!
LightSwitch beta1 finally available for download for msdn subscribers... 507MB download, no key required.

LightSwitch Installation

There is nothing currently to “Customize”…

… even the installation folder is fixed if you have vs2010 already installed!

The installation process should not take that long…

… and when done you get the “funny” for a developer option to run the app:-)

LightSwitch first run

Same splash screen as vs2010, no surprise since it runs integrated.

Under the LightSwitch templates you can choose your preferred programming language.

LightSwitch is truly data driven so the first thing that you need to take care of is connect to some data. For those of us you like to think objects first this might be a bit of frustrating!

Let’s create a new table, a “Customer” table. Use singular case here. why? Well behind the scenes there must be entity framework somewhere!

OK, we’ve got data now let’s make a screen to enter new records.

There is a hand full of commonly used data driven screen templates. Let’s hope there will be a possibility to extend these.

The user interface designer look pretty much like the good old Oracle Forms designer looked… only it’s much nicer:-) I hope there is a possibility to alter the wpf styles behind the scenes…

So let’s start the app hitting F5 =>
You get the lightswitch wcf server host up and running…

And this is how our first app looks like… not bad for the amount of work that we have invested.

LightSwitch first thoughts

I took a quick look at the solution folder and I was very surprised: the simple app we created before needs over 70MB in disk!!!
The project files are of course MsBuild project files like all other visual studio projects. They have reserved the *.lsproj extension.
The structure of the solution needs some studying, it’s not what you would expect for any other project.
Is MS Access dead? If I wanted to do something with access I would definitely consider LightSwitch.
Integration with source controls (at least SVN, HG and TFS) seems to be ok.
Would the LightSwitch environment support a large team? I am a bit skeptical here.

ASPNETPORTAL now on teamcity.codebetter.com

2010-08-19T23:44:00.001+02:00

Many thanks to Kyle Baley - The Coding Hillbilly for providing a free build server for the asp net portal starter kit.

Link to the build server: http://teamcity.codebetter.com/login.html

In order to register and build your own open source project there you need to sent an email to kyle@baley.org with your project information. As an example for the aspnet portal I have sent the following:

Username on the TeamCity server, you simply need to click register new account at the http://teamcity.codebetter.com/login.html
cbakopanos
Usernames of any other people you’d like to be administrators of the build
n/a
The name of the project
ASPNETPORTAL
A *brief* description
The ASPNETPortal Starter Kit demonstrates how you can use ASP.NET and the .NET Framework to build a dynamic portal application.
The project’s URL
http://aspnetportal.codeplex.com
The URL to the source code, better use the subversion uri if you are hosted in codeplex and use tfs because the svnbridge uri supports anonymous auth.
https://ASPNETPortal.svn.codeplex.com/svn
The name of the build runner (e.g. NAnt, Rake, MSBuild, command line, etc.)
MSBuild
The path to the build file (relative to the source code URL above)
build.proj
Any other details required by the build runner (e.g. the name of the target if different from the default)
run the build target

In my case I got a reply in less than 24 hours! Wow! I got a new project created for me with one build configuration.

Tip: The first thing you would like to do is click the link in the upper left corner “Configure visible projects” and make visible ONLY your project. Otherwise it takes for ever to load the initial home screen.

Another thing that you would like to probably do is see the revision number on the build. The picture above for example shows #rev: 49859. The default you will get is an automatically incremented build number per configuration 1,2,3,4,… You can do this by simply specifying in the general settings of your configuration the special build number format that teamcity understands.

Please note that ASPNETPortal_SVN in the above format refers to the vcs root of my project.

If your name has any spaces, dots or any other special chars then you have to replace them inside the format string with underscores. In other words you are better off giving your vcs root a “code friendly” name:-)

Working on a private remote branch

2010-08-19T14:16:00.002+02:00

The terminology used here is deriving from subversion but the concept is applicable to most source controls.

Most common scenario:
Checkout the sources from a “remote branch” into your “local copy”. Continue working there until you reach a point were your changes are good enough to be committed. In order not to deviate too much from the remote branch you often update your local copy.

PROS

Easy to understand.
No overhead in smaller projects.

CONS

Cannot commit sometimes for days. Especially in bigger teams the cost of breaking the remote branch can be very high.
Cannot go back in time in your local work. If you mess up half way through your implementation then there is no safe point… No one is controlling your local history.

Private Remote Branch:
Create a branch for your self only “private branch”. Checkout the sources from the “private branch” into your local copy. Frequently commit your changes into the “private branch”, even if you have not yet reached a point were your changes are good enough to be committed into the “team branch”. In order not to deviate too much from the “team branch” often merge changes into your “private branch”. When you are ready to commit to the “team branch” simply switch your local copy to that branch, stabilize and commit.

PROS

You can go back in history for all local work since you can afford to commit any time you like.
Once you grasp this concept you will typically make less and better commits to the team branch with better and more meaning full comments.
If necessary you can build your interim work in the build server or even share it with a co developer for reviewing.
The merging from the “team branch” to your “private branch” is really easy… basically equal to updating a local copy (since you are the only contributor to the “private branch”).

CONS

Overhead for a small project
More difficult to understand
Some source controls have shelving facilities. Example in TFS you can shelve your changes. This is not exactly equal to what has being described above (in TFS you shelve a state of your workspace with a name), but in most cases is more than enough.
Distributed source controls support private branches locally (you can locally commit). Again this is not exactly equal to the picture above (what if I loose my notebook?) but it is in most cases more than enough!

Create a new Subversion Repository

2010-08-18T16:42:00.001+02:00

Create a repository by right clicking inside the new repository empty folder.

You can access your repository using the repo browser. Right click anywhere in the windows explorer to open the repo browser.

Provide a valid Uri. If the new repository was created inside c:\test\MyRepo, then the Uri would be file:///c:\test\MyRepo

Notice the extra escape forward slash in the Uri.

If you were using a remote repository then this Uri would be the http path to your repository.

The repo browser is basically the "windows explorer" of subversion. It let's you view your repos and in addition it allows basic server side operations. Note that anything you do using the repo browser is a connected operation.

Now let's define the top level structure for our repository. Following subversion best practices we will create at the root folder 3 sub-folders: trunk, tags, branches.

You can create a new folder directly in the repo browser by right clicking at the level you would like your new folder to be created.

You need to give the new directory a name (example trunk) and also provide a meaning full comment. The creation of this folder creates basically a new revision to your repository. Make sure that you are not lazy with comments; the comment doesn't have to be long but it needs to give a clear explanation of the transaction that happened.

After you create all 3 top level folders your root structure should look like the following picture.

trunk is the main line of development in a SVN repository.
A branch is a side-line of development created to make larger, experimental or disrupting work without annoying users of the trunk version. Also, branches can be used to create development lines for multiple versions of the same product, like having a place to back port bug fixes into a stable release.
tags are markers to highlight notable revisions in the history of the repository, usually things like "this was released as 1.0". Please note that by convention you never alter code inside tags; you are better off revoking write access from tags to the majority of developers.
spikes are similar to branches (never for stabilizing) but for less formal work. An example is that I have under branches work that I need also to build on the build server, under spikes I have usually private paths or experiments that might not even be ever merged back to the main line "trunk".

Another top level structure for more demanding projects is the multi project repository structure. In this case the 1st level of directories contain names of projects and the second level of directories the same structure as before. This is a "hack" you can do in Svn in order to kind-of-mimic a distributed repository. Note that distributed facilities are not explicitly available in Svn, so you need to improvise each time you need operations such as merge, branch, etc across projects. In another source control like git, mercurial or Bazaar this would have no meaning since any operation across repositories is by nature supported.

My recommendation is to use the multi project repository in ANY CASE. Even if you don't needed yet... it's a win-win situation for the future.

NUnit Hello Test

2010-02-20T16:13:00.004+01:00

You can download NUnit from http://www.nunit.org/

Getting started (Hello Test) !!!
Let's write our first test and run/debug it.
1. Create a class library in visual studio. A good convention is to suffix all your test projects with *Tests.
2. Add a reference to Nunit

3. Create a class and optionally suffix it with "Fixture". Then decorate it with the [TestFixture] attribute.

4. Create a public method, optionaly suffix it with "Test" and decorate it with the [Test] attribute.

5. Build your class library project.
6. You can run/dubug the unit test directly from studio if you have any plugin such as Resharper (VERY GOOD!!!) or TestDriven.Net or any other plugging.
nunit.exe
Start nunit.exe and create a new project. Then you add "assembly" or "VS Project", both will do.

You can directly run the test from the gui provide it.
If you want to debugg then goto Visual studio and attach to the nunit process. Then set the desired breakpoints, kick the test you'd like from the NUnit app and you should hit your breakpoints.

nunit-console.exe

MSBuild
The easiest way is to use some 3rd party msbuild task such as the http://msbuildtasks.tigris.org/
In order to use the tasks in this project, you need to import the MSBuild.Community.Tasks.Targets files. If you installed the project with the msi installer, you can use the following.

You can find info on msbuild at http://msbuildtasks.com/default.aspx
The task to call for NUnit is the following

Save the xml file, let's assume you name it NUnitSample.proj and call it from MSBuild

ArchitectureSamples-FunqUnity in C#4.0

2009-12-06T18:35:00.005+01:00

I have posted a very nice sample application on my googlecode:
ArchitectureSamples-FunqUnity
You can checkout the code with tortoise. You need VS2010 Express or higher. Soon I will post a sibling to this sample also in VB.NET. All necessary binaries: Unity, NUnit and RhinoMocks are committed with the sample for your convenience.

The sample application demonstrates the following architectural aspects:
. Domain Driven Design / Repository Pattern
. Modularity: Type safe registration of services
. Modularity: Xml registration of components
. Modularity: Inject xml configuration
. Dependency Injection
. Unit Tests / Mocks: isolate the repository the layer when testing the application layer
. Functional programming: use lambdas to isolate components in child containers
. Functional programming: use lambdas to isolate ADO.NET infrastructure calls (connections, commands)
. Functional programming: use lambdas to create a database technology factory (sqlce, oledb, ...)

Please sent me comments... If I get enough input I will include more aspects such as:
. Presentation patterns: MVC (console apps)
. Presentation patterns: MVP (win apps and web forms apps)
. Presentation patterns: Presentation Model (wpf and silverlight)
. Data Access Guidance
. Web Services Layer, DTO pattern
. Plug-in patterns
. Domain Driven Design / aggregates, validation, rules

List of most common Design Patterns

2009-11-22T12:08:00.003+01:00

In software engineering, a design pattern is a general reusable solution to a commonly occurring problem in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Design pattern (computer science)

Below I have a list of most common design patterns.

Creational Patterns

Abstract Factory

Creates an instance of several families of classes

Builder

Separates object construction from its representation

Factory Method

Creates an instance of several derived classes

Prototype

A fully initialized instance to be copied or cloned

Singleton

A class of which only a single instance can exist

Structural Patterns

Adapter

Match interfaces of different classes

Bridge

Separates an object's interface from its implementation

Composite

A tree structure of simple and composite objects

Decorator

Add responsibilities to objects dynamically

Façade

A single class that represents an entire subsystem

Flyweight

A fine-grained instance used for efficient sharing

Proxy

An object representing another object

Behavioral Patterns

Chain of Responsibility

A way of passing a request between chains of objects

Command

Encapsulate a command request as an object

Interpreter

A way to include language elements in a program

Iterator

Sequentially access the elements of a collection

Mediator

Defines simplified communication between classes

Memento

Capture and restore an object's internal state

Observer

A way of notifying change to a number of classes

State

Alter an object's behavior when its state changes

Strategy

Encapsulates an algorithm inside a class

Template Method

Defer the exact steps of an algorithm to a subclass

Visitor

Defines a new operation to a class without change

Type safe named instances with Unity

2009-11-17T22:09:00.003+01:00

The following example demonstrates registering a named instance in Unity. The only problem here is that both the registration and resolving of the dependency is done using a string. Even using a static class to hardcode all strings in a kind-of type safe way gives us no guaranty that the developer will respect the convention.

An alternate way of doing this would be using a delegate to resolve the instance giving a type safe argument such as an enumeration. So the registration in unity is a bit different...

Instead of a static class with constants we now have a type safe enumeration:

...and finally the client class that resolves the delegate:

In addition the actual resolving of the configuration string (typically read from a config) is done lazy... at the moment we really need it.
Finally we don't have ambiguity in registering in the container a type such as string, since we now mark the instance with an additional type (marker type).

Implementing a .NET Framework Data Provider

2009-11-12T12:42:00.006+01:00

Five years ago I needed to implement a web app for a chemicals company, that was using data from SqlServer, Oracle, Documentum and Hummingbird. The problem was that at that time both Documentum and Hummingbird (document management systems) had no oledb nor .net providers available. So my data layer became a big mess due to the fact that some of my code was through ADO.NET and the rest was using proprietary API's from Documentum and Hummingbird. In addition having such code was very error prone and not testable at all, since those API's at that time were very low level.
The solution that I had found was to implement my own .NET Data Provider. I used as basis an example posted on msdn: Implementing a .NET Framework Data Provider.
The article provides a template implementation of a "Fake/Sample" data provider for an in-memory database "Fake/Sample". If you are investigating in this direction then following the above link will be very helpful.
For your convenience I have created a sample wpf app using this code. The code is an identical copy of the original; I have only made some improvements to make it up-to-date with .NET 4.0 since the initial article was written for .NET 1.0
You can checkout the sources using tortoise: http://bakopanos.googlecode.com/svn/trunk/blog/DotNetDataProviderTemplate/
I used Visual Studio 2010 for this :-)

An overview of the code
The "fake/sample" database in the sample mimics a real world database that returns a cursor of the following structure:

internal class SampleDbResultSet
{
    public struct MetaData
    {
        public string name;
        public Type type;
        public int maxSize;
    }
    public int recordsAffected;
    public MetaData[] metaData;
    public object[,] data;
}

The commands supported by the sample database are startwith "select " and startwith "update ". This is it: 2 hardcoded commands, no args or anything...
The select command returns always the following resultset hardcoded in code:

id  name  orderid  
1  Biggs  2001  
2  Brown  2121  
3  Jones  2543  
4  Smith  2772  
5  Tyler  3521

The update command simply alters the (2,2) cell of the above table.

Once you understand this sample you can implement your own wrapper for the database of your choice. I am about to implement a dataprovider for reading a large number of xml files...

Preventing Dialogs or Trace.Fail

2009-11-12T10:27:00.001+01:00

The System.Diagnostics provide a very nice infrastructure for logging. When you start an app, by default a DefaultTraceListener is added to the Debug.Listeners collection. The problem is that the DefaultTraceListener instance has the property AssertUiEnabled set to true. This will popup a nice message box, in case for example of this statement

In winforms or console apps this is quite nice. Especially the possibility to attempt a retry ...

In case you need to disable this dialog: for a wpf app, for asp.net, for a wcf service... then you simply need to set the AssertUiEnabled property to false. In addition you can wire your own outputs...

How much does it cost to resolve with Unity?

2009-11-11T22:26:00.006+01:00

The following sample shows how expensive it is to resolve types using a DI container. On my notebook it showed the following:

00:00:00.0040000
00:00:01.7080000
00:00:00.1640000

As you can easily see resolving a type with Unity is something like at least 40 times slower. Is it worth it? I believe yes because you'll catch up with the performance on good design.

Hints: migration from VS2008SP1 -> VS2010Ultimate

2009-11-11T11:09:00.000+01:00

1. The 2nd line of the project file has being changed

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

When you try to open the migrated project with VS2008 you simply get the following warning:

Project file contains ToolsVersion="4.0", which is not supported by this version of MSBuild. Treating the project as if it had ToolsVersion="3.5".

...all the rest work fine!

2. A whole set of new elements has being added to the default PropertyGroup of the project; all these are not breaking when you try to open the migrated project with VS2008.

<FileUpgradeFlags> 
</FileUpgradeFlags> 
<OldToolsVersion>3.5</OldToolsVersion> 
<UpgradeBackupLocation /> 
<PublishUrl>http://localhost/Utilities/</PublishUrl> 
<Install>true</Install> 
<InstallFrom>Web</InstallFrom> 
<UpdateEnabled>true</UpdateEnabled> 
<UpdateMode>Foreground</UpdateMode> 
<UpdateInterval>7</UpdateInterval> 
<UpdateIntervalUnits>Days</UpdateIntervalUnits> 
<UpdatePeriodically>false</UpdatePeriodically> 
<UpdateRequired>false</UpdateRequired> 
<MapFileExtensions>true</MapFileExtensions> 
<ApplicationRevision>0</ApplicationRevision> 
<ApplicationVersion>1.0.0.%2a</ApplicationVersion> 
<IsWebBootstrapper>true</IsWebBootstrapper> 
<UseApplicationTrust>false</UseApplicationTrust> 
<BootstrapperEnabled>true</BootstrapperEnabled>

3. A new element has being added on the PropertyGroup of each configuration; also nothing breaking... VS2008SP1 ignores them.

<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>

4. A new ItemGroup have being added; also nothing breaking... VS2008SP1 ignores them.

<ItemGroup> 
  <BootstrapperPackage Include="Microsoft.Net.Client.3.5"> 
    <Visible>False</Visible> 
    <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName> 
    <Install>false</Install> 
  </BootstrapperPackage> 
  <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1"> 
    <Visible>False</Visible> 
    <ProductName>.NET Framework 3.5 SP1</ProductName> 
    <Install>true</Install> 
  </BootstrapperPackage> 
  <BootstrapperPackage Include="Microsoft.VisualBasic.PowerPacks.10.0"> 
    <Visible>False</Visible> 
    <ProductName>Microsoft Visual Basic PowerPacks 10.0</ProductName> 
    <Install>true</Install> 
  </BootstrapperPackage> 
  <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1"> 
    <Visible>False</Visible> 
    <ProductName>Windows Installer 3.1</ProductName> 
    <Install>true</Install> 
  </BootstrapperPackage> 
</ItemGroup>

5. If your projects have being set to "Treat warnings as errors" then VS2010 is much more sensitive, especially to xmldocumentation mistakes.

Fail: VS2010 Setup

2009-11-11T10:26:00.000+01:00