Index: dam engine/branches/Initial Source/Deltares.DamEngine.Data/Standard/ObjectExtensions.cs
===================================================================
diff -u -r303 -r330
--- dam engine/branches/Initial Source/Deltares.DamEngine.Data/Standard/ObjectExtensions.cs	(.../ObjectExtensions.cs)	(revision 303)
+++ dam engine/branches/Initial Source/Deltares.DamEngine.Data/Standard/ObjectExtensions.cs	(.../ObjectExtensions.cs)	(revision 330)
@@ -22,6 +22,8 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
 using System.Linq;
 using System.Reflection;
 
@@ -32,6 +34,7 @@
     /// </summary>
     public static class ObjectExtensions
     {
+        public static readonly CultureInfo DefaultCulture = new CultureInfo("nl-NL");
         private const double threshold = 0.0000001;
 
         /// <summary>
@@ -67,6 +70,167 @@
             return (Math.Abs(double1 - double2) <= precision);
         }
 
+        /// <summary>
+        /// Converts an object to another type. Also works with nullable types. The <see cref="System.Convert"/> method can't.
+        /// </summary>
+        /// <remarks>
+        /// Also works with nullable types and enums. The <see cref="System.Convert"/> method can't do this.
+        /// </remarks>
+        /// <typeparam name="T">The type to converto to</typeparam>
+        /// <param name="value">The object to convert</param>
+        /// <returns>The converted object</returns>
+        /// <exception cref="ArgumentNullException">When <paramref name="value"/> is null and <typeparamref name="T"/> name="type"/> is value type and not nullable.</exception>
+        /// <exception cref="ConversionException">When an error occurs during conversion.</exception>
+        public static T ToType<T>(this object value)
+        {
+            if (value == null)
+            {
+                ThrowIfValueType<T>();
+
+                return default(T);
+            }
+
+            return (T)value.ToType(typeof(T), DefaultCulture);
+        }
+
+        /// <summary>
+        /// Converts an object to another type. 
+        /// </summary>
+        /// <remarks>
+        /// Also works with nullable types and enums. The <see cref="System.Convert"/> method can't do this.
+        /// This method can also be used to downcast numeric values for example from string (double) value "12,0" to short 12
+        /// When trying to convert a string to double and the dutch culture is set, then this method tries to 
+        /// parse the string with custom logic. Because it occures that some string are not properly 
+        /// changed according to the current culture. For instance in dbf files where numeric values are stored as 
+        /// strings (for example "10,23") 
+        /// Use this method with care when high performance is required it is not yet tested with large data sets
+        /// </remarks>
+        /// <param name="value">The value to convert</param>
+        /// <param name="type">The target type to convert to</param>
+        /// <param name="culture"> </param>
+        /// <returns>The converted type</returns>
+        /// <exception cref="ArgumentNullException">When <paramref name="value"/> is null and <paramref name="type"/> is value type and not nullable.</exception>
+        /// <exception cref="ConversionException">When an error occurs during conversion.</exception>
+        public static object ToType(this object value, Type type, CultureInfo culture)
+        {
+            if (value == null)
+            {
+                ThrowIfValueType(type);
+
+                return null;
+            }
+
+            if (type.IsEnum)
+            {
+                return value.ToEnumType(type);
+            }
+
+            object result = null;
+
+            if (IsNullable(type))
+            {
+                try
+                {
+                    var nullableConverter = new NullableConverter(type);
+                    type = nullableConverter.UnderlyingType;
+                    result = Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
+                }
+                catch
+                {
+                    result = null;
+                }
+            }
+            else
+            {
+                try
+                {
+                    if (type == typeof(double) && value is string)
+                    {
+                        if (Equals(culture, new CultureInfo("nl-NL")))
+                        {
+                            // TODO: Needs to be tested !! 
+                            // TODO: replace parsing with regular expression
+                            // TODO: to make this more flexible make parser injectable through lambda's
+
+                            var tmp = value as string;
+                            if (tmp.Contains(",") && !tmp.Contains(".")) // 1,5 -> 1.5
+                            {
+                                value = tmp.Replace(",", ".");
+                            }
+                            else if (tmp.Contains(",") && tmp.Contains(".") && tmp.Length > 4 && !tmp.Contains(" "))
+                            {
+                                // 100,000.00 -> 100000.00
+                                value = tmp.Replace(",", "");
+                            }
+
+                            //TODO:  how to handle 100,000 english notation? Seems not to occur in most/mabye all situations                             
+                        }
+                        result = value.Equals("NaN") ? Double.NaN : Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
+                    }
+                    else
+                    {
+                        // value needs to be downcasted
+
+                        switch (type.Name)
+                        {
+                            case "SByte":
+                            case "Byte":
+                            case "Int16":
+                            case "UInt16":
+                            case "Int32":
+                            case "UInt32":
+                            case "Int64":
+                            case "UInt64":
+                                var tmp = Convert.ChangeType(value, typeof(double), CultureInfo.InvariantCulture);
+                                result = Convert.ChangeType(tmp, type);
+                                break;
+                            default:
+                                result = Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
+                                break;
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    ThrowConversionException(value, type, e);
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Convert the value to the enum type
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <param name="type">The type to convert to.</param>
+        /// <param name="ignoreCase">Ignores the case if set to true</param>
+        /// <returns>The enum</returns>
+        public static object ToEnumType(this object value, Type type, bool ignoreCase = false)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException("value");
+            }
+
+            if (!ignoreCase && !Enum.IsDefined(type, value))
+            {
+                ThrowConversionException(value, type, null);
+            }
+
+            string stringVal = value.ToString();
+            object result = null;
+            try
+            {
+                result = Enum.Parse(type, stringVal, ignoreCase);
+            }
+            catch (Exception e)
+            {
+                ThrowConversionException(value, type, e);
+            }
+            return result;
+        }
+
         /// <summary>  
         /// Clone properties from an original object to a destination object.  
         /// </summary>  
@@ -135,5 +299,56 @@
             return typeof(IList).IsAssignableFrom(destinationProperty.PropertyType);
         }
 
+        /// <summary>
+        /// Throws an ArgumentNullException if target type to convert to is a ValueType.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        private static void ThrowIfValueType<T>()
+        {
+            ThrowIfValueType(typeof(T));
+        }
+
+        /// <summary>
+        /// Throws an ArgumentNullException if target type to convert to is a ValueType.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        private static void ThrowIfValueType(Type type)
+        {
+            if (type.IsValueType && !IsNullable(type))
+            {
+                throw new ArgumentNullException(
+                    string.Format("The value can't be null because parameter type {0} is a value type", type));
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the specified type is nullable.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified type is nullable; otherwise, <c>false</c>.
+        /// </returns>
+        private static bool IsNullable(Type type)
+        {
+            return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
+        }
+
+        /// <summary>
+        /// Throws conversion exception.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="e">The exception.</param>
+        private static void ThrowConversionException(object value, Type type, Exception e)
+        {
+            string v = "";
+            try
+            {
+                v = value.ToString().Replace("\0", " ");
+            }
+            catch { }
+
+            throw new ConversionException(type, v, e);
+        }
     }    
 }
\ No newline at end of file