Usually.NET

"Better" ASP.NET MVC folder structure

2011-07-03T12:29:00+00:00

Default folder structure of ASP.NET MVC looks as follows:

PROJECT#1\ 
  Areas\ 
    AREA#1\
      Controllers\    // here are all controllers from this area
      Models\         // here are models for all controllers in this this area 
      Views\          // here are subfolders named after those controllers with their views
        CONTROLLER#1\
        CONTROLLER#2\
        ...
        Shared\       // here are views shared between controllers
    AREA#2\ 
      Controllers\ 
      Models\ 
      Views\ 
        ...
    ...
Content\              // here are all css and image files
Controllers\          // here are controllers not in any area 
Models\               // here are models for all those controllers 
Scripts\              // here are all javascript files
Views\                // here are subfolders named after those controllers with their views
  ...

Such folder structure is not very manageable when project grows. To work on single controller you need to look to many folders: Models, Views, Controllers, Content, Scripts. In every one of them there are plenty of files not connected with given controller.

Even bigger, but more subtle problem is with models: in this structure models can be easily shared between controllers, which look as good idea in theory, In practice every action method will need a bit different model, with one field more, one field less or with a bit different validation, so it’s easier to have separate model for every controller and every controller action and don’t try to share them. Similar situation is with sharing css or JavaScript files.

To alleviate those problems in my current project we came to such folder structure:

Areas\           // it would be nicer to name it Features, but ASP.NET MVC requires that name
  AREA#1\
    Views\            // this folder is here only to satisfy ASP.NET MVC
      CONTROLLER#1\   // directly in this folder are the views for given controller (*.cshtml)
        Code\         // here is controller class, all his models, mappings, etc.
        Content\      // here are css, js used by this controller views
          Images\     // here are images
      CONTROLLER#2\
        Code\
        Content\
          Images\
      ...
      Shared\         // here is stuff shared between controllers, usually it's empty
        Code\
        Content\
          Images\
  AREA#2\
    Views\
      CONTROLLER#3\

        ...
      ...
  ...
Views\                // this folder is here only to satisfy ASP.NET MVC
  CONTROLLER#4\

    ...
  ...
  Shared\             // directly in this folder are: layout page, error page, etc.
    Code\             // here is shared code, for example action filters
    Content\          // here is main css file and common JavaScript files
      Images\         // here are images used by main css files

Advantages:

while you work on single controller everything is in one folder: Areas\AREANAME\Views\CONTROLLERNAME.
there is a implicit discouragement to share models/css/js between controllers

Disadvantages:

nested folder structure, so it is harder to navigate between controlers

What do you thing about it?

Lesser known LINQ methods

2011-07-03T11:26:37+00:00

System.Linq.Enumerable is a static class with all LINQ extension methods. There are also there three methods that are not extension methods and are very usefull:

Enumerable.Empty<TResult>() – returns empty collection of elements of type TResult
Enumerable.Range(int start, int count) – returns collection of integers
Enumerable.Repeat<TResult>(TResult element, int count – returns collection of 'count' times repeated 'element'

Viewing big MSMQ messages

2011-07-02T23:23:00+00:00

MSMQ snap-in shows bodies of messages larger than about 550 characters in very unreadable form:

In my current project we use MSMQ and this is quite annoying. There are some other MSMQ viewers, but from the free ones none supports subqueues, which we also heavily use. Eventually I wrote very simple MSMQ viewer that doesn’t have such “bug”. Here is the code: https://github.com/whut/MsmqFastView

Cool git tricks

2011-06-21T19:37:00+00:00

Below list of git commands that I need to remember and use more often:

git stash – stash your changes (useful for example before rebase) without creating commit, they can later be reapplied with git stash pop
git config --global alias.rom "rebase origin/master" – example of creating alias for often used git command
git add --i FILE – with this you can commit parts of the file, and you can also do it graphically with git gui!
git config --global rebase.autosquash "true" – after that when you have commit with message "squash! SOME_OTHER_COMMIT_BEGINNING_OF_MESSAGE" will be automatically marked as squash with git rebase --interactive
git bisect – great tool to find first commit that introduces bug
git archive HEAD > sources.zip – create zip with all sources from given commit
git clone URL --depth 200 – with --depth you don’t have to clone whole repository history, but only some last commits
.git/info/exclude file – when you have something to ignore, but other team members don’t, so it shoudn’t go to .gitignore
git clean –d –f – delete all untracked files and folders
git rerere – not tested yet, but probably useful when you need to resolve again and again the same conflicts after reabase
git show-branch – show all your branches and some of the last commits in each
git log master.. – when your are on some branch shows only commits unique to this branch (and unique to master)
git log --grep "text to find in commit messages"
git show COMMIT – shows diff of given commit
git reflog – shows history of all operations (commits, rebases, stashes) you have made
git reset –hard HEAD@{1} – reset HEAD to previous state from reflog
exec in git rebase –interactive – to test all, all rebased commits, for example by running test suite
git config branch.master.mergeoptions "--ff-only" – disalow merge commits on master branch, this for example makes rebasing required

Git & Cygwin on Windows

2011-06-05T14:54:00+00:00

Git from MSYSGIT is very slow on my Windows 7 x64. Simple operation like “git status” can take more than 5 seconds. There is even a bug on their site for that, but sadly it’s closed, and MSYSGIT developers appear to not care about it... So I started using Git through Cygwin, which is much quicker here. And I have some tips to remember:

To start cmd.exe in new window from bash (without polluting it with cygwin environment variables, like PATH) create an alias in ~/.bashrc:
alias cmd2="cmd /C start /i \"%windir%\explorer.exe\" \"%windir%\system32\cmd.exe\""
To run gitk from MSYSGIT instead of Cygwin one:
alias gitk2="cmd /C gitk"
To have WinMergeas difftool create winmerge.sh file:
#!/bin/sh
"/cygdrive/c/Program Files/WinMerge/WinMergeU.exe" -e -dl "Base" -dr "Mine" `cygpath -aw $1` `cygpath -aw $2`

Make it executable by running

chmod u+x winmerge.sh

And configure it as difftool in git:

git config –global diff.tool "winmerge"

git config –global difftool.winmerge.cmd "winmerge.sh \$LOCAL \$REMOTE"

And put winmerge.sh in PATH, for example by coping it to /bin, or by creating ~/bin and adding it to PATH from .bashrc like PATH=$PATH:/home/rafal/bin

Mixins in .NET

2011-03-29T21:00:00+00:00

Today I wanted to experiment with mixins in C#, language that don’t provide such functionality. Below it’s my sample implementation of mixins using Castle Core (Castle Core is .NET IoC container, like Spring in Java).

In few days I will describe what mixins are, why there are useful and why there are so great in languages that natively support them, like Ruby.

using System;
using Castle.DynamicProxy;

class Program
{
    static void Main(string[] args)
    {
        Mike mike = new Mike();

        Console.WriteLine(mike.Name); // prints Mike

        MixinGenerator mixinGenerator = new MixinGenerator();
        mike = mixinGenerator.MixIn(mike, new ICanIntroduceMyselfMixin(mike));

        Console.WriteLine(mike.Name); // prints Mike
        ICanIntroduceMyself mikeCanIntroduceHimself = (ICanIntroduceMyself)mike;
        Console.WriteLine(mikeCanIntroduceHimself.Introduce()); // prints Good morning, I'm Mike.

        Console.ReadKey();

    }
}

public interface IHaveName
{
    string Name { get; }
}

public class Mike : IHaveName
{
    public virtual string Name
    {
        get { return "Mike"; }
    }
}

public class John : IHaveName
{
    public virtual string Name
    {
        get { return "John"; }
    }
}

public interface ICanIntroduceMyself
{
    string Introduce();

    string IntroduceInEvening();
}

public class ICanIntroduceMyselfMixin : ICanIntroduceMyself
{
    private IHaveName iHaveName;

    public ICanIntroduceMyselfMixin(IHaveName iHaveName)
    {
        this.iHaveName = iHaveName;
    }

    public string Introduce()
    {
        return "Good morinig, I'm " + iHaveName.Name + ".";
    }

    public string IntroduceInEvening()
    {
        return "Good evening, I'm " + iHaveName.Name + ".";
    }
}

// Mixins infrastructure

public class MixinGenerator
{
    private ProxyGenerator proxyGenerator = new ProxyGenerator();

    public T MixIn<T>(T composingObject, object mixin)
    {
        return (T)this.proxyGenerator.CreateClassProxyWithTarget(
            typeof(T),
            new Type[] { mixin.GetType() },
            composingObject,
            new MixinInterceptor(mixin));
    }
}

public class MixinInterceptor : IInterceptor
{
    private object mixin;

    public MixinInterceptor(object mixin)
    {
        this.mixin = mixin;
    }

    public void Intercept(IInvocation invocation)
    {
        if (invocation.Method.DeclaringType.IsAssignableFrom(this.mixin.GetType()))
        {
            object result = invocation.Method.Invoke(this.mixin, invocation.Arguments);
            invocation.ReturnValue = result;
        }
        else
        {
            invocation.Proceed();
        }
    }
}

PS Mixins are already implemented in Castle Core:

John john = new John();
ProxyGenerator generator = new ProxyGenerator();
ProxyGenerationOptions options = new ProxyGenerationOptions();
options.AddMixinInstance(new ICanIntroduceMyselfMixin(john));
john = generator.CreateClassProxyWithTarget<John>(john, options, null);
ICanIntroduceMyself johnCanIntroduceHimself = (ICanIntroduceMyself)john;
Console.WriteLine(johnCanIntroduceHimself.IntroduceInEvening());

Quick & Dirty Git setup

2011-03-14T21:23:00+00:00

Set name and email:
git config --global user.name "FirstName LastName"
git config --global user.email "your@email.com"
Change editor to your favourite one (for example nano):
git config --global core.editor "nano"
Adding aliases (shortcuts) to git commands, for example to have git ci, like svn ci:
git config --global alias.ci “commit”
Colorful output from git, everywhere:
git config --global color.ui "auto"
Your own graphical merge tool (replace with your name):
git config --global merge.tool <tool>
git config --global merge..cmd "command params"
git config --global meege..path "path to command, usefull on Windows"

Check all config option with `git help config`

Cygwin Setup

2011-03-14T20:37:00+00:00

After installing Cygwin, which brings great UNIX command-line tools to Windows, there are some things that you could set up, to make Cygwin even more great:).

Colorful promt (newer Cygwin installations have colorful prompt already)
Add to end of ~/.bashrc (taken from gentoo bashrc):

if [[ ${EUID} == 0 ]] ; then
PS1='\[\033[01;31m\]\h\[\033[01;34m\] \W \$\[\033[00m\] '
else
PS1='\[\033[01;32m\]\u@\h\[\033[01;34m\] \w \$\[\033[00m\] '
fi
Bash completion
Install bash-completion from setup.exe. It will enable completion of many commands in bash, but also, at least on my machine will seriously slow down terminal start. You can disable it temporary by moving or changing extension of /etc/profile.d/bash_completion.sh.
Mintty (newer Cygwin installations install it by default)
By default Cygwin's BASH is run through cmd.exe, with is quite bad terminal emulator, no resizing, no normal copy&paste, no UTF-8 by default, .... You can install from setup.exe mintty, with is based on Putty and provides missing from cmd.exe features.
LANG
You can set every program to use your mother tongue by setting LANG variable in C:\Cygwin\Cygwin.bat, for example:

set LANG=pl_PL.UTF-8
Bash history navigation with PgUp/PgDn
After writing first few characters of previously used command, you can auto-complete rest with PgUp (and go back with PgDon) with this setting in ~/.inputrc:

"\e[5~":history-search-backward
"\e[6~":history-search-forward
Other options
Check ~/.bashrc to enable/disable additional BASH options like not saving duplicates in history and colored outut from more commands.
Graphical tools
There is companion project to Cygwin, called Cygwin/X, which provides X server and possibility to run graphical tools. But it's not only option, programs written using TCL/TK can be run without X server, so tools like gitk work!

Why Team Foundation Server is just bad

2011-01-03T18:27:10+00:00

Recently I spend some time working with Microsoft Team Foundation Server 2010 as a source control, and bug tracking tool. It has also integrated build server, reporting and project management capabilities, but a don’t know much about them. From my experience, TFS is a bad source control software and quite nice bug tracking tool (but you have free, probably even better alternatives, that you can’t integrate with TFS). Below are my reasons. Most of them are little frictions, things that slow you down by few seconds. Someone would say that that’s not much, but simply put, why choose tool that is worse over plenty better alternatives? As a cherry on the top you will find few really big bugs, things that show that TFS it’s definitively not even used by it authors.

TFS uses lock-modify-unlock model to control access to files. This means that you need lock any file before you can use it. From the bright side it uses by default locks that don’t prevent other people from reading and editing files, but that defeats only advantage of lock-modify-unlock model, that is guarantee that you won't need to merge files. It’s pain when you try to do something not from inside Visual Studio, you need to lock all files manually, apparently for no reason:). Without VS using TFS is just big PITA.
TFS don’t see changes in files that aren’t previously locked, and even don’t differentiates between changed and unchanged locked files.That means that when you change a file in Visual Studio (which automatically locks files) and then you undo your edit, the file will appear in check-in (commit) dialog! (btw. do you remember all the *.designer.* files in VS, they will be marked as changes every time you open designer).
Another bad with caused by TFS locking model: when you have read-only access to some TFS managed solution, all the files are read only on your disk and you can’t edit then (because you can’t lock them). Of course you can manually remove read-only flag from file, but even with that you don’t have ability to use “diff”.
You can’t break lock without admin rights on TFS server…
Visual Studio has tight integration with TFS, this way working with TFS locking model is not that painful, some of the operation VS performs automatically. Bad news? VS integration with TFS is worse that integration of even free tools with other source control servers. For example moving files is marked as move, not “delete then add” in TFS (this way you see full change history), but not when you move files between projects (it works for example in AnkhSVN.
TFS is basically an online only tool, which means for example that without connection to TFS, all your files will be automatically read only (in TFS 2010 there is a build-in workaround for that, but it cures consequence, not cause). You can’t even do undo while not connected to TFS.
TFS don’t integrate with any other tools, so for example if you already had some other issue tracking software (other than build-in “work items”) or document/wiki server (other than build-in ability to store unversioned word files, that is preferred way to store documentation of TFS!), you are out of luck, do all manually. For all other source control systems there are plenty of possibilities, either external tools, like Scmbug, or build-in integration, like in SVN. Likewise TFS build server only works with MSTest unit testing framework, which badness is topic for another post:).
There is no patch functionality in TFS. In exchange you got “shelve”, that is possibility to check-in your changes to server to something like your private folder, from which other people can download them. It’s cool, but server side only, you can’t “send a patch”, and shelved changes can’t be merged somewhere else, even merging back those changes doesn’t work easily. Yes, applying “shelve” is not like merging patch, it’s restoring saved versions of all changed files!
Your local copy (working copy using SVN vocabulary) of solution managed in TFS is not self contained. Some of the data about connection between local files and TFS servers is stored somewhere else, this things are called “mappings”:). That means that you can’t just move whole folder to another location, it would break whole thing.
There is also a bug in this mappings and VS: when you delete whole connection to TFS in VS all contained in it “mappings” aren’t deleted. Result: when you try to download local copy into catalog that previously hold other project in deleted “connection”, you will get error saying that this folder already holds a project, and you first should delete it. But you can’t delete it, it’s invisible in any UI after you deleted whole thing, only salvation is manual editing of some magic “mapping” files.
TFS command line client isn’t really command line tool, for example when checking in (committing) it shows graphical dialog to enter commit message!
Default diff viewer doesn’t show more than added and deleted lines, functionally is almost equivalent to probably more than ten years old WinDiff from Windows SDK. Yes, you can change it to other, but you must do this on file extension basis, not globally, another PITA.
GUI is just bad, good example of lack of usability and user friendliness. Things that for example in free AnkhSVN take one click in TFS/VS take three (like seeing local changes). Dialog box doesn’t save last used options (like compare dialog), and are sometimes set to strange defaults (like this seeing local changes, by default it shows diff with newest server version, not your working copy one). When you click undo changes on few files, you will see dialog box with all touched files, and there is no option to view local changes in that dialog. In few places there is no “View history option”, like in check-in dialog. Double clicking on file in this dialog opens it in Notepad (!?), instead of for example in VS, or better yet, in diff program. Clicking “View history” on solution file "in Solution Explorer shows history only of *.sln file (!?), but clicking “Checking pending changes” will check changes of all files, not only *.sln. Check-in dialog doesn’t automatically completes filenames or changed method names (TortoiseSVN does). When checking-in into shelve it doesn’t even save commit message when clicking Cancel. “Shelve” option is available when you right-click on solution in Solution Explorer, but “Unshelve” is hidden only in File menu. In View History window, check-in message is in one line, so you can’t see it all without right clicking and selecting Changeset details on every separate check-in (all other graphical tools, like TortoiseSVn, Gitk, AnkhSVN shows message in multiline textbox).
There is no option to browse files in past, like in Repository Explorer of TortoiseSVN, you can only manually check out single files in interesting you versions. And if you would like to still have local copy with newest version, you need first to create another “workspace”, a tool to help fixing all bad ideas about locking and online-only modes in TFS:). Also, it’s impossible to download just single file, you always must download whole solution.
There is no way to revert commit in one click, what you can do is update to previous version, manually (!) copy all changed files to Desktop, then update to newest version and manually copy&paste contents of those files inside Visual Studio!!!
TFS tracks files when you tell him to do so (optimist can say that it’s similar to Git:)). Bad news? When you add file to project or project to solution, and then remove it, it will again appear in check-in dialog, even if it even don’t exists on disk. And when you add, change, rename or delete (!) file outside Visual Studio, TFS won’t see it also!
There are plenty of other small bugs in VS/TFS integration, on my computer when I undo change sometimes few empty messages boxes with error icon shows up. And on all computer always when you try to undo change from check-in dialog triggered from Source Control Explorer tab it freezes VS.
Even that TFS everywhere use locking, it doesn’t work at all! You can for example lock files with option disallowing other people to edit it. This is needed for example when you want to edit some binary files. Bad news? In TFS you can lock file that is not in newest version, thus when you will try to check it in, you will get merge conflict!

“do not know what horror means”

Technical debt

2010-05-16T13:36:00+00:00

I mentioned technical debt in last post. Here is a quote from Martin Fowler post Technical Debt:

Technical Debt is a wonderful metaphor developed by Ward Cunningham to help us think about this problem. In this metaphor, doing things the quick and dirty way sets us up with a technical debt, which is similar to a financial debt. Like a financial debt, the technical debt incurs interest payments, which come in the form of the extra effort that we have to do in future development because of the quick and dirty design choice. We can choose to continue paying the interest, or we can pay down the principal by refactoring the quick and dirty design into the better design. Although it costs to pay down the principal, we gain by reduced interest payments in the future.

Martin Fowler describes further technical debt and consequences of not taking care of code quality in follow up post Technical Debt Quadrant. In short terms:

The whole point of good design and clean code is to make you go faster - if it didn't people like Uncle Bob, Kent Beck, and Ward Cunningham wouldn't be spending time talking about it.

Strait to the point:) But again is hard to conform to your own rules, it’s hard to not only talk about quality and good design, but actually do it, even if it pays off. Live if complicated, software development also.

Another good Marin Fowler’s artice: Is Design Dead?

Custom ASP.NET authentication or how to conform to your own rules

2010-05-16T11:34:00+00:00

Custom ASP.NET authentication

Lately I worked on integrating ASP.NET web application with external authorization service. Luckily ASP.NET architecture is very extensible and many ASP.NET functionalities are not hard-coded into framework, but provided by instances of IHttpModule. In general those modules allows developers to hook into request processing pipeline and perform custom actions before, during and after request handling. Sole interface is very simple, provides only two methods:

public interface IHttpModule
{
    void Dispose();

    // Summary:
    //     Initializes a module and prepares it to handle requests.
    // Parameters:
    //   context:
    //     An System.Web.HttpApplication that provides access to the methods, properties,
    //     and events common to all application objects within an ASP.NET application
    void Init(HttpApplication context);
}

During application startup ASP.NET runtime will call Init method on all registered modules. Inside Init modules usually attach custom handlers for HttpApplication events, like AuthenticateRequest, AuthorizeRequest, BeginRequest, EndRequest, Error and many others. Standard ASP.NET services like authentication, authorization, output caching and session are provided as modules, so it’s possible (and quite easy!) to switch then to your own implementations.

For example to integrate my external authorization service, I wrote something like this:

public class MyAuthorizationModule : IHttpModule
{
    public void Init(HttpApplication context)
    {
        context.AuthenticateRequest += new EventHandler(this.HttpApplication_AuthenticateRequest);
    }

    public void Dispose()
    {
    }

    private void HttpApplication_AuthenticateRequest(object sender, EventArgs e)
    {
        HttpApplication application = (HttpApplication)sender;
        string username = this.AuthenticateInExternalSource(application.Context);
        if (username != null)
        {
            GenericIdentity identity = new GenericIdentity(username, "MyAuthentication");
            application.Context.User = new GenericPrincipal(identity, new string[0]);
        }
    }

    private string AuthenticateInExternalSource(HttpContext context)
    {
        // Dummy code
        return "Rafał";
    }
}

And provided some configuration in web.config:

<configuration>
<!—- You will need to use section <system.webServer> instead when using IIS 7.0 in integrated mode -->
  <system.web>
    <!-- Disable default Windows authentication -->
    <authentication mode="None" />
    <httpModules>
      <add name="MyAuthenticationModule" type="MyWebApp.MyAuthorizationModule"/>
    </httpModules>
  </system.web>
</configuration>

That’s all what you need to provide custom authentication service in ASP.NET! Just set User property to your own instance of IPrincipal during handling AuthenticateRequest event, register your module and disable enabled by default Windows authentication. The great part about it is that it perfectly works with other parts of ASP.NET framework, for example with roles provider.

The problem

From my external authentication service I get some more informations than just user name and I wanted to store it inside this User property and use it later. So I quickly created custom IIdentity class and committed changes:

public class MyIdentity : GenericIdentity
{
    public MyIdentity(string name, string anotherId)
        : base(name, "MyAuthentication")
    {
        this.AnotherId = anotherId;
    }

    public string AnotherId { get; private set; }
}

After a while my colleague downloaded my changes, started application and got SerializationException. I quickly found that IIdentity implementations should be serializable, quickly added [Serializable] attribute and again committed changes. This time there was another SerializationException, but with message “Type is not resolved for member…”. After looking for a while for cause, I found Rockford Lhotka post that help me understand what was going on.

Basically setting this User property sets also principal on thread that’s serving given request. The problem lays in that in case of build-in web server in Visual Studio the same thread is used for handling request (in one AppDomain) and for some other tasks (in another one). When you have some objects in one AppDomain and want to use them in another (and that’s the case of our custom principal attached to thread) they can’t be used directly, and must be coped (by serialization and deserialization) or proxied (by inheriting from MarshalByRefObject) instead. The other AppDomain that this build-in web server uses doesn’t have access to types declared in our assembly (.NET tries to load it, but it looks only in process working direcotry and in GAC, and throws SerializationException. Possible solutions are: inheriting from MarshalByRefObject, installing assembly to GAC, coping it to web server working directory, trying to reset thread principal or using DEVPATH.

All solutions to this problem have some drawback so I decided to just drop my custom IIdentity implementation. I wanted to quickly fix this bug and not stopping my colleague soI created some static methods on my authentication module to provide the additional data that I put before in my IIdentity implementation. In my guts I felt that those static methods aren’t the best solution, but I quickly committed this change to start working on other things.

Lesson learned

Many times I heard and even say to others that code quality is very important, that in long term it always pays off to take care of design, coding standards, refactoring and testing. Software development is about managing complexity, and without paying attention to quality, great project can become real mess, a mountain of complex and intangible code. Great metaphor that nicely describes problems with quality in software projects is Technical Debt. Another highly recommended read!

It’s easy to say “quality is important, always do things the right way, not the quick-and-dirty one”, but it’s a lot harder to do it actually. This time I managed to stop and think about better way of coding this particular feature and after a bit of work I ended with solution that I wan't be ashamed of. The point is, I need always to thing about quality, about design. It’s so easy to start running and doing things the quickest way. But at the end there will always be a moment when you will have to pay back your technical debt, in long term it will always slow down development.

When it’s good enough – also about ASP.NET validators and Captcha

2010-04-07T11:12:00+00:00

Lately I encounter a lot of comment spam on my blog. There are many possibilities to fight such spam: filters like Akismet, different kinds of Captcha or just required registration. Of course I decided to create my own simple Captcha control for ASP.NET. There are many others available, but I wanted to make my own for educational purposes – do you hear NIH ;)?

Finally I created two controls inheriting from BaseValidator, one that ask question like:

Answer using words not digits: twelve minus three equals

And second that just renders empty and hidden <input> and checks if spam bot accidentally filled it. The first one works very well on my blog, I have no spam right now. Probably it wouldn’t be so effective on highly visited and popular sites - spammers would just create a spambot that would handle it, but my site is not so popular to bother.

Problem

All validators in ASP.NET follows the same schema: they are used to check validity of some other control and eventually render error message. My Captcha behaves differently: it always render something (question or empty input) and doesn’t validate any other control. I had to change some behaviors of BaseValidator in my inherited controls and ignore some properties from this base class. You can see it in attached source code in AbstractCaptchaValidator class.

SOLID

Robert C. Martin created SOLID, acronym for five basic principles of object-oriented design. There are great guidelines how to think about responsibilities and interactions of classes. You should really check them out on his old site, or in his book, Agile Principles, Patterns and Practices, also available in C# version. Highly recommended.

One of those rules is Liskov Substitution Principle:

Derived classes must be substitutable for their base classes.

My Captcha controls of course violates this principle.

Solution

In attached source code you can find my second attempt to create Captcha, this time as composite control, that internally renders Label with question, TextBox for answer and CompareValidator to check if given answer is correct. Another possibility is to implement the IValidator interface which doesn’t assume all behaviors of BaseValidator, but I lost source code for this.

Lesson learned

It’s good to look for better solutions and fight against code with complicated, not obvious and surprising behavior. SOLID principles are good guide for that. It makes your work easier in long run.

But the real point of this post is something different. It’s sometimes hard to recognize when given solution to some problem is good enough. In reality (in job particularly) it doesn’t need to be always the best and perfect one, sometimes good enough is good enough. Usually there is a need to weight pros and cons of better and worse solution, consider time frame, familiarity with given domain, abilities of team, … How to make a good decision? I think that I just need to be beware of those tradeoffs and be conscious.

MyCaptchaLib.zip

Retention of .NET attributes like in Java

2010-03-01T19:02:37+00:00

In Java you can decide if attributes, called there annotations, should be persisted only in source code, also in compiled .class files or even at runtime. You use special annotation, @Retention, to specify that. Java compiler starting from Java 5 supports annotations and this special meta-annotation (meta, because it’s annotation on annotation:) ). It’s something like that possible in .NET?

Of course;) In .NET you can use special Conditional attribute. This attribute allows us to decide if given method call or attribute should be ignored unless a specified compilation symbol is defined. Example:

public class Program
{
    static void Main(string[] args)
    {
        Assert.AreEqual(1, 2);
    }
}

public class Assert
{
    [Conditional("DEBUG")]
    public static void AreEqual(int number1, int number2)
    {
        if (number1 != number2)
        {
            throw new Exception("Arguments aren't equal.");
        }
    }
}

“DEBUG” is standard compilation symbol which is specified by default when you compile Debug version of standard Visual Studio project. Above code will throw exception when compiled in Debug mode. But when you compile it in Release configuration, nothing will happen, Assert.AreEqual method will not be even called. You can do the same with attributes:

[Conditional("USE_BEST")]
public sealed class BestAttribute : Attribute
{
}

This attribute when used on class,method and so on, will not be actually applied if “USE_BEST” symbol will not be declared.

When Conditional attribute is useful?

When used on other attributes it’s possible to create attribute that will serve only documentation purposes. But you can use regular comments for that:). Another reasons for use of Conditional are situations when you have many deployments, and in some places you for example need to call some function and in others not. You can also use it to implement your own trace or assert framework, but that is already created by Microsoft (see Debug and Trace classes).

JSON parser using ExpandoObject

2010-02-19T17:28:01+00:00

JSON

Lately I wanted to know what JSON is. And it appeared that is very nice data-interchange format. It’s a lot simpler than XML and probably could be used in all scenarios when XML is used. Just look at json.org and you will learn JSON in about 2 minutes. That’s nice:) It’s so simple that I fought that I will create for fun simple JSON parser using ExpandoObject. And, as usual, I learn something important:)

ExpandoObject

.NET 4.0 integrates DLR, which is Dynamic Language Runtime. What’s it? DLR allows to use construct’s previously possible only in dynamically typed languages. For example in C# you can declare variable as “dynamic”, and use it like variables in PHP, JavaScript, Python or Ruby

dynamic x = new List<int>();
Console.WriteLine(x.Count);
x = new int[0];
Console.WriteLine(x.Length);
x = "It's dynamic!";
Console.WriteLine(x);
// This line throws exception because there is no MyMethod on string object.
// x.MyMethod();

To find out more about “dynamic”, be sure to check Chris Burrow’s blog.

In .NET 4.0 introduce also ExpandoObject, very smart example of using new “dynamic” possibilities. It allows to declare object members on the fly (it sound to me like JavaScript!).

dynamic expando = new ExpandoObject();
expando.Member1 = "Foo";
expando.Member2 = "Bar";
expando.ToString = (Action)delegate { return expando.Member1 + " " + expando.Member2; };
Console.WriteLine(expando.Member1);
Console.WriteLine(expando.Member2);
Console.WriteLine(expando.ToString());

To find out how it works check DynamicObject and IDynamicMetaObjectProvider.

JSON Parser using ExpandoObject

ExpandoObject is perfect for creating simple JSON parser. This shows how it works:

[TestMethod]
public void ObjectStringMembers()
{
    dynamic result = new JsonParser().Parse("{\"Foo\": \"foo\", \"Bar\": 123}");
    Assert.AreEqual("foo", result.Foo);
    Assert.AreEqual(123.0, result.Bar);
}

I’m quite sure that my parser implements full JSON specification found in RFC 4627 and in only 176 lines of executable code (425 with comments, superfluous braces and so).

Lesson learned

First when I started to implement JSON parser, I thought about using regular expression. Luckily I remember quote from Jamie Zawinski:

Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems.

So I quickly drop this idea. Then I tried to use inputJSONString.Split(‘,’) and use the output of that to parse JSON. This time it took me about 30 minutes to find out that it’s another wrong approach. At last I get back to basics and used old knowledge gained on compilers theory lectures. And now I have simple parser which use something like LL(1) grammar:). What I learned is that I really need to know the basic, things like compilers theory, assembler, WinAPI, bytes and CPU instructions, JIT, XML, SOAP, a lot of things. If you thing it’s not needed, read article linked in next-to-last statement, it’s a good one. You can download the parser below.

JsonParser.cs

JsonParserTests.cs

Visual Studio 2010 Start Page Customization - Remove “Connect To Team Foundation Server” from default Start Page

2010-02-13T04:15:00+00:00

Update:

You can now easily create custom Start Page based on default one using Custom Start Page Project Template.

In Visual Studio 2010 you can easily change Start Page. Just put your version of Start Page inside MyAccount/Documents/Visual Studio 10/StartPages and select it in Tools –> Options… –> Environment –> Startup. You can find more info on MSDN.

Remove “Connect To Team Foundation Server”!

Save copy of default Start Page in MyAccount/Documents/Visual Studio 10/StartPages/MyStartPage.xaml (if you don’t have it, check instructions below)
Find Grid named commandButtonsGrid (line 26.)
Remove first ImageButton with x:UID="ConnectoToTSButton"
Remove first two RowDefinition elements from Grid.RowDefinitions
Change Row in second ImageButton to Row=”0” and in third to Row="2"
Save file and select it as new Start Page from Options like described above.

How to extract default Start Page from Visual Studio 2010

In Beta 2 of Visual Studio 2010 it was easy to start from default Start Page just by simply coping it from MyAccount/Documents/Visual Studio 10/StartPages/StartPage.xaml to new file. In RC this file disappeared from that location, but it’s still on your hard drive, but this time in

C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\en\Microsoft.VisualStudio.Shell.UI.Internal.resources.dll

Exactly inside this assembly in startpage.baml in resource file named Microsoft.VisualStudio.Shell.UI.Internal.g.en.resources. Below view of this file from Reflector.

If you wan to extract XAML source of this file download BamlViewer add-in to Reflector. Sadly BamlViewer is not good enough to extract fully working XAML source, it appears that it have problems with XML namespaces and attached properties. You will have to fix some problems manually, save startpage.xaml to disk using BamlViewer and:

Replace Static with x:Static
Replace StartPageBackgroundKey with vsfx:VsBrushes.StartPageBackgroundKey
Replace StartPageSeparatorKey with vsfx:VsBrushes.StartPageSeparatorKey
Replace Column, Row, ColumnSpan with Grid.Column, Grid.Row, Grid.ColumnSpan
Replace AutomationId with AutomationProperties.AutomationId
Replace Name="Recent Projects" with Name="RecentProjects"
Replace TabNavigation with KeyboardNavigation.TabNavigation
Replace HorizontalScrollBarVisibility with ScrollViewer.HorizontalScrollBarVisibility
Replace SetUrl with sp:RssCommands.SetUrl
Move <DataTemplate.Triggers> at the bottom of parent <DataTemplate>
Replace Browse with sp:VSCommands.Browse
Remove Name="{Binding XPath=title}"
Replace EnableDownload with sp:RssCommands.EnableDownload
Replace {x:Static PromptForCredentials} with {x:Static sp:RssCommands.PromptForCredentials}

I’m sure this file will be easier to obtain in future:)

PS TFS is not and probably never be as popular as MS would like it to be:)

PS After clean installation (including deletion of all settings) of Visual Studio 2010, in my Documents folder VS created three catalogs: Visual Studio 10, Visual Studio 2008, Visual Studio 2010. Worse than in VS2008, then I had only two: Visual Studio 2008 and Visual Studio 2005.

PS 2 Today when I wanted to shutdown my computer, which I don’t do very often because I just close the lid and suspend, I saw the usual options in Windows Vista/Seven: Switch user, Log off, Lock, Restart, Hibernate, Shutdown. My first fought was: what the hell nHibernate is doing here:)

How to learn?

2010-02-03T21:45:00+00:00

Lately I was wandering what's the best way to be better developer (or to be more concrete in my circumstances: how to become good developer). Here are some notes for me to remember:

Read books, there are a lot better source of knowledge than tech-blogs. I think that tech-blogs are great when you want to find a solution for a specific problem or master something, but when you are learning, you need to have deep knowledge of fundamentals and you won't find it elsewhere, only in books
When you learning new concept try to ask yourself question: Why is it done this way?
When I read book, I should more often use computer to try things in practice. I see now that I understand more, deeper and it last for longer then. So next time when I will don't fully understand something or I will have some doubts or I will just learn something new, I will just fire Visual Studio and play with it:)
Write software. There are two not exclusive possibilities: work as developer (I'm not right now) or contribute to some open-source project. Why? Because you need to share and confront your ideas with others. First of all, you need to have those ideas and you won't have them if you just reading/learning but not inventing/solving real problems.
Read blogs, but not to much at the same time:)
Don't be too focused on API, try to thing in more abstract terms, both in thinking about how this technology is created and how you will use it

We will see how those advices will be useful for me:)

PS Look at Udi Dahan's presentation: Making roles explicit. Not on this topic, but great and mind blowing.

Go to Implementation and Visual Studio 2010

2009-11-16T21:19:00+00:00

There is a nice feature in Visual Studio called “Go to Definition”. As name implies, when you point to, for example, to method invocation and use this option from context menu (or use F12 hotkey), VS will navigate to definition of this method. It really speed up writing code, when you can quickly jump between methods without remembering in which file it’s defined. It’s even more useful when you read someone else’s code. It works also with fields, properties, events, variables and so on.

Problem

Sadly it doesn’t work especially good with interfaces:

IMyComponent component = getMyComponent();
component.MyMethod();

Now when I go to definition of MyMethod, VS will show me this:

public interface IMyComponent
{
    void MyMethod();

    ...
}

What I would actually want is to navigate to implementation of this method. Of course there could be many implementations of this method and that would require some sort of dialog to choose which implementation to show.

Solutions?

Resharper plugin to Visual Studio which have such functionality (Go to Inheritor and Go to Implementation).
Upgrade to Visual Studio 2010. In Beta 2 there is an option called Call Hierarchy, which allows you to see implementations of methods, but it won’t work when pointing to whole interface instead of particular method and it shows not only implementations but also calls to and from given method. See it here.

Introduction to Inverson of Control magic

2009-11-16T20:13:00+00:00

There is a great Inversion of Control container called Windsor. With IoC container you can easily break dependencies, make your code more testable, and do more funky stuff that I will show you later. And in very easy way! I’m still not a guy who’s able to describe something in nice words, so I will show you what is IoC container on examples:

Resolving implementations

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

public static void Main()
{
    // Configuration
    WindsorContainer container = new WindsorContainer();
    container.Register(Component.For<ILogger>().ImplementedBy<ConsoleLogger>());

    // Usage
    ILogger logger = container.Resolve<ILogger>();
    logger.Log("Information.");

    // Output
    // "Information."
}

First function of container is giving you implementation for given interface. Which implementation it will return can be configured in different ways:

"classic" XML configuration file
"modern" fluent interface API, which you see in above example

As a side note I think that you should start using Windsor with XML configuration, to better see all the options, and then quickly switch to less verbose and error prone fluent API. If you think that this way you will loose possibility to change configuration without recompilation see dynamic compilation, IronPython and Binsor.

The best part about this “giving you implementation for given interface” is that Windsor can actually resolve all the dependencies. It means that it can automatically provide constructor arguments and set all public properties. Like here:

Resolving dependencies

public interface IProductionClass
{
    int DoWork();
}

public class ProductionClass : IProductionClass
{
    public ILogger Logger { get; set; }

    public string Name { get; set; }

    public int DoWork()
    {
        Logger.Log(this.Name + ": DoWork");
        Thread.Sleep(100);
        return 1;
    }
}

class Program
{
    public static void Main()
    {
        // Configuration
        WindsorContainer container = new WindsorContainer();
        container.Register(Component.For<ILogger>().ImplementedBy<ConsoleLogger>());
        container.Register(Component.For<IProductionClass>().ImplementedBy<ProductionClass>());

        // Usage
        IProductionClass productionClass = container.Resolve<IProductionClass>(
            new { Name = "MyProductionClass" }
        );

        productionClass.DoWork();

        // Output
        // "MyProductionClass: Do Work"
    }
}

Example above shows a ProductionClass, which uses ILogger. Windsor automatically sets Logger property of ProductionClass to registered implementation. It also sets Name property to value shown in argument to Resolve (btw. nice usage of .NET 3.5 anonymous types). I hope you see the power and simplicity that it brings.

It’s still a functionality that you couldn’t implement in few hours, and not the thing that made me writing this post. Light bulb started going over my head when I saw something like this:

Intercepting method invocation

public class PerformanceLogger : IInterceptor
{
    public ILogger logger { get; set; }

    public void Intercept(IInvocation invocation)
    {
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        invocation.Proceed();
        stopwatch.Stop();
        logger.Log(string.Format(
            "Invocation of '{0}' took {1}ms.",
            invocation.Method.Name,
            stopwatch.ElapsedMilliseconds
        ));
    }
}

public static void Main()
{
    // Configuration
    WindsorContainer container = new WindsorContainer();
    container.Register(Component.For<ILogger>().ImplementedBy<ConsoleLogger>());
    container.Register(
        Component.For<IProductionClass>()
        // Only new line
        .Interceptors(new InterceptorReference(typeof(PerformanceLogger))).Anywhere
        .ImplementedBy<ProductionClass>());
    container.Register(Component.For<PerformanceLogger>());

    // Usage (still the same!)
    IProductionClass productionClass = container.Resolve<IProductionClass>(
        new { Name = "MyProductionClass" }
    );

    productionClass.DoWork();

    // Output
    // "MyProductionClass: DoWork"
    // "Invocation of 'DoWork' took 271ms."
}

There is a possibility in Windsor to intercept method invocations (do AOP basically) to, for example, check permissions, log something, add error handling. Above example introduces new class PerformanceLogger which implements Windsor’s IInterceptor interface. Only thing to make it intercept method invocations is to add it to registration of given component!

Conclusion

I hope I’m getting better at writing posts, and that with this one I interested you in IoC containers and encourage you to try it yourself. As you could hopefully see, IoC can help make your applications be easier and simpler.

Post Scriptum

There is a possibility to skip configuration step in Windsor. You can for example write something like that:

container.Register(
    AllTypes.FromAssemblyNamed("MyServicesImplementations")
    .Where(t => t.Name.EndsWith("Service"))
    .WithService.FirstInterface());

Now you even don’t have to configure new component/service to work. You can just put ISomeService and SomeService class somewhere and start using them!

Bugs in Visual Studio 2008

2009-09-09T21:59:00+00:00

Like I said in previous posts, there is no software without bugs. But still I was quite surprised when I have found my first bug in Visual Studio. And now I know even two:).

Those aren’t the only bugs in Visual Studio, just try to search for them in Google.

I even fought few times that some behavior of VS, C# compiler especially, is a bug, when it wasn’t. For example:

public enum MyEnum
{
    One,
    Two,
    Three,
}

Person person = new Person { FirstName = "John", LastName = "Wayne", };

Did you noticed that last comma in enumeration definition and in object initializer? C# specification allows those odd commas to simplify life of code generation tools!

public static bool Compare(object x, object y)
{
    return x.Equals(y);
}

int static Main(string[] args)
{
    int x = 1;
    Console.WriteLine(Compare(x, x));
}

This code will print “false”. Maybe you know why? (answer is connected with english Christmas;)

Bug-less:)

2009-09-08T19:20:00+00:00

It quite scary when you notice that every program have bugs.

How often are you sure that everything is OK? Till lately I was sure about that right after I put my fingers off the keyboard. Although I knew that nothing is perfect, I was thinking: “I wrote so great piece of software and thought about everything. It's so simple’. But then code went to production and people started to use it. Factors, like network problems, misbehaving users;), inconsistent or invalid data revealed tons of tons of bugs.

So what to do? There are some options that I know so far:

unit testing
integration tests
static code analysis

Unit tests?

They are great for documenting your API:

[TestMethod]
public void Test()
{
    // Arrange
    Database database = new Database();
    int nonExistingPersonId = 12345;

    // Act
    Person person = database.Get<Person>(nonExistingPersonId);

    // Assert
    Assert.IsNull(person);
}

From example above I see that Get method returns null when you try to find non existing person, and I’m sure that this behavior won't change unnoticeably (e. g. to throwing exception).

Integration tests?

Can you predict how user or other application will break your software?

Static code analysis?

Yeah, it will tell you that you left unused method or use some not-so-good coding practice.

Conclusion

I will definitely use more often above practices and encourage others to do so. Maybe it’s also time for some continuous integration? And from different box: code reviews, team discussions, presentations, basically exchanging knowledge and building craftsmanship.

But still my code will contain bugs! In spite of all the null checks, try/catch blocks and tests, professional atmosphere and prepared failover scenarios. And it will contain them whatever I will do:)