Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Assemblers/DtoAssembler.cs
===================================================================
diff -u -r4000 -r4052
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Assemblers/DtoAssembler.cs	(.../DtoAssembler.cs)	(revision 4000)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Assemblers/DtoAssembler.cs	(.../DtoAssembler.cs)	(revision 4052)
@@ -26,247 +26,246 @@
 using System.Reflection;
 using System.Xml.Linq;
 
-namespace Deltares.DamEngine.Calculators.KernelWrappers.Assemblers
+namespace Deltares.DamEngine.Calculators.KernelWrappers.Assemblers;
+
+#region DtoAssembler<TDomainObject, TDataTransferObject> definition
+
+/// <summary>
+/// Default implementation for the <see cref="IDtoAssembler"/> interface
+/// </summary>
+/// <typeparam name="T">The domain object type</typeparam>
+public abstract class DtoAssembler<TDomainObject, TDataTransferObject> : IDtoAssembler<TDomainObject, TDataTransferObject>
+    where TDomainObject : new()
 {
-    #region DtoAssembler<TDomainObject, TDataTransferObject> definition
+    /// <summary>
+    /// Holds the property mappings
+    /// </summary>
+    private readonly DtoPropertyAttributeMap map = new DtoPropertyAttributeMap();
 
     /// <summary>
-    /// Default implementation for the <see cref="IDtoAssembler"/> interface
+    /// Gets the property mappings collection
     /// </summary>
-    /// <typeparam name="T">The domain object type</typeparam>
-    public abstract class DtoAssembler<TDomainObject, TDataTransferObject> : IDtoAssembler<TDomainObject, TDataTransferObject>
-        where TDomainObject : new()
+    protected DtoPropertyAttributeMap Mappings
     {
-        /// <summary>
-        /// Holds the property mappings
-        /// </summary>
-        private readonly DtoPropertyAttributeMap map = new DtoPropertyAttributeMap();
-
-        /// <summary>
-        /// Gets the property mappings collection
-        /// </summary>
-        protected DtoPropertyAttributeMap Mappings
+        get
         {
-            get
-            {
-                return map;
-            }
+            return map;
         }
+    }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        protected void InitializeMappings()
-        {
-            var tmp = new TDomainObject();
-            map.AddOrUpdateRange(tmp.ToPropertyMap());
-        }
+    /// <summary>
+    /// 
+    /// </summary>
+    protected void InitializeMappings()
+    {
+        var tmp = new TDomainObject();
+        map.AddOrUpdateRange(tmp.ToPropertyMap());
+    }
 
-        /// <summary>
-        ///
-        /// </summary>
-        protected void InitializeMappings(string elementName, XDocument xsdReferenceDocument)
+    /// <summary>
+    ///
+    /// </summary>
+    protected void InitializeMappings(string elementName, XDocument xsdReferenceDocument)
+    {
+        var tmp = new TDomainObject();
+        IEnumerable<DtoPropertyAttributeMapping> tmpMap = tmp.ToPropertyMap(elementName, xsdReferenceDocument);
+        map.AddOrUpdateRange(tmpMap);
+    }
+
+    /// <summary>
+    /// Adds or updates a property-to-attribute mapping item into the property map
+    /// </summary>
+    /// <param name="propertyName">The name of the property</param>
+    /// <param name="attributeName">The name of the attribute to map to</param>
+    protected void AddOrUpdateMapping(string propertyName, string attributeName)
+    {
+        AddOrUpdateMapping(propertyName, attributeName, DtoPropertyImportance.Optional);
+    }
+
+    /// <summary>
+    /// Adds or updates a property-to-attribute mapping item into the property map
+    /// </summary>
+    /// <param name="propertyName">The name of the property</param>
+    /// <param name="attributeName">The name of the attribute to map to</param>
+    /// <param name="importance">The usage or importance of the value i.e. reguired or optional</param>
+    protected void AddOrUpdateMapping(string propertyName, string attributeName, DtoPropertyImportance importance)
+    {
+        if (!propertyName.HasValidStringValue())
         {
-            var tmp = new TDomainObject();
-            IEnumerable<DtoPropertyAttributeMapping> tmpMap = tmp.ToPropertyMap(elementName, xsdReferenceDocument);
-            map.AddOrUpdateRange(tmpMap);
+            throw new DtoPropertyMapException("propertyName is not valid (empty or null)");
         }
 
-        /// <summary>
-        /// Adds or updates a property-to-attribute mapping item into the property map
-        /// </summary>
-        /// <param name="propertyName">The name of the property</param>
-        /// <param name="attributeName">The name of the attribute to map to</param>
-        protected void AddOrUpdateMapping(string propertyName, string attributeName)
+        bool q = (from x in new TDomainObject().GetType().GetProperties()
+                  where x.Name == propertyName
+                  select x).Any();
+
+        if (!q)
         {
-            AddOrUpdateMapping(propertyName, attributeName, DtoPropertyImportance.Optional);
+            throw new DtoPropertyMapException("The property you want to add or update doesnt exist in the property list of the domain object.");
         }
 
-        /// <summary>
-        /// Adds or updates a property-to-attribute mapping item into the property map
-        /// </summary>
-        /// <param name="propertyName">The name of the property</param>
-        /// <param name="attributeName">The name of the attribute to map to</param>
-        /// <param name="importance">The usage or importance of the value i.e. reguired or optional</param>
-        protected void AddOrUpdateMapping(string propertyName, string attributeName, DtoPropertyImportance importance)
-        {
-            if (!propertyName.HasValidStringValue())
-            {
-                throw new DtoPropertyMapException("propertyName is not valid (empty or null)");
-            }
+        Mappings.AddOrUpdate(propertyName, attributeName, importance);
+    }
 
-            bool q = (from x in new TDomainObject().GetType().GetProperties()
-                      where x.Name == propertyName
-                      select x).Any();
+    #region IDtoAssembler<TDomainObject,TDataTransferObject> Members
 
-            if (!q)
-            {
-                throw new DtoPropertyMapException("The property you want to add or update doesnt exist in the property list of the domain object.");
-            }
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="dtoObj"></param>
+    /// <returns></returns>
+    public abstract TDomainObject CreateDomainObject(TDataTransferObject dtoObj);
 
-            Mappings.AddOrUpdate(propertyName, attributeName, importance);
-        }
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="domainObj"></param>
+    /// <returns></returns>
+    public abstract TDataTransferObject CreateDataTransferObject(TDomainObject domainObj);
 
-        #region IDtoAssembler<TDomainObject,TDataTransferObject> Members
+    #endregion
+}
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="dtoObj"></param>
-        /// <returns></returns>
-        public abstract TDomainObject CreateDomainObject(TDataTransferObject dtoObj);
+#endregion
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="domainObj"></param>
-        /// <returns></returns>
-        public abstract TDataTransferObject CreateDataTransferObject(TDomainObject domainObj);
+#region DtoAssembler<TDomainObject, XElement>
 
-        #endregion
-    }
+/// <summary>
+/// Default implementation for the <see cref="IDtoAssembler"/> interface
+/// </summary>
+/// <remarks>
+/// This base class inherits from <see cref="DtoAssembler"/> this class just fixes 
+/// the dto type to XElement
+/// </remarks>
+/// <typeparam name="T">The domain object type</typeparam>
+public abstract class DtoAssembler<TDomainObject> : DtoAssembler<TDomainObject, XElement>, IDtoAssembler<TDomainObject>
+    where TDomainObject : new()
+{
+    /// <summary>
+    /// Initializes a new instance of the DtoAssembler class
+    /// </summary>
+    /// <param name="elementName">Sets the element name</param>
+    /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
+    public DtoAssembler(string elementName, Stream xsdStream)
+        : this(elementName, null, xsdStream) {}
 
-    #endregion
+    /// <summary>
+    /// Initializes a new instance of the DtoAssembler class
+    /// </summary>
+    /// <param name="elementName">Sets the element name</param>
+    /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
+    public DtoAssembler(string elementName, string elementNamespace)
+        : this(elementName, elementNamespace, null) {}
 
-    #region DtoAssembler<TDomainObject, XElement>
-
     /// <summary>
-    /// Default implementation for the <see cref="IDtoAssembler"/> interface
+    /// Initializes a new instance of the DtoAssembler class
     /// </summary>
-    /// <remarks>
-    /// This base class inherits from <see cref="DtoAssembler"/> this class just fixes 
-    /// the dto type to XElement
-    /// </remarks>
-    /// <typeparam name="T">The domain object type</typeparam>
-    public abstract class DtoAssembler<TDomainObject> : DtoAssembler<TDomainObject, XElement>, IDtoAssembler<TDomainObject>
-        where TDomainObject : new()
+    /// <param name="elementName">Sets the element name</param>
+    /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
+    public DtoAssembler(string elementName, string elementNamespace, Stream xsdStream)
     {
-        /// <summary>
-        /// Initializes a new instance of the DtoAssembler class
-        /// </summary>
-        /// <param name="elementName">Sets the element name</param>
-        /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
-        public DtoAssembler(string elementName, Stream xsdStream)
-            : this(elementName, null, xsdStream) {}
+        ElementName = elementName;
+        ElementNamespace = elementNamespace;
 
-        /// <summary>
-        /// Initializes a new instance of the DtoAssembler class
-        /// </summary>
-        /// <param name="elementName">Sets the element name</param>
-        /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
-        public DtoAssembler(string elementName, string elementNamespace)
-            : this(elementName, elementNamespace, null) {}
-
-        /// <summary>
-        /// Initializes a new instance of the DtoAssembler class
-        /// </summary>
-        /// <param name="elementName">Sets the element name</param>
-        /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
-        public DtoAssembler(string elementName, string elementNamespace, Stream xsdStream)
+        if (xsdStream == null)
         {
-            ElementName = elementName;
-            ElementNamespace = elementNamespace;
-
-            if (xsdStream == null)
-            {
-                xsdStream = GetXsdStreamFromEmbeddedResource();
-            }
-
-            XDocument doc = XDocument.Load(new StreamReader(xsdStream));
-            Schema = doc;
-            InitializeMappings(elementName, doc);
+            xsdStream = GetXsdStreamFromEmbeddedResource();
         }
 
-        /// <summary>
-        /// Gets or sets the namespace value for the element
-        /// </summary>
-        public string ElementNamespace { get; }
+        XDocument doc = XDocument.Load(new StreamReader(xsdStream));
+        Schema = doc;
+        InitializeMappings(elementName, doc);
+    }
 
-        /// <summary>
-        /// Gets the xml schema (if any)
-        /// </summary>
-        public XDocument Schema { get; }
+    /// <summary>
+    /// Gets or sets the namespace value for the element
+    /// </summary>
+    public string ElementNamespace { get; }
 
-        public Stream GetXsdStreamFromEmbeddedResource()
+    /// <summary>
+    /// Gets the xml schema (if any)
+    /// </summary>
+    public XDocument Schema { get; }
+
+    public Stream GetXsdStreamFromEmbeddedResource()
+    {
+        if (string.IsNullOrEmpty(ElementNamespace))
         {
-            if (string.IsNullOrEmpty(ElementNamespace))
-            {
-                return null;
-            }
+            return null;
+        }
 
-            Assembly assembly = GetType().Assembly;
-            string schemaName = ElementNamespace.Substring(ElementNamespace.LastIndexOf('/') + 1);
-            schemaName += schemaName.EndsWith(".xsd") ? "" : ".xsd";
+        Assembly assembly = GetType().Assembly;
+        string schemaName = ElementNamespace.Substring(ElementNamespace.LastIndexOf('/') + 1);
+        schemaName += schemaName.EndsWith(".xsd") ? "" : ".xsd";
 
-            string resourceName = (from string name in assembly.GetManifestResourceNames()
-                                   where name.EndsWith(schemaName)
-                                   select name).Single();
+        string resourceName = (from string name in assembly.GetManifestResourceNames()
+                               where name.EndsWith(schemaName)
+                               select name).Single();
 
-            return assembly.GetEmbeddedFile(resourceName);
-        }
+        return assembly.GetEmbeddedFile(resourceName);
+    }
 
-        public virtual TDomainObject CreateDomainObject(XDocument dtoDocument)
+    public virtual TDomainObject CreateDomainObject(XDocument dtoDocument)
+    {
+        if (dtoDocument == null)
         {
-            if (dtoDocument == null)
-            {
-                throw new ArgumentNullException("dtoDocument");
-            }
+            throw new ArgumentNullException("dtoDocument");
+        }
 
-            XElement el = null;
-            el = (from x in dtoDocument.Descendants()
-                  where x.Name.LocalName == ElementName
-                  select x).Single();
+        XElement el = null;
+        el = (from x in dtoDocument.Descendants()
+              where x.Name.LocalName == ElementName
+              select x).Single();
 
-            return CreateDomainObject(el);
-        }
+        return CreateDomainObject(el);
+    }
 
-        #region IDtoAssembler<TDomainObject> Members
+    #region IDtoAssembler<TDomainObject> Members
 
-        /// <summary>
-        /// Gets the xml element name
-        /// </summary>
-        public string ElementName { get; }
+    /// <summary>
+    /// Gets the xml element name
+    /// </summary>
+    public string ElementName { get; }
 
-        /// <summary>
-        /// Creates and materialized a data tranfer object (dto) from a domain object
-        /// </summary>
-        /// <param name="domainObj">The domain object</param>
-        /// <returns>An XElement instance</returns>
-        public override XElement CreateDataTransferObject(TDomainObject domainObj)
+    /// <summary>
+    /// Creates and materialized a data tranfer object (dto) from a domain object
+    /// </summary>
+    /// <param name="domainObj">The domain object</param>
+    /// <returns>An XElement instance</returns>
+    public override XElement CreateDataTransferObject(TDomainObject domainObj)
+    {
+        if (domainObj == null)
         {
-            if (domainObj == null)
-            {
-                return null;
-            }
+            return null;
+        }
 
-            if (!ElementName.HasValidStringValue())
-            {
-                throw new DtoAssemblerException("There is no element name specified");
-            }
-
-            if (ElementNamespace.HasValidStringValue())
-            {
-                XNamespace ns = ElementNamespace;
-                return new XElement(ns + ElementName)
-                    .Materialize(domainObj, Mappings);
-            }
-
-            return new XElement(ElementName)
-                .Materialize(domainObj, Mappings);
+        if (!ElementName.HasValidStringValue())
+        {
+            throw new DtoAssemblerException("There is no element name specified");
         }
 
-        /// <summary>
-        /// Creates and materializes a domain object from a data tranfer object (dto)
-        /// </summary>
-        /// <param name="dtoObj">The dto object</param>
-        /// <returns>The materialized domain object</returns>
-        public override TDomainObject CreateDomainObject(XElement dto)
+        if (ElementNamespace.HasValidStringValue())
         {
-            return new TDomainObject().Materialize(dto, Mappings);
+            XNamespace ns = ElementNamespace;
+            return new XElement(ns + ElementName)
+                .Materialize(domainObj, Mappings);
         }
 
-        #endregion
+        return new XElement(ElementName)
+            .Materialize(domainObj, Mappings);
     }
 
+    /// <summary>
+    /// Creates and materializes a domain object from a data tranfer object (dto)
+    /// </summary>
+    /// <param name="dtoObj">The dto object</param>
+    /// <returns>The materialized domain object</returns>
+    public override TDomainObject CreateDomainObject(XElement dto)
+    {
+        return new TDomainObject().Materialize(dto, Mappings);
+    }
+
     #endregion
-}
\ No newline at end of file
+}
+
+#endregion
\ No newline at end of file