Jelle Bens

Executing all SQL files in a folder

2011-11-18T13:55:00.001+01:00

SET dbName=RemmicomMeetingDb
SET sqlCmdCommand=sqlcmd -S . -E -i

%sqlCmdCommand% "DropAndCreateDb.sql"

FOR /F %%i IN ('dir /b /on *.sql') DO %sqlCmdCommand% %%i -d %dbName%

Incremental Software Delivery

2011-11-07T23:44:00.000+01:00

What i see occur quite often is that User Stories are to big, resulting in work that is not done at the end of the sprint.

Lets take a look at the story below:

As an office manager I would like to be able to lookup contacts quickly so that I can quickly find someone's contact details.

Acceptance criteria

Given an Office Manager enters "como" When I press the search button Then he/she should see the contact details of everyone who's full name contains "como"

Given an Office Manager enters"ce" When I press the search button Then he/she should see the contact details off everyone's title containing "ce"
...

Now if we think about this for a second, we could start to break down the tasks as follows:

Create the database tables
Create the data access layer
Create the DTO's
Create the UI
Create the service layer

If we stop and think about this a second it does not really make sense in a incremental delivery mindset. If you reflect on this from a Form Follows Function Perspective, that the shape of an object should be based upon its purpose. This is a faulty breakup of the feature we are trying to build, since we are going to make the purpose - storing the data in a database and then transfer it to a screen - take precedence over the function, searching contact details.
It makes more sense tobreak up the screen in functional components as shown below:

Then we could break the feature up as follows:

Display Search Results
Enter Search Criteria
Display status message "x out of Y contacts"

This will require developers to shift there mind from "Horizontal thinking" - thinking in terms of technical layers, to vertical thinking - what I often refer to as "Slicing the Cake". This enables you to incremental delivery of features and get earlier feedback.
The most important thing is the green grid displaying the search results. From a technical perspective this seems a bit weird, since we autmatically think that its not usable once we have hundreds of contacts. But this mindset is wrong, it is workable, whether its practical that is another thing.
If we would take this approach we could deliver the following screen to the Product Owner:

If he can get his hands on this he can allready take a look and maybe he could allready experience this bit of functionality and conclude he would like to add some fields to the grid like email and phone, that he did not think of immediately.
So an extra task is added to the story "Add email and phone fields to the grid"
In the meanwhile wile the product owner is allready playing around with the screen we can allready add the yellow part to the screen:

This will enable very short continuous feedback loops, moreover working like this will help you deliver functionality sprint after sprint.
This is what the end result could look like

As you see apparently there was no more time for the status message at the bottom of the screen and this task has been removed from the story another change from the initial version is also the "Search" button.
Find here an overview of what was implemented and what was removed:
As an office manager I would like to lookup contacts quickly so that I can quickly find someone's contact details.

Display search results: Done

Enter Search Criteria: Done

Display status message "x out y contacts": removed

Add phone and email fields to the grid: Done

Filter results grid when typing text: Done

Remove search button: Done

There is one caveat with this approach, business user tend to like alot to add stuff, but they really dislike removing stuff… But this is where the timebox principle kicks in, if for instance there would be no more time left than the 2 last tasks (tasks 5 and 6) than the Product Owner might still choose to accept the story as done and the Functionality could potentially be shipped.

Scrum.org PSM II Certification

2011-09-30T15:29:00.000+02:00

I reached a major milestone and obtained my Professional Scrum Master Certification II last week. A put alot of effort in it and it paid of.

Something on Continuous Integration

2011-06-20T19:51:00.001+02:00

In the past I have been experiencing some weird practices concerning CI. In the following article I will outline some do's and don'ts when implementing continuous integration.

First and foremost it is ok to break a build that is why the thing is there you know. Comparing the number of broken builds against the ones that don't break is not a good measure of quality instead measure the time to fix the build.

Do Integrate static code analysis in your build like FxCop, Ndepend and Simian. Giving you early feedback on your code quality. If the tools give you warnings solve them as well. If you keep up on regular basis this will keep your code base clean.

Do Integrate your Unit tests to run every build. Again providing early feedback on integration issues.

Do provide visual feedback (Andon) that give people an immediate feedback when a build fails.

Don't force developers to do a get latest, run all their unit tests and then check in. This is a waste of time. But when a build fails fix it!

Don't seek who broke the build. Something that is very common is that people are very eager to investigate who broke the build and pointing fingers. Instead look what broke the build try to fix it, this will enhance collective code ownership.

Don't check in, close your laptop and sprint out of the office. This practice kills team morale.

Determine Iteration Length

2011-06-14T20:07:00.002+02:00

Something I come across quite often is that teams don't consciously determine the iteration length of their sprints. They usually take 2 weeks as some default length. This is not really the way to go… Lets see what criteria we can put forward to fine tune the iteration length.
Here are the 3 major factors to consider:

Project Duration
End-User commitment (how available are they to provide feedback and input)
Maturity of the team

The shorter the project the shorter the sprints enabling to have more feedback cycles, minimizing the risk building the wrong thing. This however will require a significant amount of commitment of the stakeholders (weekly review meetings, availability to clarify and develop the product backlog with the Product Owner,...). Short sprints also have one big advantage they are more prone to fail… The reason why I see this as an advantage is that problems will surface more quickly, enabling your team to address them and thus further minimizing risk.
The second factor is also quite important: are there end-users available to provide feedback and are they easily accessible? One thing to keep in mind is that people are not used to the fact they will have to be available for a project throughout its duration. In the past they participate in workshops in the beginning of a project and in acceptance testing testing near the end (oh sweet memories :))
Finally you should consider how mature your team is. This means how experienced are they with agile practices such as Test Driven Development, Continuous integration, Test Automation, Collective Code Ownership (instead of finding out who broke the build, investigate and fix what broke the build), being cross technical (no specialist like the database guy, the UI guy, etc.). This however does not mean there is no room for specialists and that everybody has to be a generalist but everyone chips in where needed. A big obstacle are teams that divide work parallel with the layers instead of what i call "slicing the cake", this means implementing a feature from front to back, this will enable them to incremently deliver software.

For more information see: Agile Estimation and Planning from Mike Cohn

EF CTP5 And Unit Testing

2011-03-01T20:12:00.007+01:00

Using Entity Framework Code First CTP5 its quite easy to write and unit test your repositories. However test should still be written against the mappings of the actual database. It would be best to split the tests that write to the database from the tests that read into a different class

Just Create a class that inherits from DropCreateDatabaseAlways<T> override the seed method to create insert the values you want.

   1: public class DBContextInitializer : DropCreateDatabaseAlways<EntityContext>   2: {   3:     protected override void Seed(EntityContext context)   4:     {   5:         ProductDummies.GetAllProducts().ForEach(p => context.Set<Product>().Add(p));   6:         context.Commit();   7:     }   8: }

And then put in your Unit Test Assembly the following method:

   1: [ClassInitialize]   2: public static void ClassInitialize(TestContext context) {   3:     DbDatabase.SetInitializer(new DBContextInitializer());   4: }

If you then use an in memory database it will be fast. The best way to always start from a known state (and to avoid mstest concurrency problems is to put the following code in Your TestInitialize method:

   1: [TestInitialize]   2: public void TestInitialize()   3: {   4:     string key = Guid.NewGuid().ToString();   5:     TestContext.Properties.Add(DB_NAME_KEY, key);   6:     repository = new Repository<Product>(key);   7: }

To delete put the following snippet in your TestCleanUp

   1: [TestCleanup]   2: public void TestCleanUp()   3: {   4:     repository.Dispose();   5:     DbDatabase.Delete(TestContext.Properties[DB_NAME_KEY].ToString);   6: }

Unit Testing ROI

2011-02-17T22:45:00.000+01:00

In my experience everybody knows for sure unit testing is a good thing. But then again it puzzles me why nobody is actually doing it... I think one of the biggest misconceptions is that everyone thinks that unit testing pays back over time or in the long run. This is not true! There is a more immediate payback on your investment that pays off from the very first line of code! The returns on Unit Testing grow exponentially over time...

All projects go relatively smooth the first few months until they reach a certain point where the skeletons start falling out of the closet... Regression bugs start to appear at an alarming rate, it takes longer to detect errors, more time is spent in the debugger than actually writing code, it gets harder to add new functionality,etc,...

Unit testing will:

Reduce the time spent in the debugger
Reduce time to test your code as a developer
Enables you to refactor

Reduce the time spent in the debugger

if you consistently write (good) unit tests you will be focusing on smaller portions of your code and thus preventing you to have to step through your whole application. When running all your unit tests you will automatically see when you break existing functionality, like this you will hunt down the likely cause a lot quicker (probably it was that last bit of code you changed).

Reduce time to test your code as a developer

When you unit test your code those little forms with one "test" button will be of the past. An other thing which will save you tremendous amounts of time is that it is no longer needed to step through a series of screens before you actually get to the functionality you want to test.

Enabling refactoring

If you have unit tests you can refactor those methods and classes that grow an keep growing... Everybody knows these little black holes in any application that are a pain to modify and every team member is reluctant to make modifications out of fear to break something else.

NDepend Enables you to quickly identify where problems will start arising. Find below some useful queries.

Types that are to big and need to be slimmed down

WARN IF Count > 0 IN SELECT TYPES WHERE
   NbLinesOfCode > 500 OR
   NbILInstructions > 3000
   ORDER BY NbLinesOfCode DESC

for more information: http://www.ndepend.com/Metrics.aspx#NbLinesOfCode

Methods that are to big or to complex

WARN IF Count > 0 IN SELECT METHODS WHERE
ILCyclomaticComplexity > 40 AND
ILNestingDepth > 4

OR NbLinesOfCode > 50 //Can even be smaller
ORDER BY ILCyclomaticComplexity DESC

for more information: http://www.ndepend.com/Metrics.aspx#ILCC

C# 4.0 Code Contracts:

2011-02-03T23:19:00.000+01:00

I was trying out the code contracts in C# 4.0 and came across something quite surprising every time I ran my unit tests I got an annoying message box popping up “Assert Failure”, Description must use the rewriter when using Contract.Requires<TException>.

After some googling around I found that in Project Properties you need to find the code contracts tab and set “Perform Runtime Contract Checking” to full.

I opened my project properties I realized I did not have the Code Contracts tab… So in order to enable this tab you will need to install Code Contracts from DevLabs (here: http://msdn.microsoft.com/en-us/devlabs/dd491992.aspx).

Rebuild and he complained about the Assembly Mode Setting not being appropiate. After Changing it I could run my tests without having to click every time a testmethod came in the method that had the contract.

Problem solved!

Interface Contracts

One problem I came across is that when trying Interface contracts I had an assembly that ended in Contracts and apparently it does not work (Code Contracts will compile its contracts in a assembly named <assembly name>.Contracts.dll. I renamed the assembly to IContracts and everything worked as expected

Lean Principle: Eliminate Waste (Muda)

2011-01-19T23:21:00.003+01:00

In The Toyota Production System Taiichi Ohno says that capacity = work + waste. And that one should strive for absolute elimination of waste. When you are thinking about the absolute elimination of waste one should always keep the following 2 points in mind:
1. Improving efficiency makes sense only when it is tied to cost reduction. To achieve this, we have to start producing only the things we need using minimum manpower.
2. Look at the efficiency of each operator and of each line. Then look at the operators as a group, and then at the efficiency of the entire plant. Efficiency must be improved at each step and, at the same time, for the plant as a whole.

The efficiency can be quantified in the following fashion: efficiency = work / cycle time.

At Toyota they identified the 7 following types of waste:

Overproduction
Unnecessary transportation
Inventory
Motion
Defects
Over-processing
Waiting

Now in order to eliminate waste we first need to identify waste. It is my experience that there are some recurring problems when in comes to developing software. When looking for waste we need to look at it at 3 different levels. In software developed we can look at it from a Team Member’s perspective, Team and process.

Overproduction

Overproduction happens each time you engage more resources than needed to deliver to your customer. For instance, large batch production, because of long change over time, exceeds the strict quantity ordered by the customer. For productivity improvement, operators are not required to produce more than the customer needs. Extra parts will be stored and not sold. Overproduction is the worst muda because it hides or generates all others, especially inventory.^{[citation needed]} Overproduction increases the amount of space needed for storing raw material as well as finished goods. It also requires a preservation system.

In software production overproduction can be seen as developing features that are never going to be used. At XP2002 Jim Johnson of the Standish Group reported that a study on the functionality in software. The graph below clearly shows that 64% of the functionalities build is barely used! In the past I had a lot of discussions with my colleagues about this… If a customer asks something its not necessarily mean that he actually needs it.

“If I had asked people what they wanted, they would have said faster horses”

Henry Ford

One way to avoid this is to release as early and as often as possible. This enables immediate feedback from the actual end users. Overproduction is quite frequent in when the QA department is not a part of the team. Since in most companies the QA department usually has more work than it can cope with people try to produce large batches to send to them only adding to their workload hiding possible defects. In the past I worked closely with a development team to enable them to release multiple versions a day to the test environment. This immensely improved the quality.

Something that pays of (with interest) is to invest in your deployment strategy and not wait until the very last moment. I have seen it to many times that this is neglected and every time a new environment needs to be deployed it takes a lot of manual manipulations of various configuration settings making deployment a very erroneous activity. To counter this people would only release large batches of bug fixes and features. This obfuscates a lot of problems like a bug that works on a developers machine but not on an other environment. In the worst case these problems only show up when deploying to the production environment -since in most companies this is done by different people who are not aware of configuration changes for example – causing downtime.

Unnecessary transportation

Each time a product is moved it stands the risk of being damaged, lost, delayed, etc. as well as being a cost for no added value. Transportation does not make any transformation to the product that the consumer is supposed to pay for.

In software development the product is not only the piece of software we have written but more so the knowledge required to operate and write the software.

According to Poppendieck transportation are handoffs of knowledge . When transferring knowledge from one person to another the most effective way of doing this is by face to face communication. far less effective – in declining order – are phone calls, emails and documentation. Examples of this are requirements documents, bug reports. This however does not mean it is a waste to write them, it means you have to keep them as lean as possible and facilitate communication between the people that have the knowledge.

Even with face to face communication a lot of knowledge is lost. To quote Freud: “The things that go without saying are usually left unsaid…”. This can easily be perceived with playing a game somebody says a sentence to the person left of him who in his turn tells it to the person to his left and so on. Could be done in the form of “I am going on holiday and I take the following things with me:” and everyone adds one item to the sentence and the next person has to repeat the whole list, if he makes a mistake he can no longer participate in the game. See how long the list is before every one made a mistake, than compare it to your requirements documents.

Other sources of waste can be branching (if its to complicated) since it also requires transportation. If you have to many branches the knowledge is lost every time you have to transport it from one branch to another. Integrate your code early and often! It is a lot better to merge your changes on a daily basis than on a 2 weekly basis!

Inventory

Inventory, be it in the form of raw materials, work-in-progress (WIP), or finished goods, represents a capital outlay that has not yet produced an income either by the producer or for the consumer. Any of these three items not being actively processed to add value is waste.

Take for example a developer sends of some code to the deployment team who has the responsibility to deploy to the test environment than from the developer’s perspective the work is done. Then its somewhere in the queue of the deployment team waiting to get in the queue of the test team, building up inventory. Then when the testing team finally got round to testing it they discover some bugs and the functionality needs to be reworked. This largely depends on the teams definition of done. If an impaired Definition is used a team will never reach an hyper productive state. This is usually reflected in Acceptance testing cycles only just before each release (encompassing several iterations).

To avoid inventory to build up remove impediments and allot some time to “Groom” the backlog (e.g. Remove items from the backlog that are older than 16 weeks). This is a very hard concept for people to understand but don’t build up inventories. If a backlog is consistently prioritized the items older than a certain period nobody will probably remember them after one year anyhow.

Motion

As compared to Transportation, Motion refers to the producer, worker or equipment. This has significance to damage, wear and safety. It also includes the fixed assets and expenses incurred in the production.

This can be taken quite literally. One of the biggest tips I can give you is sit the Team together! This facilitates osmotic communication, the added value of removing physical distance is immense even with distances more than 2 meters. If somebody has to turn or get up from his desk to ask a team member a question he will not do it.

Osmotic communication means that information flows into the background hearing of members of the team, so that they pick up relevant information as though by osmosis. This is normally accomplished by seating them in the same room. Then, when one person asks a question, others in the room can either tune in or tune out, contributing to the discussion or continuing with their work

Cockburn 2004

A lot of teams underestimate the impact of context switching. The productivity of someone declines rapidly if he or she are combining multiple tasks. As the graph shows below multi tasking kills productivity. When someone is working on a single project his productivity is around 70% the remaining 30% is absorbed by something Mike Cohn good citizenship (socializing with colleagues, administrative duties, reading mails, …). This is in line with what Henrik Kniberg calls “Focus Factor”.

Source: Steven C.Wheelwright and Kim B.Clark (1993), Revolutionizing Product Development: Quantum Leaps in Speed, Efficiency and Quality

Defects

Whenever defects occur, extra costs are incurred reworking the part, rescheduling production, etc.

When defects appear these need to be detected and resolved as quickly as possible. Find below a table of a the relative cost associated with the stage a defect is detected:

Requirements development (Vision)	1x
Design (Writing the User Story)	2-3x
Construction (Development)	5-10x
System Or Acceptance Testing	8-20x
Production	68-110x

	Boehm 1981; Grady 1999

Usually the primary goal of testing is to discover errors, but teams should strive to do testing to prevent errors. This is what XP, TDD and BDD propagate, all code flows from a test. Once you are a TDD adept like me there is no other way you want to write code. It is usually very hard to convince people about the added value of writing test code (they see it as wasted effort). Invest in automated test frameworks and/or tools.

A great tool to signal an abnormality is some kind of “Andon” a visual indication that something is wrong visible to the whole team. If a build fails the first thing anyone who notices this should Stop what he is doing Fix the issue and investigate the root cause of the failure. And not look who checked in the last bit of code and points his finger in the direction of whoever caused the failure. Continuous Integration asks for a fair bit of discipline but is worth its weight in gold.

The purpose of continuous integration is not have a 100% success rate, studies have shown that the sweet spot is around 67% success rate to maximize productivity (according to Jeff Sutherland). Examples of Andon’s are for example CC tray, Team Build Notification, small tools running on an unused piece of hardware that is visible to everyone, lava lamps, traffic lights,… less obvious examples are Scrum/Kanban Boards.

If an abnormality is detected it should be fixed immediately otherwise the broken windows syndrome will kick in. This means that the defective state will be considered as a normal state.

Consider a building with a few broken windows. If the windows are not repaired, the tendency is for vandals to break a few more windows. Eventually, they may even break into the building, and if it's unoccupied, perhaps become squatters or light fires inside.

Or consider a sidewalk. Some litter accumulates. Soon, more litter accumulates. Eventually, people even start leaving bags of trash from take-out restaurants there or breaking into cars.

Broken windows: James Q. Wilson and George L. Kelling (1982)

Over-processing

Over-processing occurs any time more work is done on a piece than what is required by the customer. This also includes using tools that are more precise, complex, or expensive than absolutely required.

Spending more time on something does not necessarily augment the quality nor does it add value. Do just enough. Developers have a tendency to over engineer solutions – also known as gold plating. In my experience most often too much time is often spend on premature performance optimizations, trying to solve concurrency resulting in complex multithreading code that quite quickly become complex and buggy choking points in an application. I frequently encounter developers that suffer from the not invented here syndrome, writing their own data access logic, logging, user controls… These things have been done over and over again by people before them but they stubbornly believe they will do it better than the legions of developers before them.

Writing code that can become useful in “future”. One thing they forget is that if you make this consistent behavior their might not be a future for your project. I always try to keep de following sentence in mind “Simple is already complicated enough”, or to quote Einstein “Make things as simple as possible, but not simpler…”.

Successfully delivering software projects are not achieved by writing code that is really cool to write but by just restricting yourself to the bare minimum to turn a requirement into a working bit of software. In the passed I was writing a kind of address book application that had to synchronize data from the ERP system to active directory. After struggling a few hours trying to write a windows service that had to run on regular intervals, I wound up writing a console application that I scheduled in the windows task scheduler.

Another thing that falls under this category is writing unnecessary code. Whether you have been writing this code or the code is generated by a tool (Code generators, Snippets, T4 templates etc, etc,…) is all the same. If you have repetitive patterns in your code try to look at design patterns, object oriented principles whatever and refactor them out. Every line of code that gets into your code base is a line of code you drag along for the rest of the life of the product.

Waiting

Whenever goods are not in transport or being processed, they are waiting. In traditional processes, a large part of an individual product's life is spent waiting to be worked

Waiting is an obvious waste, although an obvious one a very common source of waste and they reside very stubbornly in an organization or process. I can not count the times I heard there is nothing we can do about that, it always was this way. Although upon prying to the root cause no good reasons can be given to sustain these impediments. Often very strong indicators of suboptimal communication path ways by sending mails, filling out forms… Waiting occurs a lot in teams that do not successfully self organize or are not cross functional. Bottlenecks are often enforced by formal approval procedures, the lack of mandate by a team, lack of access to the QA department that has to perform Acceptance testing. These impediments can however be easily overcome by a simple value stream map which will quickly show bottlenecks in the process.

References

Agile estimation And planning by Mike Cohn
Lean Software Development: From Concept To Cash by Mary and Tom Poppendieck
The Toyota Production System by Taiichi Ohno
Wikipedia

Lean Principle “See the whole”

2011-01-13T22:54:00.000+01:00

The remaining work report showed a clear buildup in items that were “Ready to Test” indicating a bottleneck somewhere in the process. I was wondering what was going on… I was under the assumption that the tester did not have any time to test these items (he had some work with existing customers who had to generate some kind of annual reports, so I was waiting for this surge to end). But after asking the tester what was going on he was quite surprised and responded that he only had 12 items that were ready to test instead of the more than 40 shown in the report. After some asking around the root cause of the problem was that the development team did not release a version to the test environment yet so the tester was not able to test the other items.

This example clearly shows that the reporting help you in making bottlenecks visible. However they don’t show you exactly what the root cause is. You always have to keep in mind to See the Whole.

Product Backlog Pareto

2011-01-10T23:48:00.000+01:00

Pareto analysis on Product Backlog Items and Bugs

This report helps you analyze the “health” of your backlog for more information:Implementing Lean Software Development: From Concept to Cash (page 170).

Average Cycle Time of Workitems

2010-12-27T23:39:00.004+01:00

Find below a query that shows the average Cycle Time per state, you can store the results in a temporary table and join it to provide averages to help in value stream mapping.

Cycle Time Per Sprint

The bulk of the work is done by the query below

   1:  WITH cteStateChange(rowId, tpId, wiId, [State], PrevState, UpdTime) AS(

   2:      SELECT Row_Number() OVER(Order by wi.TeamProjectSK, wi.System_id, wi.System_Rev)

   3:          , wi.TeamProjectSK

   4:          , wi.System_Id

   5:          , wi.System_State

   6:          , wi.PreviousState

   7:          , wi.System_ChangedDate

   8:      FROM dbo.DimWorkItem wi

   9:      INNER JOIN dbo.FactWorkItemHistory wih

  10:          ON wih.WorkItemSK = wi.WorkItemSK

  11:          AND wih.TeamProjectSK = wi.TeamProjectSK

  12:      WHERE 1=1

  13:      AND (wih.StateChangeCount = 1)

  14:  )

Visualize your workflow with Team Foundation Server

2010-12-22T22:52:00.001+01:00

I created a custom report for Team Foundation Sever 2010 to visualize your workflow in order to identify bottlenecks

Identify bottle necks

This indicates a bottleneck in testing there is work stacking up for the QA department.

This report will tell you at a glance where to take action.

Inspect Flow

As you see in the picture above no clear “steps” for committed are noticeable in the above chart. The chart below shows a more healthy example.

You also notice that there is an inventory of untested items building up.

Keep Assembly version same as build number

2010-11-30T21:34:00.003+01:00

I have been struggling all afernoon with Team Foundation Server 2010 Custom Activities to keep the BuildNumber and the AssemblyVersions in Sync.
Apperantly System.Version is not serializable so the value gets lost when going into the Run On Agent Sequence.
As a startiong point I used the code of Ewald Hoffman. Original Article: http://www.ewaldhofman.nl/post/2010/04/20/Customize-Team-Build-2010-e28093-Part-1-Introduction.aspx
Step 1: Create the Version Generator (+ offcource the necessary unit tests )…

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

5:

   6:  namespace SharpSolutions.Tfs.Build.BuildTasks

   7:  {

   8:      public sealed class AssemblyVersionGenerator: IAssemblyVersionGenerator

   9:      {

  10:          /// <summary>

  11:          /// Generatas a new Assembly version

  12:          /// int the following format: Major.Minor.Build.Revision

  13:          /// Major: same as current version

  14:          /// Minor: same as current version

  15:          /// Build: 2 digit year since 2000* 1000 + day of year eg 10001 = Build run on 1 jan 2010

  16:          /// Revision: seconds since midnight

  17:          /// </summary>

  18:          /// <param name="currentVersion">used to retrieve current major and minor version</param>

  19:          /// <returns>A new Assembly version</returns>

  20:          public Version Generate(Version currentVersion)

  21:          {

  22:              //If we did not force now use the real now

  23:              //O_o get it?

  24:              DateTime now = ((IAssemblyVersionGenerator)this).Now == default(DateTime)? DateTime.Now: ((IAssemblyVersionGenerator)this).Now;

  25:              int major = currentVersion.Major;

  26:              int minor = currentVersion.Minor;

  27:              int build = (now.Year % 2000) * 1000 + now.DayOfYear;

  28:              int revision = (int)(now - new DateTime(now.Year, now.Month, now.Day, 0, 0, 0)).TotalSeconds / 10;

29:

  30:              return new Version(major, minor, build, revision);

  31:          }

32:

  33:          DateTime IAssemblyVersionGenerator.Now { get; set; }

  34:      }

  35:  }

2. Create a new Code Activity. Offcourse you can easily implement your own version of IAssemblyVersionGenerator

   1:  using System;

   2:  using System.Activities;

   3:  using Microsoft.TeamFoundation.Build.Client;

   4:  using Microsoft.TeamFoundation.Build.Workflow.Activities;

5:

   6:  namespace SharpSolutions.Tfs.Build.BuildTasks.Activities

   7:  {

   8:      [BuildActivity(HostEnvironmentOption.Controller)]

   9:      public sealed class GenerateAssemblyNumber : CodeActivity<string>

  10:      {

  11:          private IAssemblyVersionGenerator versionGenerator = new AssemblyVersionGenerator();

12:

  13:          [RequiredArgument]

  14:          public InArgument<string> AssemblyInfoFileMask { get; set; }

15:

  16:          [RequiredArgument]

  17:          public InArgument<string> Version { get; set; }

18:

  19:          [RequiredArgument]

  20:          public InArgument<IBuildDetail> BuildDetail { get; set; }

21:

  22:          protected override string Execute(CodeActivityContext context)

  23:          {

  24:              string assemblyInfoFileMask = context.GetValue(this.AssemblyInfoFileMask);

  25:              string version = context.GetValue(this.Version);

26:

  27:              Version currentVersion = new Version(version);

  28:              Version newVersion = versionGenerator.Generate(currentVersion);

  29:              context.TrackBuildMessage(string.Format("New Version is {0}", newVersion.ToString()));

30:

  31:              return newVersion.ToString();

  32:          }

  33:      }

  34:  }

Step 3: Update the version number in the AssemblyInfo.cs

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using System.Activities;

   6:  using System.Text.RegularExpressions;

   7:  using System.IO;

   8:  using Microsoft.TeamFoundation.Build.Client

   9:  using Microsoft.TeamFoundation.Build.Workflow.Activities;

10:

  11:  namespace SharpSolutions.Tfs.Build.BuildTasks.Activities

  12:  {

  13:      [BuildActivity(HostEnvironmentOption.Agent)]

  14:      public sealed class UpdateAssemblyVersion : CodeActivity

  15:      {

  16:          [RequiredArgument]

  17:          public InArgument<string> VersionNumber { get; set; }

18:

  19:          [RequiredArgument]

  20:          public InArgument<string> AssemblyInfoFileMask { get; set; }

21:

  22:          [RequiredArgument]

  23:          public InArgument<string> SourcesDirectory { get; set; }

24:

  25:          // If your activity returns a value, derive from CodeActivity<TResult>

  26:          // and return the value from the Execute method.

  27:          protected override void Execute(CodeActivityContext context)

  28:          {

  29:              // Obtain the runtime value of the input arguments

  30:              string sourcesDirectory = context.GetValue(this.SourcesDirectory);

  31:              string assemblyInfoFileMask = context.GetValue(this.AssemblyInfoFileMask);

  32:              Version newVersion = new Version(context.GetValue(this.VersionNumber));

33:

  34:              // Get all AssemblyInfo files

  35:              foreach (string file in Directory.EnumerateFiles(sourcesDirectory, assemblyInfoFileMask, SearchOption.AllDirectories))

  36:              {

  37:                  // Read the text from the AssemblyInfo file

  38:                  string assemblyInfoVersionText = File.ReadAllText(file);

39:

  40:                  string updatedContents = Utilities.UpdateAssemblyVersion(assemblyInfoVersionText, newVersion);

41:

  42:                  File.WriteAllText(file, updatedContents);

  43:              }

  44:          }

45:

  46:      }

  47:  }

Formatting Source code for BLOG

2010-11-29T11:49:00.001+01:00

Reminder to myself since I always have to search for it over and over: http://www.manoli.net/csharpformat/format.aspx

5S for .NET

2010-11-29T11:24:00.001+01:00

I just finished Implementing lean software development: From Concept to Cash. In chapter 8: Quality (page 192) We find the 5S’s for Java find below my interpretation for .NET.

Sort (Seiri): Reduce the size of the code base. Throw away everything that is not needed. Remove:

Dead Code
Unused using statements
Unused references
Unused variables
Unused Methods
Unused Classes
Refactor redundant/duplicate code
Delete code in comments
Delete or fix Ignored Unit Tests

Systematize (Seiton): Organize projects and packages. Have a place for everything and everything in its place

Resolve package dependency cycles
Minimize dependencies

Shine (Seiso): Clean up. Problems are more visible when everything is neat and clean.

Resolve unit test failures (Pass rate should be 100%)
Improve unit test coverage (> 80%)
Improve Unit test performance
Check duration to run all tests
Resolve compiler warnings
Resolve TODO’s
Resolve FxCop Warnings
Refactor methods that are too long
Refactor methods where Cyclomatic Complexity > 10

Standardize (Seiketsu): Once you get a clean slate, keep it that way. Reduce complexity over time to improve ease of maintenance.
Sustain (Shitsuke): Use and follow standard procedures

Integrate FxCop in daily build
Fail Continuous integration build on unit test failure (Gated Check ins)

These criteria can easily be found using ndepend which is word its price in gold

Team Foundation Server 2010 MDX to exclude the weekends

2010-11-24T19:41:00.001+01:00

WITH 
	SET [WeekDays]
	AS Filter(
			[Date].[Date].[Date]
			, COUNT(WTD([Date].[Year - Week - Date Hierarchy])) <> 1
			AND COUNT(WTD([Date].[Year - Week - Date Hierarchy])) <> 7
		)

	SET [DateRangeFrom]
	AS FILTER([WeekDays]
				, [WeekDays].CurrentMember.Member_Value >= CDATE("11/17/2010")
				)

SELECT {
	[Measures].[Work Item Count],[Measures].[Revision Count]
	
}
ON COLUMNS,{
	[DateRangeFrom]
//	[Date].[Date].[Date]
//	, WTD([Date].[Year - Week - Date Hierarchy].CurrentMember)
//	
}

ON ROWS
FROM [Team System]

TDD Example Write function that calcutates a Fibonacci number

2010-08-10T22:56:00.000+02:00

Step 1:

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:     Func<int, int> fib = null;

4:

   5:     Assert.AreEqual(0, fib(0));

   6:  }

Step 2:

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:     Func<int, int> fib = (n) => { return n; };

4:

   5:     Assert.AreEqual(0, fib(0));

   6:  }

Wee first test case passed!
Step 3: Adding another testcase

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = (n) => { return n; };

4:

5:

   6:      Assert.AreEqual(0, fib(0));

   7:      Assert.AreEqual(1, fib(1));

   8:  }

Works again
Step 4: Removing duplication in the asserts

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = (n) => { return n; };

4:

   5:      Assert.AreEqual(0, fib(0));

   6:      Assert.AreEqual(1, fib(1));

   7:  }

Refactored gives:

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = (n) => {

   4:          return n;

   5:      };

6:

   7:      Dictionary<int, int> fibonacciSequence = new Dictionary<int, int>{

   8:                  {0 , 0},

   9:                  {1 , 1},

  10:              };

11:

  12:      foreach (KeyValuePair<int, int> row in fibonacciSequence)

  13:      {

  14:          Assert.AreEqual(row.Value, fib(row.Key));

  15:      }

  16:  }

Step 5: Adding another testcase

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = (n) => {

   4:          return n;

   5:      };

6:

   7:      Dictionary<int, int> fibonacciSequence = new Dictionary<int, int>{

   8:                  {0 , 0},

   9:                  {1 , 1},

  10:                  {2 , 1},

  11:              };

12:

  13:      foreach (KeyValuePair<int, int> row in fibonacciSequence)

  14:      {

  15:          Assert.AreEqual(row.Value, fib(row.Key));

  16:      }

  17:  }

Woops test failed!
Ok lets fix it:

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = (n) => {

   4:          if (n < 2) return n;

   5:          return 1;

   6:      };

7:

   8:      Dictionary<int, int> fibonacciSequence = new Dictionary<int, int>{

   9:                  {0 , 0},

  10:                  {1 , 1},

  11:                  {2 , 1},

  12:              };

13:

  14:      foreach (KeyValuePair<int, int> row in fibonacciSequence)

  15:      {

  16:          Assert.AreEqual(row.Value, fib(row.Key));

  17:      }

  18:  }

Test Fixed!
Step 6: Adding another test case and taking 2 steps at the time since 1 will never equal 2 but 1 = 2-1 and 2 = 3-1 and thus return n-1 will do the trick for now

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = (n) => {

   4:          if (n < 2) return n;

   5:          return n - 1;

   6:      };

7:

   8:      Dictionary<int, int> fibonacciSequence = new Dictionary<int, int>{

   9:                  {0 , 0},

  10:                  {1 , 1},

  11:                  {2 , 1},

  12:                  {3 , 2}

  13:              };

14:

  15:      foreach (KeyValuePair<int, int> row in fibonacciSequence)

  16:      {

  17:          Assert.AreEqual(row.Value, fib(row.Key));

  18:      }

  19:  }

Step 7: adding 2 more test cases (since the next we add will work fine too :))

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = (n) => {

   4:          if (n < 2) return n;

   5:          return n - 1;

   6:      };

7:

   8:      Dictionary<int, int> fibonacciSequence = new Dictionary<int, int>{

   9:                  {0 , 0},

  10:                  {1 , 1},

  11:                  {2 , 1},

  12:                  {3 , 2},

  13:                  {4 , 3},

  14:                  {5 , 5}

  15:              };

16:

  17:      foreach (KeyValuePair<int, int> row in fibonacciSequence)

  18:      {

  19:          Assert.AreEqual(row.Value, fib(row.Key));

  20:      }

  21:  }

Test Fails again (the test case marked in red)
The solution (fast forwarded):
Because 5 = 2 + 3
From the testcases we can see that fib(3) = 2 and fib(4)=3
And thus 5 = fib(3) + fib(4)
3 = 5 - 2 and 4 = 5 - 1
5 = n and this 5 = fib(n-2) + fib(n-1)

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = (n) => {

   4:          if (n < 2) return n;

   5:          return fib(n - 1) + fib(n - 2);

   6:      };

7:

   8:      Dictionary<int, int> fibonacciSequence = new Dictionary<int, int>{

   9:                  {0 , 0},

  10:                  {1 , 1},

  11:                  {2 , 1},

  12:                  {3 , 2},

  13:                  {4 , 3},

  14:                  {5 , 5}

  15:              };

16:

  17:      foreach (KeyValuePair<int, int> row in fibonacciSequence)

  18:      {

  19:          Assert.AreEqual(row.Value, fib(row.Key));

  20:      }

  21:  }

Does not compile :( Error: use of unsigned variable
The fix:

   1:  [TestMethod]

   2:  public void FibonacciSequanceTest(){

   3:      Func<int, int> fib = null;

   4:          fib = (n) => {

   5:          if (n < 2) return n;

   6:          return fib(n - 2) + fib(n - 1);

   7:      };

8:

   9:      Dictionary<int, int> fibonacciSequence = new Dictionary<int, int>{

  10:                  {0 , 0},

  11:                  {1 , 1},

  12:                  {2 , 1},

  13:                  {3 , 2},

  14:                  {4 , 3},

  15:                  {5 , 5}

  16:              };

17:

  18:      foreach (KeyValuePair<int, int> row in fibonacciSequence)

  19:      {

  20:          Assert.AreEqual(row.Value, fib(row.Key));

  21:      }

  22:  }

Et voila done!

Software Estimation

2010-04-02T11:27:00.005+02:00

McConnell suggests in "Rapid Development: Taming Wild Software Schedules" that on large projecs the actual cost of coding and unit testing is 15% of the time spent.

So for a software estimation a good rule of thumb is
Analyse: 50%
Build: 15%
Test: 35%

Jack Reeves takes another perspective on this he says that source code is actually a design document and that the compiling and unit testing is the building (construction). So we can conclude that Construction of Software is actually very cheap and in software the design is the most costly activity in contrast with manufacturing and construction (engineering) where construction is the most expensive activity.

Source: Martin Fowler: http://martinfowler.com/articles/newMethodology.html

Error when running tests: Unable to load one or more of the requested types

2010-03-18T16:22:00.002+01:00

Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information..

1. Clean the solution
2. Close Visual studio
3. Delete all the bin en obj folders
4. Try again

Sharepoint configuration wizard fails after sysprep

2010-03-15T14:01:00.003+01:00

If you sysprep a machine on which you installed sharepoint and ran the configuration wizard and you try to run it again you get the following error (after you ran the sp_dopserver and sp_addserver stored procedures):

03/05/2010 17:16:12 8 ERR Exception: System.ArgumentNullException: Value cannot be null.
Parameter name: password
at Microsoft.SharePoint.Administration.SPProcessIdentity.Update()
at Microsoft.SharePoint.Administration.SPApplicationPool.Update()
at Microsoft.SharePoint.Administration.SPWebApplication.CreateDefaultInstance(SPWebService service, Guid id, String applicationPoolId, IdentityType identityType, String applicationPoolUsername, SecureString applicationPoolPassword, String iisServerComment, Boolean secureSocketsLayer, String iisHostHeader, Int32 iisPort, Boolean iisAllowAnonymous, DirectoryInfo iisRootDirectory, Uri defaultZoneUri, Boolean iisEnsureNTLM, Boolean createDatabase, String databaseServer, String databaseName, String databaseUsername, String databasePassword, SPSearchServiceInstance searchServiceInstance, Boolean isPaired, Boolean autoActivateFeatures)
at Microsoft.SharePoint.Administration.SPAdministrationWebApplication.CreateDefaultInstance(SqlConnectionStringBuilder administrationContentDatabase, SPWebService adminService, IdentityType identityType, String farmUser, SecureString farmPassword)
at Microsoft.SharePoint.Administration.SPFarm.CreateAdministrationWebService(SqlConnectionStringBuilder administrationContentDatabase, IdentityType identityType, String farmUser, SecureString farmPassword)
at Microsoft.SharePoint.Administration.SPFarm.CreateBasicServices(SqlConnectionStringBuilder administrationContentDatabase, IdentityType identityType, String farmUser, SecureString farmPassword)
at Microsoft.SharePoint.Administration.SPFarm.Create(SqlConnectionStringBuilder configurationDatabase, SqlConnectionStringBuilder administrationContentDatabase, IdentityType identityType, String farmUser, SecureString farmPassword)
at Microsoft.SharePoint.Administration.SPFarm.Create(SqlConnectionStringBuilder configurationDatabase, SqlConnectionStringBuilder administrationContentDatabase, String farmUser, SecureString farmPassword)
at Microsoft.SharePoint.PostSetupConfiguration.ConfigurationDatabaseTask.CreateOrConnectConfigDb()
at Microsoft.SharePoint.PostSetupConfiguration.ConfigurationDatabaseTask.Run()
at Microsoft.SharePoint.PostSetupConfiguration.TaskThread.ExecuteTask()

This is related to the fact that there are allready Application pools created. if you delete the earlier created applicaiton pools and websites you should be able to run the wizard without errors.

Ax Business Connector .NET Unable to log on to Microsoft Dynamics AX.

2010-03-11T14:49:00.006+01:00

LogonFailedException: Unable to log on to Microsoft Dynamics AX.

Method signature
public void LogonAs(
string user,
string domain,
NetworkCredential bcProxyCredentials,
string company,
string language,
string objectServer,
string configuration
);

When using the logon as method of the Business Connector .NET you face a lot off issues. After searching on the net I found that almost everyone forces the bcProxyCredentials but actually this not the way it is supposed to be used.

but here the MSDN documentation contains an error:

bcProxyCredentials
Credentials of the Business Connector Proxy user used to authenticate and enable the use of LogonAs.

You can create a NetworkCredential object with the following code:

System.Net.NetworkCredential creds = new System.Net.NetworkCredential(
ADUserName, ADUserPassword, ADDomain)The NetworkCredential parameters must match the Business Connector Proxy user set in the Business Connector Proxy dialog box: To verify your settings go to the Administration pane, click Setup, click Security, and then select BusinessConnectorProxy.

the part in bold is wrong. If you open the client application got the Administration pane > Security > System Service Accounts and there you can set the Business Connector Proxy accound and you can perform the LogonAs method to imperonate another user.

From the installation guide:

Some components require that the .NET Business Connector be configured to connect to Microsoft Dynamics AX with a proxy account. The use of a proxy enables the .NET Business Connector to connect on behalf of Microsoft Dynamics AX users when authenticating with an AOS instance.

Next you should be able to use the LogonAs method to logon as any valid Axapta user

Edit: if you want to use the user that is running the process as the proxy account pass null to the LogonAs method for the bcProxyCredentials parameter

Booting from a VHD

2010-03-05T12:13:00.003+01:00

With windows 7 and windows 2008 it is possible to boot from a hyper-v virtual disk

I usually set up an image with hyper-v and sysprep it then follow these steps to add it to your bootloader

C:\Windows\system32>bcdedit /copy {current} /d "JELLE-DEV"
The entry was successfully copied to {8208ac27-0bca-11df-8dbb-a0ef01535d7b}.

Copy the GUID that is

bcdedit /set {guid} device vhd=[locate]\image.vhd
bcdedit /set {guid} osdevice vhd=[locate]\image.vhd

Webcam access in Silverlight 4

2010-03-03T11:40:00.003+01:00

Code snippet to show webcam capture in silverlight 4


CaptureDeviceConfiguration.RequestDeviceAccess();
            CaptureSource _capture = new CaptureSource();
                        _capture.VideoCaptureDevice = CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice();
            _capture.Start();
            VideoBrush videoBrush = new VideoBrush();
            videoBrush.Stretch = Stretch.Uniform;
            videoBrush.SetSource(_capture);
            rectVideo.Fill = videoBrush;
            rectVideo.UpdateLayout();

Getting the output and resizing it to have a format of a picture that can be used in a profile


_capture.AsyncCaptureImage(img =>
    {
        _capture.Stop();
        TranslateTransform tt = new TranslateTransform();

        tt.Y = -73.5;
        tt.X = -125;
        WriteableBitmap bitmap = new WriteableBitmap(70, 93);

        bitmap.Render(rectVideo, tt);
        bitmap.Invalidate();
        frameImage.Source = bitmap;
        _capture.Start();
    });

MVP in asp .net / sharepoint

2010-02-26T16:50:00.001+01:00

The view interface


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

namespace SharpSoutions.MVP
{
    public interface IView
    {
         Model DataSource { get; set; }
         void DataBind();
         void UpdateModel();

         event EventHandler Saved;
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SharpSoutions.MVP.Domain;

namespace SharpSoutions.MVP
{
    [Serializable]
    public class Model
    {
        public Person NewPerson { get; set; }

        public Title[] Titles { get; set; }
    }
}

The presenter


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SharpSoutions.MVP.Domain;
using System.Diagnostics;

namespace SharpSoutions.MVP
{
    public class Presenter
    {
        private Data.IRepository<Title> titleRepository;
        private Data.IRepository<Person> personRepository;
        

        public Presenter(Data.IRepository<Title> titleRepository, Data.IRepository<Person> personRepository)
        {
            Trace.TraceInformation("Begin Presenter.Ctor");
            this.titleRepository = titleRepository;
            this.personRepository = personRepository;
            
            this.Model = new Model();
            this.Model.NewPerson = new Person();
            Trace.TraceInformation("End Presenter.Ctor");
        }

        public Model Model { get; set; }

        public IView View { get; set; }

        /// <summary>
        /// Init populates the "static" data
        /// These are the data that is shown in dropdown boxes etc
        /// </summary>
        /// <param name="mockView"></param>
        public void Init(IView view)
        {
            Trace.TraceInformation("Begin Presenter.Init");
            AttachView(view);
            this.View.DataSource = this.Model;
            
            this.Model.Titles = this.titleRepository.Query();

            this.View.DataBind();
            Trace.TraceInformation("End Presenter.Init");
        }

        public void AttachView(IView view) {
            this.View = view;
            this.View.Saved += new EventHandler(View_Saved);

        }

        void View_Saved(object sender, EventArgs e)
        {
            System.Diagnostics.Trace.TraceInformation("Begin Presenter.View_Saved");
            this.Save();
            System.Diagnostics.Trace.TraceInformation("End Presenter.View_Saved");
        }

        public void Save()
        {
            System.Diagnostics.Trace.TraceInformation("Begin Presenter.Save");
            this.View.UpdateModel();

            personRepository.Update(this.Model.NewPerson);
            System.Diagnostics.Trace.TraceInformation("End Presenter.Save");
        }
    }
}

The View implementation


using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using SharpSoutions.MVP.Domain;

namespace SharpSoutions.MVP.Web
{
    public partial class View : System.Web.UI.UserControl, IView
    {
        

        public Model DataSource{
            get {
                if (ViewState["d"] != null) {
                    return (Model)ViewState["d"];
                }

                return null;
            }

            set {
                ViewState["d"] = value;
            }
        }

        public override void DataBind()
        {
            System.Diagnostics.Trace.TraceInformation("Begin View.Databind");
            base.DataBind();

            TitleDropDown.DataSource = this.DataSource.Titles;
            if (this.DataSource.NewPerson.Title != null) {
                TitleDropDown.SelectedValue = this.DataSource.NewPerson.Title.Id.ToString();    
            }
                        
            TitleDropDown.DataTextField = "Name";
            TitleDropDown.DataValueField = "Id";
            TitleDropDown.DataBind();

            nameTextbox.Text = this.DataSource.NewPerson.Name;
            System.Diagnostics.Trace.TraceInformation("End View.Databind");
        }


        public void UpdateModel()
        {
            System.Diagnostics.Trace.TraceInformation("Begin View.UpdateModel");
            this.DataSource.NewPerson.Name = nameTextbox.Text;
            ListItem selectedTitle = TitleDropDown.SelectedItem;
            this.DataSource.NewPerson.Title = new Title { Id = int.Parse(selectedTitle.Value), Name = selectedTitle.Text };
            System.Diagnostics.Trace.TraceInformation("End View.UpdateModel");
        }

        public event EventHandler Committed;

        protected void SaveButton_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Trace.TraceInformation("Begin View.SaveButton_Click");
            
            if (this.Saved != null) {
                this.Saved(this, EventArgs.Empty);
            }
            System.Diagnostics.Trace.TraceInformation("End View.SaveButton_Click");
        }


        public event EventHandler Saved;
    }
}

Windows 7 RDP with blank password

2010-01-31T10:44:00.003+01:00

I have a windows 7 HTPC setup atr home that is not part of my domain (in orderr if it reboots it reboots all by its self and dont ask for a password or ALT+CTRL+DELETE

but I wanted to work on it with RDP. But when I connected I gotr the following error:
"Logon failure: user account restriction. Possible reasons are blank passwords not allowed, logon hour restrictions, or a policy restriction has been enforced.". Even

Solution:
run secpol.msc /s and then under Security Settings -> Local Policies -> Security Options set the Accounts: Limit local account use of blank passwords to console logon only to disabled

Developer Interview question samples

2010-01-19T11:39:00.003+01:00

FizzBuzz example.

A fizzbuzz is a small code sample/program that can be given to a developer to test his skills and knowledge about certain subjects


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

namespace ConsoleApplication1 {
    public class ClassA {
        public override string ToString() {
            return "Hello from class A";
        }
    }

    public class ClassB : ClassA {
        public override string ToString() {
            return "Hello from class B";
        }
    }

    public class ClassC : ClassB {
        public override string ToString() {
            return "Hello from class C";
        }
    }

    class Program {
        static void Main(string[] args) {
        
                        ClassA first = new ClassC();                        
                        ClassC second = new ClassC();            
                        ClassB third = (ClassB)second;            
                        ClassA fourth = (ClassA)third;            
                        object fifth = (object)fourth;            
                        
                        Console.WriteLine("1: " + first.ToString());           
                        Console.WriteLine("2: " + second.ToString());           
                        Console.WriteLine("3: " + third.ToString());          
                        Console.WriteLine("4: " + fourth.ToString());          
                        Console.WriteLine("5: " + fifth.ToString());            
                        Console.ReadLine();        
                }    
        

    }
}

Heading to 2010

2009-12-17T11:28:00.002+01:00

Soon we will be in 2010... and microsoft gave us some early new years presents...

Currently playing around with:

Team Foundation Server 2010
Visual Studio 2010
Sharepoint 2010
Office 2010

All looks quite neat and some really cool features have been implemented... Top 5 things i like...
- Linked workitems in TFS
- Improved reporting in TFS
- Support for TDD in VSTS
- Improved support for sharepoint development in VSTS
- BCS in sharepoint 2010

Is code coverage usefull for measuring software quality?

2009-09-11T17:19:00.002+02:00

There is a lot of debate going on how much percentage should be attained. But first however is code coverage a good measurement or quality? In my personal opinion it is very usefull if an historical trend is kept. if coverage drops over time this migt be an indicator of issues tha are arising somewhere else... not enough time, quick and dirty hacks,...

But how much is enough? this like almost everything in software development is offcourse it depends. I think it largely depends on the type of application you are building, if it is ver largely dependant on workflows and long running processes the significance is going to be less then when you are doing a lot of calculations. And offcourse code coverage does not cover 1 thing which is quite important and usually the root of all evil: missing requirements :)

Implementing INotifyPropertyChanged by using Unity Interception

2009-09-07T15:08:00.004+02:00

This example uses Unity interception to be able to bind objects to a UI by just applying a [Notify] attribute to a property, this done by intercepting the call and propagating it to a INotifyPropertyChanged implementation.
From MSDN:
The INotifyPropertyChanged interface is used to notify clients, typically binding clients, that a property value has changed.

Step 1 create an abstract class that encapsulates all the functionality we need.
See below for a class diagram:

Step 2 create the handler:
NotifyPropertyChangedHandler which inherits from ICallHandler
public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext) {

IMethodReturn result = getNext()(input, getNext);

if (!input.MethodBase.Name.StartsWith("set_")) return result;
//Remov the set_ to get the property's name
var propertyName = input.MethodBase.Name.Remove(0, 4);
//invoke the modified property
//maybe we should check if the target is indeed o BindableOjectBase ;)
BindableObjectBase target = (BindableObjectBase)input.Target;
((IBindableObject)target).Modified(propertyName);
return result;
}

Step 3: Create the attribute
Create a NotifyPropertyChangedAttribute class which inherits from HandlerAttribute
create a default constructor:
public NotifyPropertyChangedAttribute() {
_CallHandler = new NotifyPropertyChangedHandler();
}

override the folowing method
public override ICallHandler CreateHandler(IUnityContainer container) {
return _CallHandler;
}
Step 4: Setting up the UnityContainer:
UnityContainer_Container = new UnityContainer();
//Registring interception extension
_Container.AddNewExtension();
_Container.RegisterInstance(instance);
_Container.Configure().SetDefaultInterceptorFor(new TransparentProxyInterceptor());
var object container.Resolve();

the last step took a little time to get it working the way I wanted since DI usually works by injecting interface implementations but this was not what I wanted to do. Since interfaces define behaviour and properties have nothing to do with behaviour but with state.

I will post the full source code later

call javascript form a sharepoint cutom toolbar

2009-08-26T10:58:00.002+02:00

Here is a short code snippet which calls a javascript when you click a custom button in sharepoint. You should register the custom javascript through Page.ClientScript.

//Load the custom button
ToolBarButton printButton = (ToolBarButton)Page.LoadControl("~/_controltemplates/ToolBarButton.ascx");
printButton.ImageUrl = "~/layout/image/print.png";
//Here is where the magic happens
printButton.NavigateUrl = "javascript:PrintPage()";

ToolBar toolBar = (ToolBar)Page.LoadControl("~/_controltemplates/ToolBar.ascx");
toolBar.Buttons.Controls.Add(printButton);

Symptoms of Rotting Design

2009-08-21T11:09:00.007+02:00

There are four primary symptoms that tell us that our designs are rotting. They are not
orthogonal, but are related to each other in ways that will become obvious. they are:
rigidity, fragility, immobility, and viscosity.
Rigidity. Rigidity is the tendency for software to be difficult to change, even in simple ways. Every change causes a cascade of subsequent changes in dependent modules. What begins as a simple two day change to one module grows into a multiweek marathon of change in module after module as the engineers chase the thread of the change through the application.
When software behaves this way, managers fear to allow engineers to fix non-critical
problems. This reluctance derives from the fact that they don’t know, with any reliability, when the engineers will be finished. If the managers turn the engineers loose on such problems, they may disappear for long periods of time. The software design begins to take on some characteristics of a roach motel -- engineers check in, but they don’t check out.
When the manager’s fears become so acute that they refuse to allow changes to software, official rigidity sets in. Thus, what starts as a design deficiency, winds up being adverse management policy.
Fragility. Closely related to rigidity is fragility. Fragility is the tendency of the software to break in many places every time it is changed. Often the breakage occurs in areas that have no conceptual relationship with the area that was changed. Such errors fill the hearts of managers with foreboding. Every time they authorize a fix, they fear that the software will break in some unexpected way.
As the fragility becomes worse, the probability of breakage increases with time,
asymptotically approaching 1. Such software is impossible to maintain. Every fix
makes it worse, introducing more problems than are solved. Such software causes managers and customers to suspect that the developers have lost control of their software. Distrust reigns, and credibility is lost.
Immobility. Immobility is the inability to reuse software from other projects or from parts of the same project. It often happens that one engineer will discover that he needs a module that is similar to one that another engineer wrote. However, it also often happens that the module in question has too much baggage that it depends upon. After much work, the engineers discover that the work and risk required to separate the desirable parts of the software from the undesirable parts are too great to tolerate. And so the software is simply rewritten instead of reused.
Viscosity. Viscosity comes in two forms: viscosity of the design, and viscosity of the environment. When faced with a change, engineers usually find more than one way to make the change. Some of the ways preserve the design, others do not (i.e. they are hacks.) When the design preserving methods are harder to employ than the hacks, then the viscosity of the design is high. It is easy to do the wrong thing, but hard to do the right thing.
Viscosity of environment comes about when the development environment is slow
and inefficient. For example, if compile times are very long, engineers will be tempted to make changes that don’t force large recompiles, even though those changes are not optiimal from a design point of view. If the source code control system requires hours to check in just a few files, then engineers will be tempted to make changes that require as few check-ins as possible, regardless of whether the design is preserved.

These four symptoms are the tell-tale signs of poor architecture. Any application that exhibits them is suffering from a design that is rotting from the inside out. But what causes that rot to take place?

Source: Robert C. Martin (http://www.objectmentor.com/)

How can we detect sofware rot before or while it is occuring? Under the motto "To prevent is better than to cure".
The problem is that software roth rarely shows on the short term. I like to compare it to building a house... you build the basement and you realise its not level but level enough for now since your scope is quite limited. When you start building the ground floor you notice that it the problem is becoming more eminent, if after a while you construct more and more floors you will notice that your apartment block will eventually collapse but by then its too late to do something about it.

Everybody knows this but how can we prevent this? I have seen this occur over and over again due to short term quick and dirty hacks and solutions because developers do nor succeed in managing expectations. The only thing you can be certain about in software is change! "It works for now" is imo the beginning of the end.

How can we prevent this? By applying the SOLID principles:

SRP: Single Reponsibility Principle
OCP: Open Closed Principle
LSP: Liskov Substitution Principle
ISP: Integration Segragation Principle
DIP: Dependency Inversion Principle

For more information on this I would recommend Robert C. Martin's Agile Principles, Patterns and Practices in C#

Adding custom properties to Webparts in Sharepoint 2007

2009-08-17T13:01:00.004+02:00

Apparently the syntax changed in MOSS 2007 to add custom properties to your web part in.

Code below:


[WebBrowsable(true)]
[WebDisplayName("Connection string:")]
[SPWebCategoryName("Data")]
[WebPartStorage(Storage.Shared)]
[WebDescription("Connectionstring")]
[Personalizable(PersonalizationScope.Shared)]
public string ConnectionString { get; set; }

Team Build: Setting up workspaces

2009-02-24T09:56:00.012+01:00

One of the errors you might encounter whilst using team build is the following:

The specified path, file name, or both are too long. The fully qualified file
name must be less than 260 characters, and the directory name must be less than
248 characters.

The guide here below will help you to avoid these. But you should also keep in mind not to make your folder structure to complex or too deep. You can group your projects in your solution using solution folders which are not reflected in your physical project location.

Working Directory Build Agent
Set the working Directory for the Build Agent to a path that is not to long (e.g. C:\BuildWorkSpace\$(BuildDefinitionPath). Be aware to add the $(BuildDefinitionPath) variable in order for every build to be stored in a unique location.

Note: this will be replacing the $(SourceDir) variable. (see below)

Source Control Folder
Set the source control folder correctly to the folder containing the solution file.

See below for Solution structure. Te solution root is the parent folder where the solution resides.

Team Build: Strong naming assemblies and Team Build

2009-01-13T22:31:00.004+01:00

This article provides a great Walkthrough for using strongly named assemblies and Team Build in combination with Automated Unit Testing.

http://ozgrant.com/2008/03/13/strong-name-your-assemblies-with-team-build-using-a-private-key/

One additional problem I came across though is when you are running x64 make sure you disable the strong name verification as wel in x64 and x86 consoles!

sn -Vr *,7f668b9f3b05cdd1

Team Build: Enabling Code Coverage without using a test list

2009-01-13T18:16:00.004+01:00

Modify the Test Arguments PropertyGroup to contain the RunConfigFile tag and point it to the correct location

<RunConfigFile>$(SolutionRoot)\01 Dev\Sharpsolutions.SharpMoney\LocalTestRun.testrunconfig</RunConfigFile>

After you have enabled ofcourse the code coverage for the correct projects.

Team Build and Referenced Assemblies

2009-01-12T19:14:00.007+01:00

This session I am going to give some tip how you should reference shared assemblies.

I am currently building an application that uses several things of Enterprise Library and RhinoMocks for unit testing. Now these references have to be made to fixed locations but this can impose problems when building from different machines (think build agents differebt developer machine setups).

What I did was on my build agent I shared the build folder and mapped a networkdrive to it (in my case s:\). then I created a structure like this:
Enltlib\latest\ to which I copied the complete bin directory from entlib. The big advantages is that if you decide to upgrade later you just rename the folder to v4.1 and create a new latest folder where you copy the latest binaries to. Like this everybody will always be referencing the latest binaries without having to redo all their references in their projects

The advantages of this approach is that its completely independent of your machine setup. And if you have to work offline from your TFS once in a while you just make sure you check out the latest version of your BuildStore share the drive on your local machine and map it to the same network drive and your projects will continue to build without having to redirect the references all the time.

XP And new years resolutions

2008-12-31T19:32:00.003+01:00

At the verge on a new year people tend to have new years resolutions and things like that mine is blog more :p amongst others. So here we go.

I recently started reading Ron Jeffries Extreme Programming Adventures in C# (http://www.amazon.com/Extreme-Programming-Adventures-DV-Microsoft-Professional/dp/0735619492). Since quite a little more then a year I Agile Development Methodologies caught my eye. Recently I am starting to dig deeper in TDD and XP. In this series of posts I will let you follow me on my journey.

Team Foundation Server 2008 SP1 with SQL 2008

2008-12-01T17:06:00.003+01:00

I installed TFS 2008 with sql server 2008 and when I opened Team Explorer the Reports node in the team project was marked with a red cross and thus inaccessible.

Simply upgrade your Visual Team System 2008 WITH team explorer installed to SP1

Microsoft Project Server 2007

2008-10-04T13:56:00.006+02:00

I finished installing microsoft Project Server 2007. I came across 2 issues.
The first one was the 2 Services (Microsoft Office Project Eventing Service and the Queue service) not starting this happens when the machine is not connected to the internet and tries to get some certificates from:
http://crl.microsoft.com/pki/crl/products/CodeSignPCA.crl
http://crl.microsoft.com/pki/crl/products/CodeSignPCA2.crl

When you try to start them manually you get "Service did not respond in a timely fashion" and in the Eventlog you have: "Unexpected exception occured".

This can be solved by using this woirkaround:
"
Manually add the CRLs from the above Urls to the server manually (assumes
you've downloaded them locally first):
certutil -addstore CA CodeSignPCA.crl
certutil -addstore CA CodeSignPCA2.crl

Resolution Workaround (don't try this unless you've exhausted everything
else):

We haven't tried this yet, but it is our hunch that if you cannot allow the
server access to the internet that it may be possible to fool .Net into using
locally hosted .crl files. This could only work if the restrictions that
prevent the service account and server reaching the internet still permit a
loop-back request to itself (calling web pages from the local server).

The way to do this is to add this to your HOSTS file on the servers:
127.0.0.1 crl.microsoft.com

"

or make sure you are connected to the internet for the easy solution :p

the other one was that jobs got stuck in the queue in "Waiting to be processed status". This I solved by running the service under the same credentials as the SSPService account.

that all for now folks :)

2008-04-14T22:37:00.012+02:00

Continous Integration and the Database

Spend some few days setting up a continous integration for a database project. Found some stuff on the internet but they got it all wrong :)

I am using Team Foundation Server 2008.

The only thing you need to do is modify the TFSBuild.proj

Modify the following sections. This enabled the automatic generation of a sql script that will be copied in the Drop Folder.
Find the SoltionToBuild tag and add the properties as shown below:


<SolutionToBuild Include="$(BuildProjectFolderPath)/../../CIDB/CIDB.sln">
<Targets></Targets>
<Properties>DefaultDataPath=C:\BuildDrop\;TargetDataBase=TestDb</Properties>
</SolutionToBuild>

Add the default configuration to the ConfigurationToBuild ItemGroup as shown below (make sure to match it to your settings in the Configuration Manager)
<ItemGroup>
<!-- CONFIGURATIONS
The list of configurations to build. To add/delete configurations, edit this value. For example,
to add a new configuration, add the following lines:

<ConfigurationToBuild Include="Debugx86">
<FlavorToBuild>Debug</FlavorToBuild>
<PlatformToBuild>x86</PlatformToBuild>
</ConfigurationToBuild>

The Include attribute value should be unique for each ConfigurationToBuild node.
-->
<ConfigurationToBuild Include="ReleaseAny CPU">
<FlavorToBuild>Release</FlavorToBuild>
<PlatformToBuild>Any CPU</PlatformToBuild>
</ConfigurationToBuild>

<!--Include the configuration to build this generates a .sql file in the drop folder-->
<ConfigurationToBuild Include="DefaultAnyCPU">
<FlavorToBuild>Default</FlavorToBuild>
<PlatformToBuild>Any CPU</PlatformToBuild>
</ConfigurationToBuild>
</ItemGroup>

Next add the following section to the end of the TFSBuild.proj file. the %3B is the escape character for ';' in MSBuild


<PropertyGroup>

<TargetConnection>Data Source=.%3BIntegrated Security=True%3BPooling=False</TargetConnection>
<DefaultDataPath>C:\BuildDrop\</DefaultDataPath>
<TargetDataBase>DevDb</TargetDataBase>
</PropertyGroup>

<Target Name="AfterDropBuild">
<MSBuild Projects="$(SolutionRoot)\CIDB\CIDB\CIDB.dbproj"
Properties="Configuration=Default;
OutDir=$(SolutionRoot)\..\binaries\Default\;
AlwaysCreateNewDatabase=false;
TargetConnectionString=$(TargetConnection);
DefaultDataPath=$(DefaultDataPath);
TargetDataBase=$(TargetDataBase)"
Targets="ReBuild;Deploy" /> <!—Need to specify the Rebuild target otherwise fails -->
</Target>

Update:

If you modify your source folder setting in the workspace - defaults to $(SourceDir)- make sure that you override your SolutionRoot property

by adding the following

...

</ProjectExtensions>
<PropertyGroup>

<SolutionRoot>C:\Workspace_Build02 </SolutionRoot>

....

Thats all there is to it :)

Coming up automatically generate an upgrade script to deploy to production systems... I installed the Database Team Edition on the build agent but I am not quite sure if its necessary I will investigate this... I dont know if its default part of ms build

2008-02-13T11:51:00.003+01:00

Long time since I made a blogpost. But finally got my TFS server running at home and it works like a charm

This guide proved to be very usefull:
http://bloggingabout.net/blogs/mglaser/archive/2007/01/31/hosting-team-foundation-server-on-a-fully-qualified-domain-name-fqdn.aspx

2007-09-24T15:13:00.004+02:00

Create A Compression extension using .NET 2.0
(original version can be found here: http://www.123aspx.com/redir.aspx?res=29459)

First of all we create a class that does all the work


public class CompressionExtension : SoapExtension {
Stream _OldStream;
Stream _NewStream;


public override object GetInitializer(LogicalMethodInfo methodInfo,
SoapExtensionAttribute attribute) {
return attribute;
}

// Get the Type
public override object GetInitializer(Type t) {
return typeof(CompressionExtension);
}

// Get the CompressionExtensionAttribute
public override void Initialize(object initializer) {
if (initializer is CompressionExtensionAttribute) {
CompressionExtensionAttribute attribute =
(CompressionExtensionAttribute)initializer;
}


return;
}

// Process the SOAP Message
public override void ProcessMessage(SoapMessage message) {
// Check for the various SOAP Message Stages
switch (message.Stage) {

case SoapMessageStage.BeforeSerialize:
break;

case SoapMessageStage.AfterSerialize:
// ZIP the contents of the SOAP Body after it has
// been serialized
Zip();
break;

case SoapMessageStage.BeforeDeserialize:
// Unzip the contents of the SOAP Body before it is
// deserialized
Unzip();
break;

case SoapMessageStage.AfterDeserialize:
break;

default:
throw new Exception("invalid stage");
}
}

// Gives us the ability to get hold of the RAW SOAP message
public override Stream ChainStream(Stream stream) {
_OldStream = stream;
_NewStream = new MemoryStream();
return _NewStream;
}

// Utility method to copy streams
void Copy(Stream from, Stream to) {
TextReader reader = new StreamReader(from);
TextWriter writer = new StreamWriter(to);
writer.WriteLine(reader.ReadToEnd());
writer.Flush();
}


// Zip the SOAP Body
private void Zip() {
_NewStream.Position = 0;
// Zip the SOAP Body
_NewStream = ZipSoap(_NewStream);
// Copy the streams
Copy(_NewStream, _OldStream);
}

// The actual ZIP method
private byte[] Zip(string stringToZip) {
byte[] inputByteArray = Encoding.UTF8.GetBytes(stringToZip);
MemoryStream ms = new MemoryStream();

// Check the #ziplib docs for more information
GZipStream zipOut = new GZipStream(ms, CompressionMode.Compress);
zipOut.Write(inputByteArray, 0, inputByteArray.Length);
zipOut.Close();

// Return the zipped contents
return ms.ToArray();
}

// Select and Zip the appropriate parts of the SOAP message
public MemoryStream ZipSoap(Stream streamToZip) {
streamToZip.Position = 0;
// Load a XML Reader
XmlTextReader reader = new XmlTextReader(streamToZip);
XmlDocument dom = new XmlDocument();
dom.Load(reader);
// Load a NamespaceManager to enable XPath selection
XmlNamespaceManager nsmgr = new XmlNamespaceManager(dom.NameTable);
nsmgr.AddNamespace("soap", "http://schemas.xmlsoap.org/soap/envelope/");
XmlNode node = dom.SelectSingleNode("//soap:Body", nsmgr);
// Select the contents within the method defined in the SOAP body
node = node.FirstChild.FirstChild;
// Check if there are any nodes selected
while (node != null) {
if (node.InnerXml.Length > 0) {
// Zip the data
byte[] outData = Zip(node.InnerXml);
// Convert it to Base64 for transfer over the internet
node.InnerXml = Convert.ToBase64String(outData);
}
// Move to the next parameter
node = node.NextSibling;
}
MemoryStream ms = new MemoryStream();
// Save the updated data
dom.Save(ms);
ms.Position = 0;

return ms;
}

// Unzip the SOAP Body
private void Unzip() {
MemoryStream unzipedStream = new MemoryStream();

TextReader reader = new StreamReader(_OldStream);
TextWriter writer = new StreamWriter(unzipedStream);
writer.WriteLine(reader.ReadToEnd());
writer.Flush();
// Unzip the SOAP Body
unzipedStream = UnzipSoap(unzipedStream);
// Copy the streams
Copy(unzipedStream, _NewStream);

_NewStream.Position = 0;
}

// Actual Unzip logic
private byte[] Unzip(string stringToUnzip) {
// Decode the Base64 encoding
byte[] inputByteArray = Convert.FromBase64String(stringToUnzip);
MemoryStream ms = new MemoryStream(inputByteArray);
MemoryStream ret = new MemoryStream();

// Refer to #ziplib documentation for more info on this
GZipStream zipIn = new GZipStream(ms, CompressionMode.Decompress);
Byte[] buffer = new Byte[2048];
int size = 2048;
while (true) {
size = zipIn.Read(buffer, 0, buffer.Length);
if (size > 0) {
ret.Write(buffer, 0, size);
} else {
break;
}
}
return ret.ToArray();
}

// Unzip the SOAP Body
public MemoryStream UnzipSoap(Stream streamToUnzip) {
streamToUnzip.Position = 0;
// Load a XmlReader
XmlTextReader reader = new XmlTextReader(streamToUnzip);
XmlDocument dom = new XmlDocument();
dom.Load(reader);

XmlNamespaceManager nsmgr = new XmlNamespaceManager(dom.NameTable);
nsmgr.AddNamespace("soap", "http://schemas.xmlsoap.org/soap/envelope/");
// Select the SOAP Body node
XmlNode node = dom.SelectSingleNode("//soap:Body", nsmgr);
node = node.FirstChild.FirstChild;

// Check if node exists
while (node != null) {
if (node.InnerXml.Length > 0) {
// Send the node's contents to be unziped
byte[] outData = Unzip(node.InnerXml);
string sTmp = Encoding.UTF8.GetString(outData);
node.InnerXml = sTmp;
}
// Move to the next parameter
node = node.NextSibling;
}

MemoryStream ms = new MemoryStream();

dom.Save(ms);
ms.Position = 0;

return ms;
}

}

Next we create a class that will be able to use as an attribute


public class CompressionExtensionAttribute : System.Web.Services.Protocols.SoapExtensionAttribute {

        private int _Priority;

        // Override the base class properties
        public override Type ExtensionType {
            get { return typeof(CompressionExtension); }
        }

        public override int Priority {
            get {
                return _Priority;
            }
            set {
                _Priority = value;
            }
        }
    }

This approach involves updating the reference.cs manually. We are going to extend this in order that if we choose update webreference in Visual studion the attribute is added immediately to the proxy class. (For more detail goto: http://msdn2.microsoft.com/en-us/library/x4s9z3yc.aspx)

2007-04-20T12:29:00.002+02:00

Create a Winforms ComboBox with a default text when nothing is selected.

Follow these easy steps to create a combox that shows a text instead of an empty line when nothing is selected

Create a new UserControl

in the code view make sure the Class Enherits from ComboBox instead of UserControl

In the default constructor set the DrawMode to OwnerDrawn.

Add two properties UnSelectedColor of type Color and UnSelectedText of type string

Override the OnDrawItem method

I will put a more detailed article on my personal homepage. Link will follow later.

Thanks to Richard Everett who provided me the example code

2007-04-16T16:52:00.001+02:00

Easy way for filtering a BindingList

Found this opensource project: http://sourceforge.net/projects/blw/

As a replacement for datasets/dataTables

2007-04-03T13:42:00.002+02:00

Guid vs Int

Rather interesting article on when tho use a guid or an int as a Primary Key:

http://databases.aspfaq.com/database/what-should-i-choose-for-my-primary-key.html

Summary:

IDENTITY

PROS

small storage footprint;
optimal join / index performance (e.g. for time range queries, most rows recently inserted will be on a limited number of pages);
highly useful for data warehousing;
native data type of the OS, and easy to work with in all languages;
easy to debug (where userid = 457);
generated automatically (retrieved through SCOPE_IDENTITY() rather than assigned);
not updateable (though some consider this a disadvantage, strangely enough).

CONS

cannot be reliably "predicted" by applications â€” can only be retrieved after the INSERT;
need a complex scheme in multi-server environments, since IDENTITY is not allowed in some forms of replication;

can be duplicated, if not explicitly set to PRIMARY KEY:

CREATE TABLE splunge(
splungeID INT IDENTITY(1,1),
foo CHAR(1)
)
GO
SET NOCOUNT ON
INSERT splunge(foo) VALUES('a')
INSERT splunge(foo) VALUES('b')
INSERT splunge(foo) VALUES('c')
GO
DBCC CHECKIDENT('splunge', RESEED, 2)
GO
INSERT splunge(foo) VALUES('d')
GO
SELECT * FROM splunge
GO
DROP TABLE splunge
GO

if part of the clustered index on the table, this can create an insert hot-spot;
proprietary and not directly portable;
only unique within a single table;
gaps can occur (e.g. with a rolled back transaction), and this can cause chicken little-style alarms.

GUID()

PROS

since they are {more or less} guaranteed to be unique, multiple tables/databases/instances/servers/networks/data centers can generate them independently, then merged without clashes;
required for some forms of replication;
can be generated outside the database (e.g. by an application);
distributed values prevent hot-spot (as long as you don't cluster this column, which can lead to abnormally high fragmentation).

CONS

the wider datatype leads to a drop in index performance (if clustered, each insert almost guaranteed to 'dirty' a different page), and an increase in storage requirements;
cumbersome to debug (where userid = {BAE7DF4-DDF-3RG-5TY3E3RF456AS10});
updateable (need to propogate changes, or prevent the activity altogether);
sensitive to time rollbacks in certain environments (e.g. daylight savings time rollbacks);
GROUP BY and other set operations often require CAST/CONVERT;
not all languages and environments directly support GUIDs;
there is no statement like SCOPE_GUID() to determine the value that was generated, e.g. by NEWID();
there are display issues to consider, such as response.write issues (see Article #2358), and also consider cases where you display a large amount of rows as checkboxes or other form elements with IDs - your page just got a whole lot bigger, and you have to handle the IDs in a custom way because JavaScript can't deal with objects that have dashes in their name/id.

2007-03-06T22:33:00.002+01:00

I came across an annoying little thing trying to trigger an event that updates the UI...

{"Cross-thread operation not valid: Control 'label1' accessed from a thread other than the thread it was created on."}

This happens because the UI runs in a specific thread. Now we create another thread and try to access the UI thread which throws the above exception. There is a solution in msdn but imo its not a good one.

Thus we need to marshal the event from one thread to the other thread as shown below.

the source (just create a new form called form1 and drag a label and a button on it):

ThreadComponent.cs


using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.ComponentModel;


namespace WindowsApplication3 {
    public delegate void ShowSomethingHandler(string message);
  

    public class ThreadedComponent {
        private Thread _Thread;      

        public ThreadedComponent() {
            _Thread = new Thread(Poll);
            _Thread.Start();

        }

        private void Poll() {
            int i = 0;
            ISynchronizeInvoke invoker = ShowSomething.Target as ISynchronizeInvoke;
            while(true) {
                if(ShowSomething != null) {
                  
                   //ShowSomething("Message N°:" + (++i));
                    if(!invoker.InvokeRequired) {
                        object[] args = {"Message N°:" + (++i)};
                        invoker.Invoke(ShowSomething, args);
                    } else {
                        ShowSomething("Message N°:" + (++i));
                    }
                  
                  
                }
                Thread.Sleep(1000);
            }
        }

        public event ShowSomethingHandler ShowSomething;
    }
}

Form1.cs


namespace WindowsApplication3 {
    public partial class Form1 : Form {
        public Form1() {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e) {
            ThreadedComponent c = new ThreadedComponent();
            c.ShowSomething += new ShowSomethingHandler(c_ShowSomething);
        }

        void c_ShowSomething(string message) {
            label1.Text = message;
        }
    }
}

2007-02-24T17:46:00.000+01:00

Finished my MCPD: Enterprise applications cerification last week

2007-02-04T19:21:00.000+01:00

Finally managed to solve a problem that has been bugging me for ages now. When tryinng to use the wizard for databinding to an object the Wizard gave an error :
"An unexpected error has occurred"
"Error Message: Object reference not set to an instance of an object"

The solution can be found here:
http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=380441&SiteId=1&PageID=3

2007-02-04T19:15:00.000+01:00

Finished the 70-553 upgrade exam. I am now officially
MCTS: .NET Framework

Windows Applications
WebApplications

2006-12-08T14:12:00.000+01:00

Passed my second CRM exam, Extending Microsoft CRM 3.0 today . I am now a Microsoft Certified Business Management Solutions Professional - Microsoft Dynamics CRM Developer.... ;)

2006-12-05T15:42:00.000+01:00

Struggling to install virtual server RC2 on Vista :)

Found the solution here : http://blogs.msdn.com/virtual_pc_guy/archive/2006/06/05/618547.aspx

in short:

Install Virtual server like this:
start /w pkgmgr /l:log.etw /iu:IIS-WebServerRole;IIS-WebServer;IIS-CommonHttpFeatures;IIS-StaticContent;IIS-DefaultDocument;IIS-DirectoryBrowsing;IIS-HttpErrors;IIS-HttpRedirect;IIS-ApplicationDevelopment;IIS-ASPNET;IIS-NetFxExtensibility;IIS-ASP;IIS-CGI;IIS-ISAPIExtensions;IIS-ISAPIFilter;IIS-ServerSideIncludes;IIS-HealthAndDiagnostics;IIS-HttpLogging;IIS-LoggingLibraries;IIS-RequestMonitor;IIS-HttpTracing;IIS-CustomLogging;IIS-ODBCLogging;IIS-Security;IIS-BasicAuthentication;IIS-WindowsAuthentication;IIS-DigestAuthentication;IIS-ClientCertificateMappingAuthentication;IIS-IISCertificateMappingAuthentication;IIS-URLAuthorization;IIS-RequestFiltering;IIS-IPSecurity;IIS-Performance;IIS-HttpCompressionStatic;IIS-HttpCompressionDynamic;IIS-WebServerManagementTools;IIS-ManagementConsole;IIS-ManagementScriptingTools;IIS-ManagementService;IIS-IIS6ManagementCompatibility;IIS-Metabase;IIS-WMICompatibility;IIS-LegacyScripts;IIS-LegacySnapIn;IIS-FTPPublishingService;IIS-FTPServer;IIS-FTPManagement;WAS-WindowsActivationservice;WAS-ProcessModel;WAS-NetFxEnvironment;WAS-ConfigurationAPI

If this does not work look at the above link for the manual install you just have to install IIS and see that the 'IIS 6 Management Compatibility' is checked

Then I got this error:
The following error occurred:An error occurred accessing the website application data folder.

This is solved by running Internet Explorer as Administrator (make sure you have windows authentication enabled in "Authentication" In your websites managment console)

2006-11-30T08:46:00.000+01:00

Run across a minor issue while trying to install Visual Studion 2005 on Vista.
When installing he suddenly says he can not copy a certain file. you can retry or cancel. Cancel the installation and rerun the setup.exe with "Elevated Administrator Rights" . This should solve that issue. If this does not work try to install the latest version of Daemon tools because second time i tried the elevated administrator rights did not resolve the issue.

When I tried to run Visual Studio I get a warning. I recommend that you read what it has to say because there are numerous issues that may occur...

Do not forget to install the latest service pack either.

2006-11-29T15:47:00.000+01:00

Today spent a large part of the day installing VISTA on my laptop
Something I had to look for was how to sync my Qtec s200 with vista. Figured out I had to install "Microsoft Windows Mobile Device Center Beta 3 for Windows Vista"

You can download it here:
http://www.microsoft.com/downloads/details.aspx?FamilyId=C23C8E6A-A72D-4AEF-9663-31CE2FEFBADA&displaylang=en

Works more stable than the RC2 from october that I installed on my desktop a month ago. (until now :p)

2006-11-13T12:03:00.000+01:00

Installed windows vista and office 2007 this weekend. Looks great only computer is a lot slower now :/ thnking about reverting back.

Only problem I came across is that I could not install daemon tools to mount iso images. Found a very good (free) alternative: elby Virtual CloneDrive is can be found here : http://www.elby.de/fun/software/index.html

2006-10-26T15:06:00.000+02:00

Playing around with the WPF (Avalon) looks neat!

Made my first databound custom control its pretty easy...
I had been struggling with it for a short while but then turned on some scandicrust and it did wonders ;)

Also extending my framework bit by bit. Starts to look quit nice.

2006-09-20T15:52:00.000+02:00

Yesterday I came across a small problem in CRM I needed to disable all fields in a form except one o_O. So this is what I came up with:

I put this in my form_load event

Since I am a lazy programmer is used a loop :D


var type = 'hidden+text+select-one+checkbox+textarea+radio';
for (i=0;i <crmform.all.length;i++){
     if(type.indexOf(crmForm.all[i].type) != -1){
//disable all fields except new_SomeField
         crmForm.all[i].disabled= (crmForm.all[i].id != 'new_SomeField');
    }
}
//Disable lookup fields manually
crmForm.all.ownerid.disabled = true;
crmForm.all.preferredserviceid.disabled = true;
crmForm.all.preferredequipmentid.disabled = true;
crmForm.all.preferredsystemuserid.disabled = true;

For the future maybe use an array containing all
the fields you want to disable / leave enabled.