The scenario is simple, we have four roles defined for the system. They are Students, Graduates, Staff and Administrators. Some staff can be graduates, (or even Students). Administrators are, of course staff! So how you model this? We already know of one bitwise trick from Michal’s post, so let us see how we can use bitwise operations to make this a reality!

First let us revise the results of the bitwise AND operations. You can check Wikipedia for full details.

1	&	0	=	0
0	&	1	=	0
0	&	0	=	0
1	&	1	=	1

Converting these back to decimal 1001 is 9 and 0101 is 5. So 9 & 5 = 8. If we convert each of these bits to represent a role in our system, we can come up with a table like this.

Bit 1	0 (false)	Student
Bit 2	0 (false)	Graduate
Bit 3	0 (false)	Staff
Bit 4	1 (true)	Admin

So a user of the system with a role number of 8 is an Admin, but in our case, an Admin is also a member of staff, and in fact, a member of staff could also be a student or a graduate. This is where using bitwise operations can really help model such a situation. To get it working, a staff member who is a student will have bits 1 and 3 set to true, while a graduate who is also a staff member will have bits 2 and 3 set to true. We can represent these roles in decimal as User(Staff & Graduate) = 6, while User (Staff & Student) = 5. Get the picture?

Let’s look at a simple real world example. First we have a User class, with a Role property of the type int. The reason we use an integer, is that is can be easily stored in the database.

We also need to create an enumeration, with a Flags attribute. The flags attribute tells the compiler that this enumeration can be treated as a bit field. We then define a value for each role. The reason for using exponents of 2 should become clearer later.

The menu of our website needs to be generated depending on the user role. The menu selection code below should generate the correct menu depending on the user role.

Ok, so let see where the magic happens! If we AND (&) the user assigned role, with the role required, and we compare this result to the role required, we can determine if a user is in the role. Summarised, the end result of the AND operation needs to equal that of the role required. In user class we have the method:

Looking at some binary examples, we can see how it works. In the first example, an admin user wants accesses a graduate item.

Role Required	Staff(4)	0 1 0 0
User Role	Admin (8)	1 0 0 0
Result of &	Access Denied (0)	0 0 0 0

It is clear that we have a problem here, because we said that admin could be both staff, and staff may also be graduates. What we need to do is add up the roles, so that this user will access both admin and staff content. Assigning the user the role of Admin and Staff is easy. All we do is:

And the resulting table is:

Now we can easily draw our menu depending on the roles assigned to a user. Adding or removing roles for a user is also easy, just add it or subtract it. I wrote a little project to go with this so you can test it our your self. Thanks to Michi for introducing this, and Dan for helping work it out!

Download the Roles sample project You’ll need to use nUnit to test it.

FNH extends NHibernate, and automagically generates XML mapping files for your objects. Unfortunately, to get stored procedures to work, you need to take a step backwards, and create good old fashioned hbm.xml files, doing the mappings manually.

Firstly , let us look at the results of the stored procedure that we want to map.

The class that will use this data is called lookup.

The code for this class is:

 
This object will be used to populate a simple drop down list, so that a user can select their county.

When I started using FluentHNibernate, I wanted to totally avoid using XML mappings, so I skipped chapters 3 and 6 of Hibernate in Action. My first mistake! So for those attempting this, it may be worth your while understanding Hibernate mappings before you proceed. (You may also ask why I have the Java Book and my code is in C#, that is because I am quite used to working in different programming languages, so those who prefer examples in .Net examples check NHibernate in Action.)

Let’s move on to creating the mapping file.

IMPORTANT: When you add the mapping file to your project, make sure you set the Build Action to Embedded Resource!

I have created a Lookup.hbm.xml file, and the source is below:

To put it quite simply, lines 5 to 13 map my Lookup class to the columns in the stored procedure, while lines 16 to 20 map the results from the stored procedure my lookup class. Line 22 names the stored procedure. I am not sure if this is the best way to achieve the mappings, so any feedback would be appreciated.

Once your object is nicely mapped, you then need to update your fluent configuration. All you need to do is tell FNH to load hbmMappings from the current assembly. See the snippet below:

To retrieve the list of lookups, I do the following, which populates my results variable with a list of all my lookups.

And that is it, the results variable now contains the list of lookups that I can use to populate my list control.

1. Hidden Features of C#
2. Visual Studio Optimizations
3. Which C#/.Net blogs do you read?

If you need more see the most voted C# questions. Would be nice to see some more lists like that (Julien, what about Flex?, Fab PHP?).

Okay, maybe you haven’t seen this screen in particular but apart from the troubleshooting tips you should have seen it.

Few days ago I have discovered the Null object pattern (NOP) and its usefulness. Kick me, punch me or even stone me to death cause I haven’t known it so far :) Still I would like to write a quick note about it as not everyone might be aware of it.

If it’s possible for a variable to be null, you have to remember to surround it with null test code so you’ll do the right thing if a null is present. Often the right thing is same in many contexts, so you end up writing similar code in lots of places – committing the sin of code duplication. – Martin Fowler

What does that exactly mean? It means the following:

if (Product.Creator == null) {

    Debug.WriteLine("unknown");

} else {

    Debug.WriteLine(Product.Creator);

}

If we have a Creator property of a Product and it may be null (to indicate an unknown creator) we need to do a null check everywhere we wanna display the creator. I would call it boring code duplication. And that’s where the NOP joins our game.

Let’s create a user instance which represents the actual “unknown” user so we can get rid of the odd null check. Best to achieve that is to sub class our User into an Unknown user. The following diagram illustrates this simple approach. btw see Customers equal to users :))

Figure 1 – Patterns of Enterprise Application Architecture, Martin Fowler

As you can see we are even able to provide different types of “null” users such as “Missing” and “Unknown”. That allows us to assign a human readable name to those users (e.g. assign in the sub class’ constructor) and we are still able to check if a given user is unknown (if necessary):

if (Product.Creator is UnknownUser)

Okay, enough general theory about the pattern itself. You might ask how does the whole thing fit into NHibernate? Persistence is the magic word. If our users are persisted then the “unknown” users gets persisted as well. That’s probably not what we want. We wanna keep our data storage clean containing only “real” users. Michael Cromwell points that out in one of his articles:

This then has its own problems because if it’s a user editable object you don’t really want them to be able to change/delete this data so it becomes a special case that will need to be locked for editing/deleting. – NHibernate & Null Object Pattern: The Options, Michael Cromwell

Correct! We don’t want to exclude this user in all our queries and take care of these “special case users”. What he suggests is to handle that case directly in the getter and setter of the property. In case a null is assigned he returns an “NotAssigned User”. In our particular example the solution would look the following:

protected User _creator;

public User Creator {

    get {

        return _creator ?? new UnknownUser();

    }

    set {

        if (value is UnknownUser)

            _creator = null;

        else

            _creator = value;

    }

}

I am happy! This looks like a nice OO solution to me. The “unknown user” won’t be persisted, a null reference will be stored instead. Important: This works fine for one “unknown user type”. However, keep in mind that if we have more than one “unknown user type” (see Figure 1) than it might be necessary to persist those users in order to be able to differentiate between them.

Haven’t used it so far but will in my next projects. Anyone who is interested into more practical details might read How to avoid “!= null” statements in Java?.

Let’s start with a brief description of the problem before digging through the possible solutions. The applications architecture is based on the NHibernate Best Practices with ASP.NET, 1.2nd Ed. by Billy McCafferty. I guess it’s a must read for all who deal with Nhibernate and asp.net. So please read it before moving on, as it helps you to understand the approach I am talking about.

Problem:

1. Many domain objects have different properties which are in need of translations. E.g. A Product may contain a Name and a Category property which needs to be translated into the applications supported languages.
2. It should be easily possible to update the translations of an object before persisting it.
3. After getting a persistent entity it should be possible to get a given property in the applications current language.
4. Querying entities according to the translation must not be a big problem. E.g. Getting a list of products ordered by its name in the current selected language.

1st Solution:

The first solution I tried was the approach from Ayende (Localizing NHibernate: Contextual Parameters) – whose Blog I strongly recommend for all NHibernaters. The approach he describes is having a simple string property on your domain object and mapping it using a filter with the current selected language (culture).

Pros:
- quickly to implement
- Domain objects property stays unchanged (still a string)

Cons:
- Each property would result in an own table
- “ugly” sql queries in your mapping files
- Can’t easily access all translations
- Querying entities is not straightforward (e.g. fulltext search)

2nd Solution (my preferred):

Due to the cons I could not really use the 1st approach within the project and decided to build an own solution. Here is my suggestions…
We create a Domain object called PhraseDictionary acts as a generic container for translation phrases. It can be bound to any property of any of our domain objects. I have added its class diagram to show its members:

That type can be used now for each of our domain properties which require translation. The Name property helps us to differentiate all the different phrases we will have in the DB (you can skip it if you want – though it’s nice if you browse the data directly). The SetPhrase() method sets a phrase for a given LCID and getPhrase() gets a phrase translation for the requested LCID. Both methods return the instance itself to make method chaining possible.
For easier usage there is a Phrase property which does the same but always for the current domain culture (Domain culture could be handled in a DomainCulture class – which gives us the ability to get the current culture and/or switch it). All Phrases are stored in a Dictionary with LCID as key and the actual translation as the value.

As we are going to persist it, thats the resulting mapping file:

<?xml version="1.0" encoding="utf-8" ?>

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">

  <class name="MyProject.Core.Domain.PhraseDictionary, MyProject.Core" table="dictionary">

    <id name="ID" unsaved-value="0">

      <generator class="identity" />

    </id>

    <property name="Name"></property>

    <map name="Phrases" 

      access="nosetter.camelcase-underscore" 

      table="phrase" 

      cascade="all-delete-orphan">

      <key column="dictionary_id"></key>

      <index column="culture_id" type="Int32"></index>

      <element column="phrase" type="String"></element>

    </map>

  </class>

</hibernate-mapping>

The most important part here is the Dictionary (map) which stores the LCID as key and the translation as value. Thoses “phrases” are fully cascaded as it makes no sense for them to live without the PhraseDictionary.

Okay lets dig into the actual implementation…

using System;

using System.Collections.Generic;

using System.Text;

using System.Threading;

namespace MyProject.Core.Domain {

    public class PhraseDictionary : DomainObject<int> {

        /// <summary>

        /// required for NHiberante

        /// </summary>

        protected PhraseDictionary()

            : base() {

            Phrases = new Dictionary<int, string>();

        }

        /// <summary>

        /// 

        /// </summary>

        /// <param name="name">internal name only</param>

        public PhraseDictionary(string name)

            : this() {

            Name = name;

        }

        private IDictionary<int, string> _phrases;

        private string _name;

        /// <summary>

        /// Name of the dictionary. 

        /// - only for internal use. Eases browsing data directly in database

        /// </summary>

        public virtual string Name {

            get { 

                return _name; 

            }

            set { 

                _name = value; 

            }

        }

        /// <summary>

        /// Stores all phrases for a lcid

        /// </summary>

        public virtual IDictionary<int, string> Phrases {

            get { 

                return _phrases; 

            }

            private set { 

                _phrases = value; 

            }

        }

        /// <summary>

        /// Adds a phrase for a given lcid

        /// - if the lcid exists then the phrase is updated

        /// - empty strings are considered as "not available". 

        ///     Thus adding an empty phrase might remove an existing if already existed

        /// </summary>

        /// <param name="lcid"></param>

        /// <param name="phrase"></param>

        /// <returns>Returns itself. Useful for method chaining.</returns>

        public virtual PhraseDictionary SetPhrase(string phrase, int lcid) {

            if (Phrases.ContainsKey(lcid)) {

                if (string.IsNullOrEmpty(phrase)) {

                    Phrases.Remove(lcid);

                } else {

                    Phrases[lcid] = phrase;

                }

            } else if (!string.IsNullOrEmpty(phrase)) {

                Phrases.Add(lcid, phrase);

            }

            return this;

        }

        public virtual PhraseDictionary SetPhrase(string phrase) {

            return SetPhrase(phrase, Thread.CurrentThread.CurrentUICulture.LCID);

        }

        /// <summary>

        /// Gets a phrase for a given lcid

        /// - returns empty string if it does not exist

        /// </summary>

        /// <param name="lcid"></param>

        /// <returns></returns>

        public virtual string GetPhrase(int lcid) {

            if (Phrases.ContainsKey(lcid)) return Phrases[lcid];

            return string.Empty;

        }

        public virtual string GetPhrase() {

            return GetPhrase(Thread.CurrentThread.CurrentUICulture.LCID);

        }

        /// <summary>

        /// Gets the phrase for the current UI culrute

        /// </summary>

        public virtual string Phrase {

            get {

                return GetPhrase();

            }

            set {

                SetPhrase(value);

            }

        }

        public override int GetHashCode() {

            return Phrases.GetHashCode();

        }

        public override object Copy() {

            PhraseDictionary d = new PhraseDictionary();

            d.Name = Name;

            d.Phrases = new Dictionary<int, string>(Phrases);

            return d;

        }

        public override string ToString() {

            return Phrase;

        }

    }

}

And here is how we would hook it up onto e.g. the Name property of a Product domain object.

public interface IProduct {

    // contains all name translations

    // AllNames.Phrase gets/sets the translation for the current domain culture

    PhraseDictionary AllNames { get; set; }

}

This would allow us to set/receive the translation of name property conveniently as follows:

// set the culture to US english

Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");

IProduct p = new Product();

// sets product name in english

p.AllNames.Phrase = "Book";

// switch domain culture to german

Thread.CurrentThread.CurrentUICulture = new CultureInfo("de-DE");

// sets product name in german

p.AllNames.Phrase = "Buch";

// both translations have been stored

Debug.Assert(p.AllNames == 2);

// the current one should be german

Debug.Assert(p.AllNames.Phrase == "Buch");

To keep everything together. Here is the part you require in your Product mapping file:

<many-to-one name="AllNames"

  cascade="all-delete-orphan">

    </many-to-one>

One requirement was an easy use of the translations within HQL query. Here is an example of how we would fet all products sorted by the name of the current culture:

// Gets all products sorted by the name of the current culture

IList<Product> GetAllSortedByName() {

    string query = @"

        from Product product

        left outer join product.AllNames allNames 

        where index(allNames) = :lcid 

        order by allNames";

    IQuery q = NHibernateSession.CreateQuery(query);

    q.SetParameter("lcid", Thread.CurrentThread.CurrentUICulture.LCID);

    return q.List<Product>();

}

That was it. Thanks for having the read and I am looking forward to lots of feedback which could improve that approach.

Here are some quick remarks:
- I strongly recommend creating a DomainCulture class which encapsulates the current culture and how it is stored.
- Probably it would be useful to make the PhraseDictionary.Phrases readonly to the public.

As I always make notes while reading "geek" books I thought: "so why not summarize them all up in a nice list and blog'em". Here we go...

1. implicit vs explicit interface
implicit interface implementation allows to use the interface member through an object or through the interface whereas the explicit interface implementation allows only access through the interface.

Visual studio just offers the choice of the implementation but most people don't know the difference. With explicit implementation the server (implementing the interface) can prevent clients from using it directly on object which implements it. It forces that the members of the interfaces are only accessible via the interface itself

2. implicit vs explicit cast
this is just to get used to the terminology because a lot of guys are using it but don't know the terminology ;)

Here you see that implicit casting is assigning a class instance directly to a variable. Explicit means casting from one type to another.

3. Destructors
A destructor of a class is defined with ~ClassName. In comparison to Dispose() the C# destructor is always called. Dispose() needs to be called by the client whereas the destructor is called when the garbage collector comes around. Best way is to implement both and channel the implementation to the method which does the cleanup. e.g. cleanup. Example of implementation [COMP05, 98]:

Classes deriving from this baseclass can now implement their destruction by overriding the cleanup method and can now decide to do the clean up manually (calling Dispose) or leave it till the GC comes around. Important here is that if Dispose() was called we tell the garbage collector to exclude this instance from being garbaged later (with GC.SuppressFinalize()).

4. use "Using" defensive

This approach will only call Dispose() if the object implements IDisposeable. Good if you dont really know if the object needs to release resources or not and if you want to be ready for future changes. e.g. the server decides to implement IDisposeable.

5. Delegate inference

This is much nicer to read but only supported with .net 2.0.

6. Custom event arguments
Custom event arguments (own class derrived from EventArgs) should have only readonly members. This prevents the client from changing the values. Readonly members can only be assigned in the constructor so the publisher of the event is able to set the values when creating the arguments.

7. Always fire events in a try catch block
You never know what the event handler method of the client does, so its good to put the firing into a try catch block. You could write your own EventsHelper class [COMP05, 144] for the purpose of firing event within your classes.

8. use "property-like" approach for event accessors
As you do with common member variables (expressing them with properties) you also should do this with events. This alows you to control the adding and removing of event handlers for your event.

9. Static objects as keys

a static object is created to act as a key for e.g. collections (because every instance is unique - has its own identity!). The advantage in comparison to the "old school" version (key is a string) is that the key is already available in memory wheras the string needs to be created everytime. If you use this key in a lot of places it could save some time.

10. Combine enumeration values

This example illustrates that it is possible to have enumeration values which accept more than one existing values of the current enumeration.

11. Singelton Application
A singelton application is one which only allows running one instance per machine. e.g. Microsoft Outlook is a singelton application. Everytime the user starts the application it will check if an instance is already running. If its not running it will launch it otherwise it will focus to the current one. The source for an application which runs only once is available in another post "Singelton Application with C#"

12. Containment
If it is not possible to derive from a class we use a class to wrap around the class we would like to inherit from. This procedure is also known as "Containment" (I mention it here because the this term is more unknown - usually developers use wrapper)

13. Use Debug.Assert()
The use of Debug.Assert should be used as often as possible. During the development the developer should "assert" things which always should be true. This helps finding bugs easier and its easier for other developers to understand the code.

This short example demonstrates that obviously the developer expects the variable "c" to be greater than 0. Why? Because in the next line he/she uses it for a dvision which would break with c = 0. If this is the case you would get an information seen in line 4. This concept is nice because it makes comments "active".

14. user string instead of String
String is just an alias for string and therefore its nicer to use the original type straight away. The same with int and Int32, etc.

15. Rethrowing exceptions

This piece of code rethrows the exception. The interesting thing here is that you dont need to specify the Exception explicitly. Just the keyword "throw" is enough to rethrow the exception.

15. Code exclusion with attributes and not with #if .. #endif

The advantage here is that the code is not reachable anymore if the condition is not met. This means that it will result in compile errors if you reference this method. #if ... #endif does not enforce this constraint. Its also nicer than the hash signs ;) Please check the MSDN Reference for more details about the conditional attribute.

Thats was it :) Hope there was something interesting and maybe new for everyone. I dont want to promote the book here but I really recommend it because it contains good content about programming with c# (and especially for component development) and should be read by every C# developer who wants to develop for enterprise.

Maybe you have some interesting tips & tricks which might be useful for others. Please be so nice and comment them... I am interested.

Resources:
[COMP05] .net Components, Juval Löwy, O'Reilly 2005 United States

The trick here is to get a cross-process communication because every application runs in its own process. This is achieved with a Mutex which is available system wide. We use the name of the application for the identification of the Mutex.

the source is inspired from the book ".net Components, Juval Löwy, O'Reilly 2005 United States" page 231

Let's have a look how this thing needs to be used. There are three constructors for the usage so the creation of instances can be done in various ways. Additionally an instance can be obtained by using the Parse method. Some examples of creation...

If we have to ore more time ranges we can check if they colide. In other words if they overlap or clash. Everything the same :)

We can also check if a given TimeSpan is within the range or even another TimeRange.

That should be it. Have fun with it and dont hasitate to drop me any feedback about this stuff or even extensions.

Overview of C# TimeRange:

• Parsing a timerange out of a string (supports various formats)
• Parses also TimeSpan from a string (ParseTimeSpan method)
• Collision detection of two timeranges (inclusive and exclusive)
• Detection of a given TimeSpan is within the Range
• Equality check of time ranges
• Formatting in a user friendly way (ToString overridden)

The TimeRange for C# tested with .net framework 2.0 can be downloaded here...

TimeRange class for C#