In an old post I dealt with a possible implementation of a BaseEntity class that stores all properties in a State object (based on a dictionary to store properties). Technically speaking, this solution have no drawbacks respect using field variables to store properties values, but it can give a lot of benefit. If you see the object from the outside, it presents a bunch of properties and thanks to encapsulation you can use the technique you prefer to store the real data inside the object. This approach has some drawbacks, first of all accessing the value of a property can be slower, because you need to find the value inside a dictionary instead of reading directly from a memory location (the field value). Another drawback is that I use the property names as dictionary keys, so you waste more memory to store the keys of the state dictionary, but you can limit this problem using string interning.

This model has indeed some advantages respect using field variables, first of all you can easily find the value of every property from the String representation without the need of reflection. One of the first advantage is the ability to Deep Clone an object with a simple routine.

public virtual T Clone<T>() where T : BaseEntity

{

    return (T) Clone();

}

public virtual BaseEntity Clone()

{

    BaseEntity newEntity = (BaseEntity)

                           Activator.CreateInstance(GetType(), true);

    newEntity._state = State.Clone();

    return newEntity;

}

As you can verify from the code I simply create another instance of the entity, then simply assign a clone of the original status to the new entity.

public State Clone()

{

    State clone = new State();

    foreach (var o in _state)

    {

        if (o.Value is BaseEntity)

        {

            //we need to deep clone this entity.

            BaseEntity be = o.Value as BaseEntity;

            clone._state.Add(o.Key, be.Clone());

        }

        else if (o.Value is IEnumerable<BaseEntity>)

        {

            //need to deep clone a collection

            IEnumerable<BaseEntity> be = o.Value as IEnumerable<BaseEntity>;

            IList copiedbe = Activator.CreateInstance(be.GetType()) as IList;

            foreach (var entity in be)

            {

                copiedbe.Add(entity.Clone());

            }

            clone._state.Add(o.Key, copiedbe);

        }

        else

        {

            clone._state.Add(o.Key, o.Value);

        }

    }

    return clone;

}

Clone method is quite simple and it is not tested in all scenario (I’ve tested for basic classes) but it works quite well and solves easily the needs to deep clone an object. I’m not sure that in strong OOP oriented software Deep Cloning is a needed thing, but when you work with ORM and User Type (more in future posts), it is quite useful.

Gian Maria

After lots of year working with NHibernate I started to think that probably the whole concept of ORM can be considered an Antipattern. Some people prefer a “classic” approach to the problem, data is the key concept and most of the logic is inside a storage based on Relational Model.

Is this wrong?

Absolutely not, after all, for many years this was the preferred way to structure your application, and it worked quite well, but after OOP has come to life, a lot of people started appreciating this new paradigm of programming and started to think in terms of “objects” instead of “data”.

This is a radical shift, because if you really possess “object thinking”, you tend to subdivide the problem in objects that  have methods instead that in table that have relations. This lead to an obvious problem, since we need to store the data somewhere and since we already have good Relational Database Engine, the simplest solution is finding a way to save Objects in Relational Storage system and an ORM is the answer.

But after years of ORM the initial enthusiasm is completely passed away and I start believing that I’m forcing a square peg in a round hole.

Since most programmers started to work in terms of data and relations (after all university taught us to think in this way), using an ORM lead usually to highly anemic domain and tend to lead people of thinking in term of objects that have state (properties) and relations with other objects instead of object that have methods and communicates with other objects (with events).

If you start designing your entities from their state (properties) it could be the sign that you moved from “tables with relations and stored procedures that operates on tables” to “objects with relations and services that operates on objects”, and you need to realize that the situation is not changed very much.

When people start to have problems with Session duration, Lazy Loading, eager fetching (or other issue related to ORM), is the sign that the square peg is not fitting in the round hole and the ORM becomes the Hammer that forces it down (usually bringing some pain with it).

This means that if you want to do OOP you should move everything to NoSql?

Absolutely not, because sometimes you will probably find yourself forcing a round peg in a square hole . I’m starting to think that in a real, big, complex OOP project, you need to have both type of storage: Relational and Object based. This will give you  round holes and the square holes, so you can put each peg in the right place.

At least until some new technology comes to life that bring us a new Hexagonal Peg that will need an Hexagonal shaped data storage .

Gian Maria.

I’ve stumbled upon this funny comic

I usually use long Random generated password, that I store in KeePass for all services that I really care about, (home banking, amazon account that has my credit card, etc), and tend to use easy to remember password for services I do not care very much (stupid online games, or stuff like that).

This funny comics suggests that choosing some four random common words can be a viable solution (complex to guess, but easy to remember), but sadly enough some online services does not permits you to use long password, or password that use special chars etc. My online banks forced me to choose a 10 digit number as the password o_O, another online service told me to use a password between 6 and 18 chars, but only letters, numbers are allowed, Another one forced me to use at leas one uppersize, and one digit, but limits the length to 20 chars, etc etc. My question is “why in the hell a service should limit my possibilities to choose a password I like?”.

Having such restrictions is quite annoying, because if you have a mental scheme to choose passwords, password complexity rules quite often render this scheme not valid, forcing you to use a password that will be hard to remember (thanks to keepass this is much more easier) and not more secure. And what about a Chinese or Japanese user that want to choose a password composed of Kanji characters? Maybe he want to use Kanji of Spring, mountain, sky, because it is easy for her to remember a blue mountain sky on spring.

I’m not a cryptography expert, but usually password are stored in HASHED format with a SALT (beware of Italian Railway system, last year I clicked “lost my password” and they sent me the password in CLEAR format on my e-mail O_o), this means that the user could choose an arbitrary sequence of Unicode chars, because it is simply a stream of bytes that will be hashed producing another stream of bytes of Fixed Length that can be stored in a database without problems, even if the user choose a 100 character password, the hash length is always the same.

Given this, is there really a reason to impose restrictions on password complexity? In my opinion the only restriction should be in the length, prohibiting really short password to avoid really easy-to-guess password, but every Unicode charachter should be acceptable and there should be no maximum password length, no specific char requirements (es. at least one digit, at least one Uppercase char), if I trust my KeePass program to generate a cryptography random sequence of 32 chars, or if I want to use an Haiku I like, why you should limit my freedom in choosing my password?

Alk.

Scenario: I have some service that runs in the background, but I want the user to be able to launch interactively with a  windows form application and I want to intercept all log4net messages issued by the various components that works in the background.

Thanks to the supereasy way to write an appender in log4net, obtaining this result is really simple..

   1: public class Log4NetLogEventSourceAppender : AppenderSkeleton

   2:    {

   3:        private Object _syncRoot;

   4:  

   5:        public Log4NetLogEventSourceAppender()

   6:        {

   7:            _syncRoot = new object();

   8:        }

   9:  

  10:        /// <summary>

  11:        /// Occurs when [on log].

  12:        /// </summary>

  13:        public static event EventHandler<OnLog4NetLogEventArgs> OnLog;

  14:  

  15:        protected override void Append(LoggingEvent loggingEvent)

  16:        {

  17:            EventHandler<OnLog4NetLogEventArgs> temp = OnLog;

  18:            if (temp != null)

  19:            {

  20:                lock (_syncRoot)

  21:                {

  22:                    temp(null, new OnLog4NetLogEventArgs(loggingEvent));

  23:                }

  24:            }

  25:        }

  26:  

  27:    }

  28:  

  29:    public class OnLog4NetLogEventArgs : EventArgs

  30:    {

  31:        public LoggingEvent LoggingEvent { get; private set; }

  32:  

  33:        public OnLog4NetLogEventArgs(LoggingEvent loggingEvent)

  34:        {

  35:            LoggingEvent = loggingEvent;

  36:        }

  37:    }

This is a quick and dirty approach, a _syncRoot object will serialize all events because this is a shared event I want to prevent multiple threads to messup logging. Thanks to the shared event you can simply add this appender to the list of enabled appender.

   1: <appender

   2:     name="Interceptor"

   3:     type="xxx.Log4NetLogEventSourceAppender, xxx">

   4:     <layout type="log4net.Layout.PatternLayout">

   5:       <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline %property{analyzing_url}" />

   6:     </layout>

   7:   </appender>

Now in code you should simply subscribe to appender event.

   1: Log4NetLogEventSourceAppender.OnLog += Log4NetLogEventSourceAppender_OnLog;

And do something useful in the event handler, in my program I have a custom MVP pattern, and I simply add the log the to the view (that in turn shows a grid with all the logs with filtering and sorting capabilities).

   1: void Log4NetLogEventSourceAppender_OnLog(object sender, OnLog4NetLogEventArgs e)

   2: {

   3:      View.AppendLog(e.LoggingEvent);

   4: }

Thanks to the extremely flexibility of log4net it is possible to manage logs in a great variety of locations, and with this simple interceptor you can propagate logging wherever you want.

Another useful application of this logger was made in a scheduled service,

   1: private void ReactToLogMessages(OnLog4NetLogEventArgs e, StringBuilder log4netLogs, ScanLog scanLog)

   2: {

   3:     if (e.LoggingEvent.Level >= log4net.Core.Level.Info)

   4:     {

   5:         log4netLogs.AppendLine(e.LoggingEvent.RenderedMessage);

   6:     }

   7:     //ora capire il livello di errore

   8:     if (e.LoggingEvent.Level == log4net.Core.Level.Warn)

   9:     {

  10:         scanLog.NumOfWarnings++;

  11:     }

  12:     else if (e.LoggingEvent.Level == log4net.Core.Level.Error)

  13:     {

  14:         scanLog.NumOfErrors++;

  15:     }

  16: }

This function simply append all info or greater logs to a string, but the most important fact is that he count the number of warning and errors, and after the task finish, it warn the administrator if there are errors or more than a certain number of warning. This will make simple to react to task that have problems.

Alk.

Some days ago I blogged about an implementation of persistent cache component based on Managed Esent and PersistentDictionary. This component is injected into other components thanks to Inversion of Control and it is a Singleton object.

Being a singleton is a requisite because it permits to different dependent objects to share the same cache, moreover PersistentDictionary does not permit to have multiple instances that insists on the same directory. This will make EsentCache a perfect candidate of Singleton Object Pattern. Now another dilemma arise, since PersistentDictionary implements IDisposable to flush all resources into disk, who will call Dispose on a Singleton object?

The solution is obvious, this is a duty of the Inversion Of Control engine you use and this is another reason to base your architecture with Dependency Injection in mind. With a IoC container, being a singleton is a “property” of registered instance making the IoC container responsible of the lifecycle of the singleton. In my application there is a static IoC class (a service locator pattern) used by infrastructural code to create objects, based on Castle.Windsor container. Since a WindsorContainer is a Disposable object I want to be sure that it got disposed when the application exit.

   1: static IoC()

   2: {

   3:     AppDomain.CurrentDomain.ProcessExit += new EventHandler(CurrentDomain_ProcessExit);

   4:     BaseInitialization();

   5: }

Static constructor will set an handler for ProcessExit event of current domain. This event have a special purpose, as you can read in MSDN documentation

The EventHandler for this event can perform termination activities, such as closing files, releasing storage and so on, before the process ends.

The only drawback is that the execution time of this method is limited as explained in the documentation

Note:

The total execution time of all ProcessExit event handlers is limited, just as the total execution time of all finalizers is limited at process shutdown. The default is two seconds. An unmanaged host can change this execution time by calling the ICLRPolicyManager::SetTimeout method with the OPR_ProcessExit enumeration value.

This could be a problem, because shutting down the IoC engine will call dispose method for each singleton object that was resolved and we cannot anticipate how time this operation will need, but we have no other option to have a fallback technique to avoid people forgetting to call dispose on the IoC container.

The implementation of the event handler is really simple

   1: static void CurrentDomain_ProcessExit(object sender, EventArgs e)

   2: {

   3:     Shutdown();

   4: }

All work is delegated to the Shutdown() event, this will make possible for programs to dispose the IoC engine gracefully. For windows program you can simple put a call to Shutdown before the end of Main() method, this will pose no limit on Shutdown execution time, but if for some reason, people forgets to call Shutdown explicitly when the application is ending, resources will be released thanks to the ProcessExit event handler.

alk.

I have a program where components could depend from cache, implemented by ICache interface.

I have really different types of cache, for data that needs to be temporary stored in memory I use a cache component based on enterprise library, but there are components that logically needs a cache that will survive after the process will exit.

The first and obvious solution was to create a very simple component that stores cache data on application database, this is especially useful because program running from different computer could share the same cache with no problem. (program was born when Velocity still not exists, and we decided to keep everything really simple)

The main drawback to this approach is the traffic to the database, and we have some specific part of the application based on windows client that communicates over WCF, and deployed outside our organization.

The first solution was to deploy a sql server express with the application, and use the very same cache component based on database, but this solution has some drawback, because we want to keep the installer simple, and not all users likes to have a SQLExpress on their machine, so we need a different solution based on file system.

A simple and quick solution was using a PersistentDictionary based on Esent. To keep performances good, I stored all the data needed to query the cache (Key, Timestamp, ..) in a separate PersistentDictionary.

   1: private class EsentDb

   2:  {

   3:      private PersistentDictionary<String, CacheToken> _keyDatabase;

   4:      private PersistentDictionary<String, String> _valueDatabase;

Code is really simple, because I rely on object serialization to store complex object into a string, with few lines of code and some test now I have a persistent cache that requires no other component, thanks to ESENT.

alk.

There are a lot of rules for usability of User Interface, and one of the most important one is not to clutter the user with strange error messages. Since the last update of skype, sometimes when I’m chatting with someone a “really useful” message box appears.

This windows does not communicate nothing to the user, moreover if you click ok nothing happens… skype continue to work with no problem. This design violates some best practice of the UI.

1. It shows a completely unnecessary and obscure message to the user
2. It presents only the Ok button, so the user cannot choose any options. A Modal dialog box should be used when the user need to choose an option.
3. It shows a Red Cross, but the program works perfectly after this error.
4. This messagebox popup in front of every windows, distracting the user and adding no value to UI.

Such a message would be better handled in this way.

• Since the program can continue to work after this event, log this information in a logfile, and maybe use a little "communication box” in the interface, instead of a modal messagebox with only an option.
• Send a logfile to the team, if this is an error, the development team can handle it an find a bug, the user does not need to see what is happened behind the curtain.

alk.