Morten Lyhr

Reusability and discoverability of LINQ Queries

2011-04-14T22:45:00.001+02:00

I agree with Ayende point that Repositories and DAL’s are pretty much a thing of the past.

Usually my LINQ queries contains 3 distinct parts:

Some filtering
Some transformation
Some selection

If I search for LINQ reusability I get some hits where all 3 parts are reused together. But in my experience it is extremely rare I need the same 3 parts in more than 1 place.

In my experience it is often the filtering part that is used many places. I did not have a good solution for this, until I read ayendes post.

After some though I came up with the following.

Notice how the filtering is reusable, and chainable in LINQ . Also the code reads very well and the where clauses are easily discoverable with intellisence.

This approach is very light weight and flexible, just like code should be.

Windows Home Server 2011–How I use it

2011-04-14T21:38:00.001+02:00

I recently added a Western Digital Hard disk with a new sector? size to my Windows Home Server 2003. Within a week it behaved very strangely. Afterwards I found out I had to set a jumper on the disk before using it in a pre-windows 7 machine.

So I installed a fresh Windows Home Server 2011, on my excellent Tranquil PC BBS. Installation went smooth and and I was up and running. I added the wifes laptop, my laptop, childrens laptop and the MCE to automatic backup.

I really don’t want to open any ports in my router, I dint think its worth the security risk. I think MS should have shipped at free remote service with WHS, that did the relaying. I have used Hamachi before but it is too slow and is unstable, unless some ports are open in the router. Now I use Remobo and works great and is very fast, its free unless you need to run it as a windows service. Installation was easy and it just works.

Currently the server sports a 2TB drive and a 1,5TB drive. In the old WHS Drive Extender made all the data available as a single 3,5TB unit, but the new WHS does not support this. Many have declare WHS dead because this feature was removed, but I don’t get it? I actually like the simple transparent way much better. I only have 2 media types that require TB’s of space and that is DVD rips, and Recorded TV. When I have too grow I just add a “Recorded TV 2” share and have my MCE point to that too, no one will notice.

I am a firm believer that most work should be done on the local machine and not over network. So the wifes documents and all the family pictures are stores on the wifes laptop. She sometimes delete files or removes text from documents. With WHS I only have a nightly backup, so I need something something to continuously backup files to the home server share. I ended up using AutoVer, its free automagically creates a copy of the file with a date extension. This cost some extra space, but it is worth it. Now I have all changes made to her files not just images every night.

For off-shore backup (you do keep you backup at another location right?) I use 2 e-sata enclosings with 1,5GB HDD’s in them. I keep one at home attached to the server and one at work locked up. Every monday pickup the one at home and swap it with the one at work. This kind of backup works great in case of fire, virus or hacker attacks since the disk is offline and at another location. With the old WHS I could mount the backup HDD in any other computer and see the files, but the new one hides the data in a unknown format. I like the old transparent way, now I have to use WHS to restore a file.

I have some critical data, the family pictures/videos about 60GB of it. So I asked on superuser how I should make a backup of those files to the cloud. The answer was a great product called CloudBerry Backup. Its optimized for S3 usage, so it does not use too much bandwidth or space. All files can be downloaded from Amazon S3 afterwards from any tool. Not like Mozy or the like where you are dependent their tools for restore. Cloudberry Backup offered a simple and transparent way of doing cloud backup. Installation and setup was silly easy, I set mine to run every night at 00 to 06 hours (It takes a few night to upload 60GB of data). I get a email report every day specifying total data, and how much was transferred. CloudBerry Backup just pickes up where it left the day before, even large files are uploaded in chunks so no bandwidth is wasted when it resumes the next night.

So there you have it, using a few extra tools I just made my WHS even more valuable too me.

Embedding a TFS Build label in all assemblies

2010-03-17T20:14:00.001+01:00

The default TFS build label does not have a xx.xx.xx.xx pattern, but looks like “MyBuild_20070418.1”. So we cant assign the value to the AssemblyVersion or AssemblyFileVersion attribute, however the AssemblyInformationalVersion attribute can be used as it is a string.

        1: <Target Name="AfterGet">

       2:   <!-- Insert build label into assemblies -->

       3:   <Message Text="Modifying AssemblyInfo files under &quot;$(SolutionRoot)&quot;." />

       4:  

       5:   <Message Text="Undo checkout assemblyinfo files, make sure no files are checked out." />

       6:   <Exec Command="&quot;C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\tf.exe&quot; undo *.* /recursive /noprompt"

       7:         WorkingDirectory="$(MSBuildProjectDirectory)\..\sources" ContinueOnError="true"/>

       8:  

       9:   <Message Text="Checkout assemblyinfo files" />

  <Exec Command="&quot;C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\tf.exe&quot; checkout &quot;AssemblyInfo.*&quot; -r"

        WorkingDirectory="$(MSBuildProjectDirectory)\..\sources" ContinueOnError="true"/>

  

  <ItemGroup>

    <AssemblyInfoFilesCs Include="$(SolutionRoot)\**\assemblyinfo.cs" />

  </ItemGroup>

  

  <Message Text="Adding $(LabelName) to %(AssemblyInfoFilesCs.fullpath)" />

  

  <WriteLinesToFile

          File="%(AssemblyInfoFilesCs.fullpath)"

          Lines="[assembly: AssemblyInformationalVersion(&quot;$(LabelName)&quot;)]"

          Overwrite="false"/>

</Target>

  

  

  

<Target Name="AfterCompileSolution">

  <Message Text="Undo checkout assemblyinfo files" />

  

  <Exec Command="&quot;C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\tf.exe&quot; undo *.* /recursive /noprompt"

        WorkingDirectory="$(MSBuildProjectDirectory)\..\sources" ContinueOnError="false"/>

</Target>

With this in place all assemblies (dll, exe), will have a AssemblyInformationalVersion attribute with the label of the TFS Build. So it should be a no-brainer to trace a dll to a point in time in TFS Source Control. Just open the dll in reflector and disassemble the dll.

An alternative to AssemblyInformationalVersion would be AssemblyConfiguration, but then we have to use a task that can do a text replace, as it is usually already defined in AssemblyInfo.cs files.

SQL Server Restore database with exclusive access

2010-03-02T13:09:00.001+01:00

        1: ALTER DATABASE MyDatabase SET SINGLE_USER WITH ROLLBACK IMMEDIATE  

       2:  

       3: RESTORE DATABASE MyDatabase FROM DISK = 'X:\Path\mybackup.bak'

In effect this rolls back any pending transactions, and gives you exclusive access to the database.

Effective Logging

2010-02-04T23:09:00.001+01:00

Runtime diagnostics

There are 3 major ways to diagnose code at runtime.

I think most .NET developers use the debugger everyday in Visual Studio, and Automated tests (actually mostly unit tests) get a lot of blog space. But interestingly logging i not mentioned often? In some scenarios on way is more useful than the 2 other, and some times it does not matter which one is used. But all 3 ways have distinct advantages that can be used, to ease our busy developer lives.

Advantages

If your application has crashed, It does not matter how many unit tests or how good you are with the debugger. A good log will help you identify the problem.

In a live application the performance degradation(amount of log messages) can be controlled, by setting a log level. The application does not even have to be restarted. Unit tests does not do much with live applications and usually it is not wise to attach a debugger to a live application.

Statistics can be gathered from logs, like key performance indicators, number of exceptions etc. WMI can also be used, but that is actually just an other kind of logging (internal vs external).

Logs (often log files) act as an alternative UI, administrators/supporters etc. can read logs and determine out of process usage of the application.

If there is a good log there is no reason to call the user and start a “shared screen” so you can see what he does.

Messages

Don't just output values, describe what the values mean. When reading the log, you don't have the source code to help you - only the previous and next message(s).

Logging as a global error handler

As far as I can tell this is where most applications have some form of logging. The implementation looks differently depending on the type application.

In a WinForms app it looks something like this.

And in an ASP.NET app it could looks like this.

However this at the application boundary, it should be the only place in your code where the type Exception is caught. All uncaught exceptions should be allowed to bubble up to the global error handler and properly logged.

Logging is not error handling for the user

Don't log an exception just to re-throw the exception. But if you actually catch an specific exception type, always log the exception. The fact that the exception was caught could come in handy when diagnosing a problem with the application.

Decision Points

Are where the code branch, like if, switch and the like.

Don’t log inside a decision point, and don’t log where there is no decision point. Also don't log values that are not used for the decision.

Do log before a decision point and do log the value(s) that are used to determine what branch to use. Do log all the values in a single formatted message. There are more decision points than “if”’s, logical operators also act as a decision point.

Things to log even though it is not a decision point

When the application uses out of process resources (File system, starts a process etc.), Do log the resource used.

This could help an administrator understand how the application works.

Another thing to always log is the use of DateTime.Now

DateTime.Now problems are often elusive and hard to replicate in a debugging environment, having the exact value help to understand under what conditions a problem can occur.

Point of indirection (like events) where there is no clear path to the calling code. It can be helpful to see what events get called and in what order.

Assertion

Don’t use logging for assertion, a manual test with the debugger or a repeatable automated test are better suited for this.

Message Context

Every log message should have context values that determines this usage from others. Often things like:

Timestamp
Level (debug, trace, info, warning, error, fatal)
Thread
Principal (username)
Url (for web apps)
Request hashcode (for web apps)
Session hashcode (for web apps)

Using these message contexts, it should be easy to grab interrelated messages for analysis.

Conclusion

Don't neglect logging just because your more familiar with the debugger or you and your agile team has the code base covered with automated tests. In some scenarios logging is a vital view into your running application.

How to restore to another database with full text index

2010-01-27T11:26:00.001+01:00

I have been using this little trick for some time now.

The other day I had to restore a backup to a database with full text indexes.

First we need to know the files included in the backup.

        1: RESTORE FILELISTONLY FROM DISK='C:\backup.bak'

Next we need to move the additional files to another location.

       1: RESTORE DATABASE myDatabase FROM DISK = 'C:\mybackup.bak' WITH REPLACE,

       2: MOVE 'ftname_ft' TO 'c:\newpath\ftname.ft'

Optimizing build times

2010-01-26T22:58:00.000+01:00

Background

I am currently working on a large winforms code base.

It has 60+ Visual Studio projects in a single Solution.

The project dependencies are “V” shaped. Many projects are dependent on a few projects, that are dependent on even fewer projects. So the many projects should be parallelized, after the few projects have been build in sequence.

Getting started

First of all I needed to get a base measurement of how long the build takes.
I don't trust ReBuild to not cheat, so I deleted all source files on disk and got them again from source control.
Next Visual Studio does not show build times, so I used MSBuild from the concole. It is very easy, because a sln file is a MSBuild file. ex: “msbuild my-solution.sln” and the total build time is showed when it is finished.

Analysis

So my build was taking approximately 4 minutes I needed to find the low hanging fruits, that would make a huge impact with minimum of work and change.
Adding a parameter to msbuild helped me do that. ex: “msbuild my-solution.sln /v:diag”, now the build took longer but I could see what it was doing. One thing immediately caught my attention, the creation of a COM wrapper for MSHTML.dll. It took almost a minute, that's 25% of the total time. So I changed the reference from the COM to the PIA (Primary Interop Assembly).

During my analysis I repeatedly had to delete the local files and get them from source control, and I noticed that my source code files and 3rd party dll’s was approximately 200MB. After the build was done the folder was almost 3GB!
The sinner was a little property called “copy local” automatically set to true in every project in Visual Studio (except for the system references).
So I set all projects references to copy local false, and the disk writes went down – way down.

But I had created a new problem, I could not start the program any longer because the main exe file did not have all the dll references copied (the windows services and websites did not start either). So In order to enable “F5” again I set all the projects output path to the same bin folder.

Hardware

My main laptop is shipped with a Samsung SSD 64GB Hard drive, so I needed an additional hard drive for my WMs and growing code base. I ordered an Icy Box with USB power and esata, and a WD Velocy Raptor 10000RPM Hard drive (the fastest non SSD out there?). But the greedy Velocy Raptor was too much for the USB power, so I ended up ordering a WD Black 7200RPM HDD.

So basically I had a SSD, a fast 7200RPM and a 10000RPM drive, so why not let them duke it out :-)
Actually I added another option, a RAM Drive like this one http://stevesmithblog.com/blog/using-ramdisk-to-speed-build-times/

Build times in seconds, less is better.

The first think to notice is that the SSD is the slowest of all the disks! Now I am no expert, but the SSD runs the OS and all the applications so it has other duties too. It is also kind of an early SSD, I think the new Intel X25 has better performance for builds (lots of small reads and writes). It is a really good disk for my OS and applications, every thing runs really smooth.

Next thing to notice is the RAM drive flattens as there are less disk activity, it looks like it becomes a bottleneck(maybe the compiler is greedy on the RAM bus?).

Last thing to notice is the 7200RPM and 10000 RPM drives are almost equally fast, when building to the same bin folder with copy local = false. And the drive is a lot cheaper.

Conclusion

Remember this is NOT universally applicable. But looking for things that take a long time to compile, like the COM reference or reducing disk reads/writes is. Going from 4 minutes to under 1 minute is not too bad.

The beauty of 2 state enums

2009-09-25T23:10:00.001+02:00

The .NET type system already has a type for 2 states, it is of cause the Boolean. So why would I want to make a custom type?

Lets look at some code.

        1: var export = new SchemaExport(_cfg);

       2: var sb = new StringBuilder();

       3: TextWriter output = new StringWriter(sb);

       4: export.Execute(true, false, false, null, output);

The code above is from NHibernate, more specifically it is NHibernates schema export.

The documentation looks like the following.

public void Execute(bool script, bool export, bool justDrop, System.Data.IDbConnection connection, System.IO.TextWriter exportOutput)
Member of NHibernate.Tool.hbm2ddl.SchemaExport

Summary:
Executes the Export of the Schema in the given connection

Parameters:
script: true if the ddl should be outputted in the Console.
export: true if the ddl should be executed against the Database.
justDrop: true if only the ddl to drop the Database objects should be executed.
connection: The connection to use when executing the commands when export is true. Must be an opened connection. The method doesn't close the connection.
exportOutput: The writer used to output the generated schema

Remarks:
This method allows for both the drop and create ddl script to be executed. This overload is provided mainly to enable use of in memory databases. It does NOT close the given connection!

Now I don't necessarily remember method signatures all to well. So custom type too the rescue, or rather custom enum too the rescue.

       1: public enum Script

       2: {

       3:     OutputToConsole,

       4:     NoConsoleOutput

       5: }

       6: pulic enum Export

       7: {

       8:     ExecuteScriptAgainstDatabase,

       9:     DontExecuteAgainstDatabase

      10: }

      11: public enum DDL

      12: {

      13:     DropOnly,

      14:     CreateAndDrop

      15: }

      16: export.Execute(Script.OutputToConsole, Export.DontExecuteAgainstDatabase, DDL.CreateAndDrop, null, output);

Another alternative is to make several methods that can be named, or create a class that takes the arguments as properties, so that they can be optional.

Using NHibernate and SQLite on x64

2009-09-23T09:13:00.001+02:00

If you are using a x64 OS, and have a reference to System.Data.SQLite and NHibernate throws exceptions like these:

NHibernate.HibernateException : Could not create the driver from NHibernate.Driver.SQLite20Driver, NHibernate, Version=2.1.0.4000, Culture=neutral, PublicKeyToken=aa95f207798dfdb4.
NHibernate.HibernateException : The IDbCommand and IDbConnection implementation in the assembly System.Data.SQLite could not be found. Ensure that the assembly System.Data.SQLite is located in the application directory or in the Global Assembly Cache. If the assembly is in the GAC, use <qualifyAssembly/> element in the application configuration file to specify the full name of the assembly.

It most likely because SQLite is not a managed dll, it is compiled to a specific CPU.

System.Data.SQLite does not change this behavior since it is just a wrapper and container for the unmanaged dll.

The easiest way to fix this is to change the platform target under build properties of the Visual Studio project to x86.

Another alternative is to choose the x64 version of System.Data.SQLite, but if the same source code is used on both x86 and x64 it is not option.

Data, objects and abstractions – Are there more to DIP?

2009-05-22T00:21:00.001+02:00

If we define the following:

Data is just raw data, with no context and no logic associated.

Objects contains both data and behavior that operates on that state.

Abstractions defines behavior by naming, with out any details of how the desired behavior is implemented.

A common definition of DIP states that:

High level modules should not depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions.

That keeps the objects from referencing each other, creating low coupling = a good thing :-)

In C# code following DIP, there is often an “IFooBar” and a “FooBar”. So we have a 1 to 1 between abstractions and object classes. I never really liked it, I don't know why it just don't feels right. Another side effect is that objects that depend on the abstraction can now be unit tested, but often we need to mock the abstraction. In my opinion this leads to hard-to-read and brittle tests.

Is there a simple alternative?

So if objects should not depend upon other object and an abstraction is not desirable, what should the dependency be?

Data

It just like messaging between systems, only this is inside an system. Instead of having a direct dependency to the “CustomerRepository” or having to create a “ICustomerRepository”, just depend on a Customer or a Customer[], nice and simple. This assumes that the Customer is data, and not a object or abstraction.

Move as much if/else/switch/loop code to object classes that depend on and creates data, that way they are easily read, tested and understood. As close to the user action (button click etc. – I call them “Controllers”), get the data needed(possible from a database), pass it to or create the objects, and then take action based on the data result(SubmitChanges to the database, send the MailMessage or what not). These “Controllers” are hard to test and need mocking because of all the database work, mail sending etc., so here classic DIP applies. The Controllers should have a minimum of conditional statements (if) and the few if statements needed should not be nested. This is extremely procedural in nature, and is easy to read.

Sometimes we actually need an abstraction, and by all means make one. But code reads better when it just data flowing through logic.

Combo box vs Button

2009-02-19T16:47:00.001+01:00

I don't know exactly why, but I almost never use combo boxes/drop-down liste etc.

If we have an order with an order status, where order status can be cancelled, pending, approved and shipped.

I often see screens like this:

The screen makes sense for most developers because that is how the data i structured in the database, usually with an Order and OrderStatus table.
In code this is mapped to an Order class and an OrderStatus enum, where the Order class has a Status property with the type of OrderStatus.

So its easy with data binding to make every property a field in the screen, and most data binding will happily make enum properties to combo boxes.

What does the user want to do

So how can we express the order status without a combo box?

Actually the question is not hard to answer, just try to understand what the user really wants.
”A user wants to be able to change the order from a status, to any status that is valid.”

In the above case, most likely not every order status is valid from all other order statuses. So its ok to go from Pending to Approved, but not from Shipped to Pending.

So the key is, to only show valid changes in order status, and to make the user able to trigger these changes.

A solution could look like this screen:

Conclusion

While simple data binding is easy to do in most platforms, it might not be the best solution – from a users perspective.

Usability session with me from ANUG

2008-10-30T14:26:00.001+01:00

Its in Danish, sorry.

I volunteered to participate in a usability study of hertz.com.
I was to rent a car in L.A. for a week.

The session was not rehearsed in advance, and there is an audience of about 50 people.

Data Structures vs Encapsulation

2008-10-01T21:56:00.001+02:00

Having read Clean Code I really wanted to blog about data structures (DTO) and encapsulated objects. But I have been busy and someone else beat me to the punch. Uncle Bob also has an article where he outlines his view.

Data Structure Objects

In C# a Data Structure is represented by a class or struct, that has has no logic and exposes all its state through properties(public fields or get/set methods). Its primarily used near the system boundaries, like UI, Service end points, and database access. Anyone can use the exposed data and operate on it, so adding new behavior is easy, but adding new or changing existing data is troublesome.

Encapsulated Objects

Are represented by C# classes/interfaces with methods that operate on data. The data is hidden(encapsulated). Internally the object can have Data Structure Objects as state, and operate on that state. Methods define the operation that can either be a command (changes the state, and returns nothing) or a query (does not change state, and returns something). A Validator could have a Validate command method that validates the internal state, and a ValidationNotifications query that returns the result of the last validation.

Changing the state is easy because it is only know internal in the class, but adding new or changing existing behavior is troublesome, because it changes the contract of the class.

Hybrid Objects

Hybrids often appear because of database and UI concerns. A class exposes it state so that the UI can data bind and the DAL can save the entity. But the same class should also be encapsulated so that the logic only lives with in the object.

So now the class has two distinct responsibilities:

Exposing state for the UI and DAL to use.
Exposing logic for validation etc.

And guess what, if it is combined in a Hybrid Class it has the drawbacks of both, and non of the benefits. So Hybrids should really be avoided, and interesting happen when you don't create hybrids.

Should all my classes be Encapsulated Objects?

NO!

Even though all the cool kids show off their OO skilz, many problems are best solved with a simple Data Structure Class. If your application starts out as a 1 to 1 mapping from the UI to the database tables, there is little need for encapsulated objects. However as the application gets more logic, be sure to place this logic in encapsulated objects. Avoiding the Hybrid trap, this should help make the application more maintainable.

My advice

Keep your data(from a database or the user etc.) in Data Structures and your logic(anything like if/for/while etc) in Encapsulated Classes. The encapsulated Objects are free to use Data Structures directly or contain them as state. Just like adding string, int, bool and any other simple type feels natural, adding a custom made Data Structure as state should also be natural.

What Goes In Must Come Out

2008-09-09T23:07:00.001+02:00

IO, logic and data

In essence all computer systems are about I/O, data is send against the system and data is sent back.
In the simplest form it looks like this, note that there is no logic involved. Raw data is just passed as input, to change the data and then the changed data is sent back out.

I would guess that most systems in the world takes this approach, think about the countless spreadsheets laying around with absolutely no logic.

When logic is introduced I usually see the following layer of logic introduced.

The logic now has 2 distinct responsibilities.

All input is validated against the business rules, before changes to the data.
Exposure and transformation of the data to a specific client.

These 2 responsibilities are very different. When the data store is optimized for one, the other suffers. If a relational database is used as data store, the data schema can be normalize to make input commands more effective, and help keep our data consistent. But a normalized data store is not good for the output to the client, because it often need data from multiple tables. Either a lot of joins are used, or when using Active Record, DDD entities or the like, whole table rows are loaded into ram, even if only a few fields are needed from each table.
De-normalize the data schema on the other hand, makes input commands tricky because multiple versions of the truth can be scattered all over the database. This quickly ends up with inconsistent data.

The logic also suffers from a asymmetry in how code is designed. Business rules are usually object centric, while client transformation is data centric. This creates an object <-> data structure asymmetry, where the code is neither good object or good data structures. Objects want to encapsulate data and operate on it, while data structures want to expose data and want others to operate on it. Both are needed and have valid reasons to be in a system, objects are good at adding data without breaking their contract, while data structures are good at adding new methods without breaking their contract. But hybrids break their contract, when both data and methods are added, so they are good at neither.

Introducing multiple models

A possible solution could look like this.

The logic is split up, business rules are applied before the input is saved to the business data model, and an ETL is used to transform the business data to a specific data model. There could be multiple output specific models (for views, reports and service results) and multiple clients(Web app, Service etc.) using them.

So en essence there is a model with logic optimized for changes, and a model with transformations optimized for reads. The general performance of the system should be better, at the cost of using more disk space.

If you think about it, data is transformed to other models already. BI transforms the data into aggregate structures and Full Text Search transforms data into indexes. The new part is to transform relational data optimized for change, into relational data optimized for reads. Also this has radical influence on the code design, because the business rules no longer get polluted with data transformation and data structure behavior.

How to create fully encapsulated and simple Domain Models

2008-09-06T23:22:00.001+02:00

Background

Udi wrote about this topic, but I never really liked the solution. To me it seemed complex and over architected, even the solutions from the commenter's where surprisingly complex (No disrespect for Udi or any of the commenter's intended).

Business Context

The core domain revolves around renting video games. I am working on a new feature to allow customers to trade in old video games. Customers can trade in multiple games at a time so we have a TradeInCart entity that works similar to most shopping carts that everybody is familiar with. However there are several rules that limit the items that can be placed into the TradeInCart. The core rules are:

1. Only 3 games of the same title can be added to the cart.
2. The total number of items in the cart cannot exceed 10.
3. No games can be added to the cart that the customer had previously reported lost with regards to their rental membership.
a. If an attempt is made to add a previously reported lost game, then we need to log a BadQueueStatusAddAttempt to the persistence store.

A solution

The service layer service looks like this.

        1: using System.Transactions;

       2:  

       3: namespace VideoGameRenting

       4: {

       5:     public class TradeInService

       6:     {

       7:         private readonly Repository _repository;

       8:  

       9:         private GameDTO _gameDTO;

        private TradeInCartDTO _tradeInCartDTO;

        private LineItemDTO[] _lineItemDTOS;

        private GameReportedLostDTO _gameReportedLostDTO;

        private TradeInCart _tradeInCart;

  

        public TradeInService(Repository repository)

        {

            _repository = repository;

        }

  

        //This is an outer boundry of the system.

        //The operation below is a complete operation aganst the system.

        public void AddGameToCart(int gameId, int tradeInCartId)

        {

            using(TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew))

            {

                LoadAllDataNeeded(gameId, tradeInCartId);

  

                ApplyBusinessRulesToData();

  

                SaveDataIfNeeded();

   

                scope.Complete();

            }

  

            //If it is a GUI application, "redirect" to a method that renders a view with data

        }

  

        private void LoadAllDataNeeded(int gameId, int tradeInCartId)

        {

            _gameDTO = _repository.Find<GameDTO>(gameId);

            _tradeInCartDTO = _repository.Find<TradeInCartDTO>(tradeInCartId);

            _lineItemDTOS = _repository.Query<LineItemDTO>(x => x.TradeInCartId == _tradeInCartDTO.Id);

            _gameReportedLostDTO = _repository.FindBy<GameReportedLostDTO>(

                x => x.Customer == _tradeInCartDTO.CustomerId && x.GameId == _gameDTO.Id);

        }

  

        private void ApplyBusinessRulesToData()

        {

            _tradeInCart = new TradeInCart(_tradeInCartDTO, _lineItemDTOS);

            _tradeInCart.AttemptToAddGameAndLogAnyAbuse(_gameDTO, _gameReportedLostDTO);

        }

  

        private void SaveDataIfNeeded()

        {

            _repository.Save(_tradeInCartDTO);

            foreach (LineItemDTO line in _tradeInCart.GetItems())

            {

                _repository.Save(line);

            }

            foreach (AbuseLogEntryDTO abuseLogEntry in _tradeInCart.GetAbuseLogEntries())

            {

                _repository.Save(abuseLogEntry);

            }

        }

    }

}

Basically I treat data as pure data structures(DTO) and I have objects that operate on the data.

The TradeInCart DDD Entity looks like this, it is the agregate root for TradeInCartDTO, LinetemDTO and AbuseLogEntryDTO.

       1: using System;

       2: using System.Collections.Generic;

       3:  

       4: namespace VideoGameRenting

       5: {

       6:     public class TradeInCart

       7:     {

       8:         private readonly TradeInCartDTO _tradeInCartDTO;

       9:         private readonly List<LineItemDTO> _items;

        private readonly List<AbuseLogEntryDTO> _abuseLogEntries;

  

        public TradeInCart(TradeInCartDTO tradeInCartDTO, IEnumerable<LineItemDTO> items)

        {

            _tradeInCartDTO = tradeInCartDTO;

            _items = new List<LineItemDTO>(items);

            _abuseLogEntries = new List<AbuseLogEntryDTO>();

        }

  

        public IEnumerable<LineItemDTO> GetItems()

        {

            return _items.AsReadOnly();

        }

  

        public IEnumerable<AbuseLogEntryDTO> GetAbuseLogEntries()

        {

            return _abuseLogEntries.AsReadOnly();

        }

  

        public void AttemptToAddGameAndLogAnyAbuse(GameDTO game, GameReportedLostDTO gameReportedLost)

        {

            if (GameHasBeenReportedLost(gameReportedLost))

            {

                LogAbuse();

                return;

            }

            if (GameCannotBeAddedToCart(game)) return;

  

            AddGameToNewLineItem(game);

        }

  

        private bool GameHasBeenReportedLost(GameReportedLostDTO gameReportedLost)

        {

            return gameReportedLost != null;

        }

  

        private void LogAbuse()

        {

            AbuseLogEntryDTO abuseLogEntry = new AbuseLogEntryDTO();

            abuseLogEntry.Message = "BadQueueStatusAddAttempt";

            abuseLogEntry.TimeStamp = DateTime.Now;

            _abuseLogEntries.Add(abuseLogEntry);

        }

  

        private bool GameCannotBeAddedToCart(GameDTO game)

        {

            return _items.Count > 10 || CountGamesWithSameTitle(game.Id) > 3;

        }

  

        private void AddGameToNewLineItem(GameDTO game)

        {

            LineItemDTO lineItemDTO = new LineItemDTO();

            lineItemDTO.GameId = game.Id;

            lineItemDTO.TradeInCartId = _tradeInCartDTO.Id;

            _items.Add(lineItemDTO);

        }

  

        private int CountGamesWithSameTitle(int gameId)

        {

            int gameCount = 0;

            foreach (LineItemDTO line in _items)

            {

                if(line.GameId == gameId)

                {

                    gameCount++;

                }

            }

            return gameCount;

        }

  

  

    }

}

The full source code is in my trunk.

Conclusion

I think my solution is simpler and easier to understand. I think it communicates very well.

I am actually in doubt... Do I need a AddToCartAttempt class, with GameDTO and GameReportedLostDTO as fields and the appropriate logic? Then I would not need to pass around parameters in TradeInCart's GameHasBeenReportedLost, GameCannotBeAddedToCart and AddGameToNewLineItem

Error creating window handle.

2008-08-21T21:00:00.001+02:00

I have been chasing a bug in a VB.NET Windows Forms application today. The error log was filled with Win32Exception Error creating window handle. Digging in the usage log I loacted the following code.

        1: Public Sub DataBindRadioButton(ByVal radioButton As Windows.Forms.RadioButton, ByVal radioButtonTrueValue As Object, ByVal radioButtonFalseValue As Object, ByRef dataSource As Object, ByVal dataMember As String)

       2:      Dim propertyHolder As New propertyHolder(radioButton, radioButtonTrueValue, radioButtonFalseValue, dataSource, dataMember)

       3:      propertyHolder.Name = radioButton.Name & "propertyHolder"

       4:  

       5:      For Each control As control In radioButton.FindForm.Controls

       6:          If control.Name = propertyHolder.Name Then

       7:              radioButton.FindForm.Controls.Remove(control)

       8:              Exit For

       9:          End If

      10:      Next

      11:  

      12:      radioButton.FindForm.Controls.Add(propertyHolder)

      13:  End Sub

propertyHolder is a Control.

So whats the memory leak here?

radioButton.FindForm.Controls.Remove(control), since we remove the control from the container(Form). We now inherit the responsibility to clean up.

So a non leaking version would be.

       1: Public Sub DataBindRadioButton(ByVal radioButton As Windows.Forms.RadioButton, ByVal radioButtonTrueValue As Object, ByVal radioButtonFalseValue As Object, ByRef dataSource As Object, ByVal dataMember As String)

       2:       Dim propertyHolder As New propertyHolder(radioButton, radioButtonTrueValue, radioButtonFalseValue, dataSource, dataMember)

       3:       propertyHolder.Name = radioButton.Name & "propertyHolder"

       4:  

       5:       For Each control As control In radioButton.FindForm.Controls

       6:           If control.Name = propertyHolder.Name Then

       7:               radioButton.FindForm.Controls.Remove(control)

       8:       control.Dispose()

       9:               Exit For

      10:           End If

      11:       Next

      12:  

      13:       radioButton.FindForm.Controls.Add(propertyHolder)

      14:   End Sub

So remember to dispose a control when you dynamically remove it from its container.

The application also had a while loop that in some conditions never exited, and called the above method.

Delegates - Late Bound VS Expression

2008-08-21T09:51:00.001+02:00

With the new Expressions .NET 3.5, is there any reason to use a late bound delegate?
Lets put it to the test.

Milliseconds/number of iterations. (less is better.)

Expressions have almost constant time, while LateBound suffers under many iterations.

And the test code.

        1: using System;

       2: using System.Diagnostics;

       3: using System.Linq.Expressions;

       4: using System.Reflection;

       5: using NUnit.Framework;

       6:  

       7: namespace Sample

       8: {

       9:     [TestFixture]

    public class LateBoundVSExpressionCall

    {

        [Test]

        public void TestLateBound()

        {

            object instance = new object();

            Stopwatch stopwatch = Stopwatch.StartNew();

            MethodInfo methodInfo = typeof(object).GetMethod("ToString");

            for (int i = 0; i < 1000000; i++)

            {

                methodInfo.Invoke(instance, null);

            }

            stopwatch.Stop();

            Trace.WriteLine("LateBound: " + stopwatch.ElapsedMilliseconds + " milliseconds");

        }

  

        [Test]

        public void TestExpression()

        {

            object instance = new object();

            Stopwatch stopwatch = Stopwatch.StartNew();

            MethodInfo methodInfo = typeof(object).GetMethod("ToString");

            ConstantExpression constantExpression = Expression.Constant(instance);

            MethodCallExpression methodCallExpression = Expression.Call(constantExpression, methodInfo);

            Func toString = Expression.Lambda>(methodCallExpression).Compile();

            for (int i = 0; i < 1000000; i++)

            {

                toString();

            }

            stopwatch.Stop();

            Trace.WriteLine("ExpressionCall: " + stopwatch.ElapsedMilliseconds + " milliseconds");

        }

    }

}

So with just a few extra calls to Expression, we get run time il, that performs a lot better.

Onion Architecture in Praxis

2008-08-13T23:22:00.001+02:00

What is it?

Jeffrey Palermo has coined the pattern onion architecture, so what is it?

Actually it is "just" my default architecture, and has been for some time now. The ideas behind are not new, and it is related to other principles and patterns. Never the less I really like having a name for it, so we have a common understanding of it.

How I use Assemblies and Namespaces

First of I am a bit of a namespace fascist, every namespace in an assembly starts with the root name(The root name is the assembly name part before the first ".").

Assembly: MyDomainCore.dll

Namespaces would be something like: MyDomainCore, MyDomainCore.Something, MyDomainCore.SomethingElse etc.

Also I use folders for namespaces, so that files are located in a folder path that matches the namespace path.

How I use Namespace References

Any namespace can reference another namespace as long as it has another root name.

MyDomainTesting -> MyDomainCore (OK)

Any namespace can reference another namespace with the same root name, as long as the namespace is closer to the root name.

MyDomainCore.Infrastructure -> MyDomainCore (OK)

MyDomainCore -> MyDomainCore.Infrastructure (Not OK)

Visual Studio Solutions, Projects, and folder structure

MyDomain (Solution)

MyDomainCore (Project)

Infrastructure (Folder)

Bootstrapping (Folder)

MyDomainApplication (Project) [Reference to MyDomainCore]

MyDomainTesting (Project) [Reference to MyDomainCore and MyDomainApplication]

This is the initial setup, from here it can grow to more complex scenarios, like multiple Infrastructure implementations or multiple applications (web, rich client, web service etc.).

What goes where?

MyDomainCore should only be POCO classes as a model and should not contain references to System.IO, NHibernate, Web or anything other that is remotely infrastructure related. It provides abstractions (abstract classes or interfaces) for Business Services used by the core(think SendEmailService and Repository). Applications Services group together the model for a given user scenario.

MyDomainCore.Infrastructure implements the business services of MyDomainCore. SendEmailService could be implemented as an SmtpSendEmailService. Repository could be implemented as a NHibernateRepository etc. Most Services will also have a stub implementation, like StubRepository and StubSendEmailService.
Classes in MyDomainCore.Infrastructure should in general not use any classes from this namespace, and should be as light as possible in.

MyDomainCore.Infrastructure.Bootstrapping wires the MyDomainCore and MyDomainCore.Infrastructure together, usually with an IOC Container. It can be configured for stub or normal usage.
It is placed in it own namespace so that I cant be referenced from the same name root.

MyDomainApplication when it is a GUI, it parses the raw user input and relays the request to the Application Services, for validation and processing. Its main purpose is to render the UI and to receive user input.

MyDomainTesting contains all automated tests, unit, integration - or as I usually categorize them Fast and Slow.

How to configure NHibernateFacility in code

2008-08-11T08:56:00.001+02:00

I haven't started using Burrow yet, so I still depend on the NHibernateFacility in the castle stack. But I really don't like to pay my angle bracket tax, so I want to configure it in code.

        1: private void CreateItem(MutableConfiguration parent, string key, string value)

       2: {

       3:   MutableConfiguration item = parent.CreateChild("item");

       4:   item.Attributes.Add("key", key);

       5:   item.Value = value;

       6: }

       7:  

       8: public void Init()

       9: {

  MutableConfiguration facility = new MutableConfiguration("facility");

  facility.Attributes.Add("id", "nhibernatefacility");

  facility.Attributes.Add("isWeb", "isWeb");

  facility.Attributes.Add("defaultFlushMode", "Commit");

  facility.Attributes.Add("type", "Castle.Facilities.NHibernateIntegration.NHibernateFacility, Castle.Facilities.NHibernateIntegration");

  MutableConfiguration factory = facility.CreateChild("factory");

  factory.Attributes.Add("id", "nhibernate.factory");

  MutableConfiguration settings = factory.CreateChild("settings");

  

  CreateItem(settings, "connection.provider", "NHibernate.Connection.DriverConnectionProvider");

  CreateItem(settings, "connection.driver_class", "NHibernate.Driver.SqlClientDriver");

  CreateItem(settings, "connection.connection_string", "Data Source=SERVER;Initial Catalog=DATABASE;Integrated Security=SSPI");

  CreateItem(settings, "dialect", "NHibernate.Dialect.MsSql2005Dialect");

  CreateItem(settings, "show_sql", "true");

  

  MutableConfiguration assemblies = factory.CreateChild("assemblies");

  MutableConfiguration assembly = assemblies.CreateChild("assembly");

  assembly.Value = "HomeForretningCore";

  

  IWindsorContainer container = new WindsorContainer(); 

  container.Kernel.ConfigurationStore.AddFacilityConfiguration("nHibernateFacility", facility);

  container.AddFacility("nHibernateFacility");

}

ReSharper 4.0 Keymap

2008-07-18T21:33:00.001+02:00

I keep forgetting where I find this pdf, so this is for future reference.

http://www.jetbrains.com/resharper/docs/ReSharper40DefaultKeymap2.pdf

Learning by Sample: Monorail and AspView

2008-07-18T21:18:00.001+02:00

I really like the AspView View engine for Monorail, not that the other view engines are bad - but...
Intellisense and a familiar syntax just does it for me, however the documentation is lacking behind.

So I have converted the monorail getting started sample application to use aspview. Also it is now a Visual Studio 2008 solution.
I have added a SQLCE sql server as a database backend, and all dependencies are also included. So you can get started by just downloading, no other software has to be installed. I am assuming that you are using ReSharper, if not do you self a favor and install it now.

It is in my trunk, and there is a zip file for download.

Using the sample

After downloading and unzipping the file, open src\GettingStartedSample.sln.
Do a F5 and the Home controller should show with the Index action (http://localhost:54321/home/index.rails).
In the HomeController class there are two other actions (http://localhost:54321/home/erroneousaction.rails and http://localhost:54321/home/datatotheview.rails), you can set a break point before browsing to the urls.
Next try out the ContactController (http://localhost:54321/contact/contactform.rails), again a break point can be set.
SupplierController is a Scaffolding controller so no break points can be set, but try to create a supplier(http://localhost:54321/supplier/list.rails). The SQLCE database in "C:\temp.sdf" contains the data.
Finally nagivate to (http://localhost:54321/product/list.rails), and create and edit a product. Again the data goes to "c:\temp.sdf"

All logging from nhibernate is logged by the trace writer, and should be visible in the Output/Debug window in VS.

Version: Both Monorail and AspView are trunk versions (Rev. 5227).

The Seductive Visual Designer

2008-07-15T00:21:00.001+02:00

An effective tool in the toolbox

Creating a user interface with a Visual Designer, makes a lot of sense due to the WYSIWYG experience. Shortening the feedback loop from editing content, to verification of the result. Prototyping, demoing and trying out different solutions, are the key strengths of the Visual Designer.

Moving towards a GUI-guide

Every tool has its shortcomings, no matter how good it is. Due to the flexibility of the Visual Designer, controls can be placed anywhere on the view, and size, color almost anything can be changed. So in order to create a uniform user experience across multiple views, a GUI-guide is often created.

The GUI-guide is usually written in Word, with examples and descriptions of how to layout and compose the GUI. So all GUI work is a manual merge process, of the Visual Designer and the GUI-guide.

Alternatives

Letting go of the Visual Designer sounds counter productive to most developers, but as with most tools there is a golden rule of when (not) to use it.

"It depends"

Its hard, and takes years of experience. Using any tool in the toolbox too much or too little, could have severe impact on productivity, maintainability and pretty much any other aspect of development.

When I first learned about database normalization, I though "what is it good for?". When I finally figured out why I should use it, I started to use it everywhere. Temporal data, auditing, you name it - everything was normalized. It took me years of experience, trying different levels of normalization before I was able to do it properly.

So instead of blindly using the tool, we should ask.

"Is this tool optimal for the task at hand, are there any alternatives?"

So if we need a GUI where there are multiple variations of the same theme, think "OrderDetailsView", "CustomerDetailsView", etc. Is the Visual Designer optimal for creating views, with components arranged after certain rules?

I don't think so, the Visual Designer exposes all behavior of all controls, and have no mechanism that allow rules to be applied across multiple views. You might think that User Controls fit the bill, but there is a big drawback with User Controls - They don't stack or combine! In my experience User Controls offer the worst form of reusability, I have ever encountered (An alternative could be a light weight micro controller).

So the Visual Designer exposes too much flexibility, and not enough automatability(is that a word?). I have seen dozens and dozens of views where tab order is not set correctly. Why, because it is a manual process to apply it. I have seen endless hours wasted because some control, was 1-10 pixels out of alignment or buttons was glued to the top and not the bottom of the view. Clearly the Visual Designer is not ideal for solving the problem at hand.

Automation

The art of codifying rules and processes, in essence what software developers do. We usually automate business rules for customers, but some times it is useful to automate our own business. Build scripts and Continuous Integration are good examples, but the possibilities are nearly endless. Figure out the most repetitive tasks you do, and automate them!

The framework trap

I often fall in this one, when automating some of my tedious tasks. I start to over design the automation, taken into account requirements that does not exist yet. Frameworks should not be build up front, but rather harvested from several projects.

Example

Suppose we have the following GUI-guides, for details views.

All fields should have a label with a description.
All fields should have a editing control. (textbox for text and numbers, checkbox for boolean and combobox for enums).
All fields should be in a single column with label first and then the textbox next to it.
Fields have a "xxx2" field, should be align next to each other in 2 columns. (name and name2 should be in a single row in 2 columns).
Tab order goes from left to right and top to down. (name->name2->address->address2->country->email).

In the real world, the list would go on and on.

In Windows Forms we could manually create every details view, or we could create a details view builder.

        1: using System;

       2: using System.Collections.Generic;

       3: using System.Windows.Forms;

       4:  

       5: namespace NonVisualDesigner

       6: {

       7:     public class DetailsViewBuilder

       8:     {

       9:         private readonly List _detailsViewFieldModels;

  

        public DetailsViewBuilder()

        {

            _detailsViewFieldModels = new List();

        }

  

        public DetailsViewBuilder AddField()

        {

            _detailsViewFieldModels.Add(new DetailsViewFieldModel());

            return this;

        }

  

        public DetailsViewBuilder WithName(string name)

        {

            _detailsViewFieldModels[_detailsViewFieldModels.Count - 1].Name = name;

            return this;

        }

  

        public DetailsViewBuilder WithType(Type type)

        {

            _detailsViewFieldModels[_detailsViewFieldModels.Count - 1].Type = type;

            return this;

        }

  

        public Panel Build()

        {

            Panel panel = new Panel();

  

            int tabOrderIndex = 0;

            int rowIndex = 0;

            DetailsViewFieldModel previousDetailsViewFieldModel = null;

            

            TableLayoutPanel tableLayoutPanel = new TableLayoutPanel();

            foreach (DetailsViewFieldModel detailsViewFieldModel in _detailsViewFieldModels)

            {

                Label label = new Label();

                label.Name = detailsViewFieldModel.Name + "Label";

                label.Text = detailsViewFieldModel.Name;

                Control editingControl;

                if(detailsViewFieldModel.Type == typeof(bool))

                {

                    editingControl = new CheckBox();

                }

                else if (detailsViewFieldModel.Type.IsEnum)

                {

                    editingControl = new ComboBox();

                }

                else

                {

                    editingControl = new TextBox();

                }

                editingControl.Name = detailsViewFieldModel.Name + editingControl.GetType().Name;

                editingControl.TabIndex = tabOrderIndex;

  

                int labelColumnIndex = 0;

                int editingControlColumnIndex = 1;

  

                if (previousDetailsViewFieldModel != null && previousDetailsViewFieldModel.Name + "2" == detailsViewFieldModel.Name)

                {

                    labelColumnIndex = labelColumnIndex + 2;

                    editingControlColumnIndex = editingControlColumnIndex + 2;

                    rowIndex--;

                }

  

                tableLayoutPanel.Controls.Add(label, labelColumnIndex, rowIndex);

                tableLayoutPanel.Controls.Add(editingControl, editingControlColumnIndex, rowIndex);

  

                previousDetailsViewFieldModel = detailsViewFieldModel;

  

                rowIndex++;

                tabOrderIndex++;

            }

            tableLayoutPanel.Dock = DockStyle.Fill;

            panel.Controls.Add(tableLayoutPanel);

            return panel;

        }

    }

  

    public class DetailsViewFieldModel

    {

        public string Name;

        public Type Type;

    }

}

A customer details view could then be created like this.

       1: using System;

       2: using System.Collections.Generic;

       3: using System.Windows.Forms;

       4:  

       5: namespace NonVisualDesigner

       6: {

       7:     public class CustomerDetailsView : Form

       8:     {

       9:         public CustomerDetailsView()

        {

            Panel panel = new DetailsViewBuilder()

                .AddField().WithName("Name").WithType(typeof (string))

                .AddField().WithName("Name2").WithType(typeof(string))

                .AddField().WithName("Address").WithType(typeof(string))

                .AddField().WithName("Address2").WithType(typeof(string))

                .AddField().WithName("Phone").WithType(typeof(string))

                .AddField().WithName("Fax").WithType(typeof(string))

                .AddField().WithName("Email").WithType(typeof(string))

                .AddField().WithName("Gender").WithType(typeof(Gender))

                .AddField().WithName("Active").WithType(typeof(bool))

                .Build();

            panel.Dock = DockStyle.Fill;

            Controls.Add(panel);

        }

    }

  

    public enum Gender

    {

        Male,

        Female

    }

}

It looks like this.

Conclusion

Carefully consider if a tool is appropriate to solve a problem, always try to find alternatives. Automate guidelines and rules written in non-executable form. Save your self from the pain of manual, repetitive and error prone tasks.

Visual Studio #regions are a code smell

2008-07-10T12:28:00.001+02:00

Why do #regions exists?

My best guess is that back in the the good old .NET 1.0 and 1.1 days, before partial classes, MS needed a way to visually remove, all the noise the auto generated Windows Forms code made. It kind a made sense, because you don't need to understand the auto generated code, you can just open the form in design view.

Why use #regions?

Often I see #regions used to group different code artifacts, like "Fields", "Constructors", "Properties", "Events", "Methods" etc. When the class gets big, navigating to an event handler becomes as easy as:

Collapse all "regions.
Expand the "Events" region
Start to scroll for the event handler.

That is faster than scrolling through all the code in a big file.

Do we need #regions?

As with most other "coding tools", #regions tackle complexity. A class with several thousands lines of code, can be visually laid out in 20 lines or so. If you have a class with many, many lines of code, #regions do offer an advantage over normal layout. The #regions don't take up to much space compared to the total number of lines, so it is easy to ignore them if not needed. But if the #regions makes sense, they can be used to slice the lines into categories.

An obvious problem with #regions

Like any other categorization it falls apart if there are multiple dimensions. What if we are looking for an event handler, but the #regions define business rules?

My wife categorizes our pictures by month. She creates a folder with a "Month Year" name, and places pictures taken that month there. Every now and then we need to find a picture of someone, it could be my son. The problem with the "Month Year" categorization is that is does not help, we need a "who is on the picture" categorization.

If google created a fixed categorization, it would be much harder to find anything. Because the same topic could be categorized with many dimensions.

A not so obvious code smell lurking behind the #regions

So if #regions are good at categorizing many lines of code, why is it a code smell to use them?

This leads to another question.

>Why do we need to categorize?

The answer is easy.

>Because of the many lines of code.

And finally the question we should be asking

>Why do we allow many lines of code in a single file?

A single class with many lines of code, is called a god object. It is a well known anti-pattern, and will kill maintenance. I will not in depth with the god obejct anti-pattern, but it is well described elsewhere.

Moving away from the god class

Is it possible? It most certainly is...

This form god'ified could look like this in code.

        1: using System;

       2: using System.Windows.Forms;

       3:  

       4: namespace GodClass

       5: {

       6:     public partial class CustomerDetails : Form

       7:     {

       8:         public CustomerDetails()

       9:         {

            InitializeComponent();

        }

  

        #region Events

        private void CustomerDetails_Shown(object sender, EventArgs e)

        {

            DefaultFocus(_nameTextBox);

        }

  

        private void _saveButton_Click(object sender, EventArgs e)

        {

            FocusAll(_nameTextBox, _name2TextBox, _addressTextBox, _address2TextBox, _phoneTextBox, _emailTextBox);

            //Save the object

        }

  

        private void _nameTextBox_TextChanged(object sender, EventArgs e)

        {

            TextBoxRequired(_nameTextBox);

        }

  

        private void _name2TextBox_TextChanged(object sender, EventArgs e)

        {

            MoveTextToTextBoxIfTextIsEmpty(_nameTextBox, _name2TextBox);

        }

  

        private void _addressTextBox_TextChanged(object sender, EventArgs e)

        {

            TextBoxRequired(_addressTextBox);

        }

  

        private void _address2TextBox_TextChanged(object sender, EventArgs e)

        {

            MoveTextToTextBoxIfTextIsEmpty(_nameTextBox, _name2TextBox);

        }

  

        private void _phoneTextBox_TextChanged(object sender, EventArgs e)

        {

            TextBoxRequired(_phoneTextBox);

        }

  

        private void _emailTextBox_TextChanged(object sender, EventArgs e)

        {

            TextBoxRequired(_emailTextBox);

        }

  

        #endregion

  

        #region Procedures

        public void DefaultFocus(Control control)

        {

            control.Focus();

        }

  

        public void TextBoxRequired(TextBox textBox)

        {

            if (string.IsNullOrEmpty(textBox.Text))

            {

                textBox.Focus();

            }

        }

  

        public void FocusAll(params Control[] controlsToFocus)

        {

            foreach (Control controlToFocus in controlsToFocus)

            {

                controlToFocus.Focus();

            }

        }

  

        public void MoveTextToTextBoxIfTextIsEmpty(TextBox firstTextBox, TextBox secondTextBox)

        {

            if (string.IsNullOrEmpty(firstTextBox.Text))

            {

                firstTextBox.Text = secondTextBox.Text;

                secondTextBox.Text = "";

            }

        }

        #endregion

    }

}

In addition, the tab order is set in the visual designer.

The problem with this sample is ofcourse, it is not several thousans of lines.

If we wanted to de-god'ify the class it could look like this.

       1: using System.Windows.Forms;

       2:  

       3: namespace NonGodClass

       4: {

       5:     public partial class CustomerDetails : Form

       6:     {

       7:         public CustomerDetails()

       8:         {

       9:             InitializeComponent();

      10:             new DefaultFocus(this, _nameTextBox);

      11:             new TextBoxRequiredMicroController(_nameTextBox);

      12:             new TextBoxRequiredMicroController(_addressTextBox);

      13:             new TextBoxRequiredMicroController(_emailTextBox);

      14:             new TextBoxRequiredMicroController(_phoneTextBox);

      15:             new ValidateFormMicroController(_saveButton, _nameTextBox, _name2TextBox, _addressTextBox, _address2TextBox,

      16:                                             _phoneTextBox, _emailTextBox);

      17:             new MoveTextToTextBoxIfTextIsEmptyMicroController(_nameTextBox, _name2TextBox);

      18:             new MoveTextToTextBoxIfTextIsEmptyMicroController(_addressTextBox, _address2TextBox);

      19:         }

      20:     }

      21: }

Things to notice, there are zero regions!

The microcontrollers look like this.

       1: using System.Windows.Forms;

       2:  

       3: namespace NonGodClass

       4: {

       5:     public class TextBoxRequiredMicroController

       6:     {

       7:         private readonly TextBox _textBox;

       8:  

       9:         public TextBoxRequiredMicroController(TextBox textBox)

        {

            _textBox = textBox;

            _textBox.TextChanged += ((sender, e) => FocusIfEmpty());

        }

  

        private void FocusIfEmpty()

        {

            if (string.IsNullOrEmpty(_textBox.Text))

            {

                _textBox.Focus();

            }

        }

    }

  

    public class ValidateFormMicroController

    {

        private readonly Button _button;

        private readonly Control[] _controlsToFocus;

  

        public ValidateFormMicroController(Button button, params Control[] controlsToFocus)

        {

            _button = button;

            _controlsToFocus = controlsToFocus;

            _button.Click += ((sender, e) => FocusAll());

        }

  

        private void FocusAll()

        {

            foreach (Control controlToFocus in _controlsToFocus)

            {

                controlToFocus.Focus();

            }

        }

    }

  

    public class DefaultFocus

    {

        private readonly Form _form;

        private readonly Control _defaultControlToFocus;

  

        public DefaultFocus(Form form, Control defaultControlToFocus)

        {

            _form = form;

            _defaultControlToFocus = defaultControlToFocus;

            _form.Shown += ((sender, e) => FocusDefaultControl());

        }

  

        public void FocusDefaultControl()

        {

            _defaultControlToFocus.Focus();

        }

    }

  

    public class MoveTextToTextBoxIfTextIsEmptyMicroController

    {

        private readonly TextBox _firstTextBox;

        private readonly TextBox _secondTextBox;

  

        public MoveTextToTextBoxIfTextIsEmptyMicroController(TextBox firstTextBox, TextBox secondTextBox)

        {

            _firstTextBox = firstTextBox;

            _secondTextBox = secondTextBox;

            _secondTextBox.TextChanged += ((sender, e) => MoveText());

        }

  

        private void MoveText()

        {

            if (string.IsNullOrEmpty(_firstTextBox.Text))

            {

                _firstTextBox.Text = _secondTextBox.Text;

                _secondTextBox.Text = "";

            }

        }

    }

}

Even more these MicroControllers are reusable in the next form!

Things normally done(or forgotten) in the visual designer can also be micro controlled.
Tab order is as easy as.

       1: namespace NonGodClass

       2: {

       3:     public class TabOrderMicroController

       4:     {

       5:         public TabOrderMicroController(params Control[] controls)

       6:         {

       7:             for (int i = 0; i < controls.Length; i++)

       8:             {

       9:                 controls[i].TabIndex = i;

      10:             }

      11:         }

      12:     }

      13: }

Conclusion

If you use #regions, you might need to apply separation of concerns. This forces your code to be more readable, although it creates a navigation issue, when having lots of classes.

Creating an Active Directory Authentication Service

2008-07-10T08:18:00.000+02:00

This should be as easy as a one liner, and guess what - it is :-)

Following the Dependency Inversion Principle, we define a high level policy class - well actually it is an interface.

public interface AuthenticationService
{
    bool Authenticate(string username, string password);
}

This hides the implementation detail from consumers.

Next we need to implement the actual ActiveDirectoryAutenticationService

using System.DirectoryServices.AccountManagement;

public class ActiveDirectoryAuthenticationService : AuthenticationService
{
    private readonly PrincipalContext _principalContext;

    public ActiveDirectoryAuthenticationService(PrincipalContext principalContext)
    {
        _principalContext = principalContext;
    }

    public bool Authenticate(string username, string password)
    {
        return _principalContext.ValidateCredentials(username, password, ContextOptions.Negotiate); 
    }
}

If you are using an IOC Container, like Windsor from the Castle Project, the configuration looks the this.
This should go in your main or global.asax, depending on the project type.

using System
using System.DirectoryServices.AccountManagement;

PrincipalContext principalContext = new PrincipalContext(ContextType.Domain, Environment.UserDomainName)
IWindsorContainer container = new new WindsorContainer();
container.Register(
                    Component.For<PrincipalContext>().Instance(principalContext),
                    Component.For<AuthenticdationService>().ImplementedBy<ActiveDirectoryAuthenticationService>()
                  );

Now you are ready to use the AuthenticationService.

public class Consumer
{
    private readonly AuthenticationService _authenticationService;

    public Consumer(AuthenticationService authenticationService)
    {
        _authenticationService = authenticationService;
    }

    public void DoSomethingWhereAuthenticationIsNeeded(string username, string password)
    {
        if (!_authenticationService.Authenticate(username, password)) throw new SecurityException("Invalid username or password.");
    }
}

The end result is a code with low coupling, with an abstraction for a key business concern.

Doing BDD, with Rhino Mocks AAA syntax

2008-07-09T00:17:00.000+02:00

Ayende proposed a new AAA syntax in Rhino Mocks. I was wondering how it mixed with BDD.

Given this.

using System.Security;

public interface EmailService
{
    void Send(string message);
}

public interface AuthenticationService
{
    bool Authenticate(string username, string password);
}

public class SecureVault
{
    private readonly AuthenticationService _authenticationService;
    private readonly EmailService _emailService;
    private readonly string _secret;

    public SecureVault(AuthenticationService authenticationService, EmailService emailService, string secret)
    {
        _authenticationService = authenticationService;
        _emailService = emailService;
        _secret = secret;
    }

    public string GetSecret(string username, string password)
    {
        if(_authenticationService.Authenticate(username, password))
        {
            _emailService.Send(username + " successfully authenticated, and grabbed secret.");
            return _secret;
        }
        else
        {
            throw new SecurityException("Access denied!");
        }
    }
}

Using a stub test double, the if/else branch can be tested. This is called state based testing.

using System.Security;
using NUnit.Framework;
using NUnit.Framework.SyntaxHelpers;
using Rhino.Mocks;

namespace Specs_for_SecureVault
{
    [TestFixture]
    public class When_getting_secret_with_successful_authentication
    {
        private string _secret;
        private EmailService _emailService;

        [SetUp]
        public void Init()
        {
            var authenticationService = MockRepository.GenerateStub<AuthenticationService>();
            _emailService = MockRepository.GenerateMock<EmailService>();
            authenticationService.Stub(x => x.Authenticate("mortenlyhr", "pass1234")).Return(true);
            var secureVault = new SecureVault(authenticationService, emailService, "mysecretvalue");
            _secret = secureVault.GetSecret("mortenlyhr", "pass1234");
        }

        [Test]
        public void Should_return_secret()
        {
            Assert.That(_secret, Is.EqualTo("mysecretvalue"));
        }
    }

    [TestFixture]
    public class When_getting_secret_with_failed_authentication
    {
        [Test]
        [ExpectedException(typeof(SecurityException))]
        public void Should_throw_exception()
        {
            var authenticationService = MockRepository.GenerateStub<AuthenticationService>();
            var emailService = MockRepository.GenerateMock<EmailService>();
            authenticationService.Stub(x => x.Authenticate("mortenlyhr", "pass1234")).Return(false);
            var secureVault = new SecureVault(authenticationService, emailService, "mysecretvalue");
            secureVault.GetSecret("mortenlyhr", "pass1234");
        }
    }
}

So far so good, but what about interaction based testing?

The EmailService is a prime candidate for this. We can write an additional test for this expectation, in the "When_getting_secret_with_successful_authentication".

[Test]
public void Should_send_an_email_containing_the_username()
{
    _emailService.AssertWasCalled(x=>x.Send(Arg<string>.Matches(s=>s.Contains("mortenlyhr"))));
}

I don't think it can be any clearer that this, thank you BDD and Rhino Mocks ;-) - A match from heaven...

I am starting to see a pattern where mocks are private fields, and stubs have their return values as private fields. This is a lot less noise than when I did TDD, where every dependency was a private field. So again BDD helps you write less brittle specifications.

Morten Lyhr

Reusability and discoverability of LINQ Queries

Windows Home Server 2011–How I use it

Embedding a TFS Build label in all assemblies

SQL Server Restore database with exclusive access

Effective Logging

Runtime diagnostics

Advantages

Messages

Logging as a global error handler

Logging is not error handling for the user

Decision Points

Things to log even though it is not a decision point

Assertion

Message Context

Conclusion

Recommended Reading

How to restore to another database with full text index

Optimizing build times

Background

Getting started

Analysis

Hardware

Conclusion

The beauty of 2 state enums

Using NHibernate and SQLite on x64

Data, objects and abstractions – Are there more to DIP?

Is there a simple alternative?

Combo box vs Button

What does the user want to do

Conclusion

Usability session with me from ANUG

Data Structures vs Encapsulation

Data Structure Objects

Encapsulated Objects

Hybrid Objects

Should all my classes be Encapsulated Objects?

My advice

What Goes In Must Come Out

IO, logic and data

Introducing multiple models

How to create fully encapsulated and simple Domain Models

Background

Business Context

A solution

Conclusion

Error creating window handle.

Delegates - Late Bound VS Expression

Onion Architecture in Praxis

What is it?

How I use Assemblies and Namespaces

How I use Namespace References

Visual Studio Solutions, Projects, and folder structure

What goes where?

How to configure NHibernateFacility in code

ReSharper 4.0 Keymap

Learning by Sample: Monorail and AspView

Using the sample

The Seductive Visual Designer

An effective tool in the toolbox

Moving towards a GUI-guide

Alternatives

Automation

The framework trap

Example

Conclusion

Visual Studio #regions are a code smell

Why do #regions exists?

Why use #regions?

Do we need #regions?

An obvious problem with #regions

A not so obvious code smell lurking behind the #regions

Moving away from the god class

Conclusion

Creating an Active Directory Authentication Service

Doing BDD, with Rhino Mocks AAA syntax