Esempio n. 1
0
        private void GetChildNode(ConfigurationScope configScope)
        {
            ResultProperty property = null;
            SubMap         subMap   = null;
            XmlNodeList    list     = configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix("constructor/argument"), configScope.XmlNamespaceManager);

            if (list.Count > 0)
            {
                Type[]   types          = new Type[list.Count];
                string[] parametersName = new string[list.Count];
                for (int i = 0; i < list.Count; i++)
                {
                    ArgumentProperty property2 = ArgumentPropertyDeSerializer.Deserialize(list[i], configScope);
                    this._parameters.Add(property2);
                    parametersName[i] = property2.ArgumentName;
                }
                ConstructorInfo constructor = this.GetConstructor(this._class, parametersName);
                for (int j = 0; j < this._parameters.Count; j++)
                {
                    ArgumentProperty property3 = (ArgumentProperty)this._parameters[j];
                    configScope.ErrorContext.MoreInfo = "initialize argument property : " + property3.ArgumentName;
                    property3.Initialize(configScope, constructor);
                    types[j] = property3.MemberType;
                }
                this._objectFactory = configScope.SqlMapper.ObjectFactory.CreateFactory(this._class, types);
            }
            else if (Type.GetTypeCode(this._class) == TypeCode.Object)
            {
                this._objectFactory = configScope.SqlMapper.ObjectFactory.CreateFactory(this._class, Type.EmptyTypes);
            }
            foreach (XmlNode node in configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix("result"), configScope.XmlNamespaceManager))
            {
                property = ResultPropertyDeSerializer.Deserialize(node, configScope);
                configScope.ErrorContext.MoreInfo = "initialize result property: " + property.PropertyName;
                property.Initialize(configScope, this._class);
                this._properties.Add(property);
            }
            XmlNode node2 = configScope.NodeContext.SelectSingleNode(DomSqlMapBuilder.ApplyMappingNamespacePrefix("discriminator"), configScope.XmlNamespaceManager);

            if (node2 != null)
            {
                configScope.ErrorContext.MoreInfo = "initialize discriminator";
                this.Discriminator = DiscriminatorDeSerializer.Deserialize(node2, configScope);
                this.Discriminator.SetMapping(configScope, this._class);
            }
            if ((configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix("subMap"), configScope.XmlNamespaceManager).Count > 0) && (this.Discriminator == null))
            {
                throw new ConfigurationException("The discriminator is null, but somehow a subMap was reached.  This is a bug.");
            }
            foreach (XmlNode node3 in configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix("subMap"), configScope.XmlNamespaceManager))
            {
                configScope.ErrorContext.MoreInfo = "initialize subMap";
                subMap = SubMapDeSerializer.Deserialize(node3, configScope);
                this.Discriminator.Add(subMap);
            }
        }
Esempio n. 2
0
 public void SetObjectFactory(ConfigurationScope configScope)
 {
     Type[] types = new Type[this._parameters.Count];
     for (int i = 0; i < this._parameters.Count; i++)
     {
         ArgumentProperty property = (ArgumentProperty)this._parameters[i];
         types[i] = property.MemberType;
     }
     this._objectFactory = configScope.SqlMapper.ObjectFactory.CreateFactory(this._class, types);
 }
 /// <summary>
 /// Sets the object factory.
 /// </summary>
 public void SetObjectFactory(ConfigurationScope configScope)
 {
     Type[] parametersType = new Type[_parameters.Count];
     for (int i = 0; i < _parameters.Count; i++)
     {
         ArgumentProperty argumentMapping = (ArgumentProperty)_parameters[i];
         parametersType[i] = argumentMapping.MemberType;
     }
     // Init the object factory
     _objectFactory = configScope.SqlMapper.ObjectFactory.CreateFactory(_class, parametersType);
 }
        /// <summary>
        /// Deserialize a ResultProperty object
        /// </summary>
        /// <param name="node"></param>
        /// <param name="configScope"></param>
        /// <returns></returns>
        public static ArgumentProperty Deserialize(XmlNode node, ConfigurationScope configScope)
        {
            ArgumentProperty argumentProperty = new ArgumentProperty();

            NameValueCollection prop = NodeUtils.ParseAttributes(node, configScope.Properties);
            argumentProperty.CLRType = NodeUtils.GetStringAttribute(prop, "type");
            argumentProperty.CallBackName = NodeUtils.GetStringAttribute(prop, "typeHandler");
            argumentProperty.ColumnIndex = NodeUtils.GetIntAttribute( prop, "columnIndex", ResultProperty.UNKNOWN_COLUMN_INDEX  );
            argumentProperty.ColumnName = NodeUtils.GetStringAttribute(prop, "column");
            argumentProperty.DbType = NodeUtils.GetStringAttribute(prop, "dbType");
            argumentProperty.NestedResultMapName = NodeUtils.GetStringAttribute(prop, "resultMapping");
            argumentProperty.NullValue = prop["nullValue"];
            argumentProperty.ArgumentName = NodeUtils.GetStringAttribute(prop, "argumentName");
            argumentProperty.Select = NodeUtils.GetStringAttribute(prop, "select");

            return argumentProperty;
        }
 /// <summary>
 /// Finds the <see cref="IArgumentStrategy"/>.
 /// </summary>
 /// <param name="mapping">The <see cref="ArgumentProperty"/>.</param>
 /// <returns>The <see cref="IArgumentStrategy"/></returns>
 public static IArgumentStrategy Get(ArgumentProperty mapping)
 {
     // no 'select' or 'resultMap' attributes
     if (mapping.Select.Length == 0 && mapping.NestedResultMap == null)
     {
         // We have a 'normal' ResultMap
         return _defaultStrategy;
     }
     else if (mapping.NestedResultMap != null) // 'resultMap' attribut
     {
         return _resultMapStrategy;
     }
     else //'select' ResultProperty
     {
         return new SelectStrategy(mapping,
             _selectArrayStrategy,
             _selectGenericListStrategy,
             _selectListStrategy,
             _selectObjectStrategy);
     }
 }
        /// <summary>
        /// Get the result properties and the subMap properties.
        /// </summary>
        /// <param name="configScope"></param>
        private void GetChildNode(ConfigurationScope configScope)
        {
            ResultProperty mapping = null;
            SubMap         subMap  = null;

            #region Load the parameters constructor
            XmlNodeList nodeList = configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_CONSTRUCTOR_ARGUMENT), configScope.XmlNamespaceManager);
            if (nodeList.Count > 0)
            {
                Type[]   parametersType = new Type[nodeList.Count];
                string[] parametersName = new string[nodeList.Count];
                for (int i = 0; i < nodeList.Count; i++)
                {
                    ArgumentProperty argumentMapping = ArgumentPropertyDeSerializer.Deserialize(nodeList[i], configScope);
                    _parameters.Add(argumentMapping);
                    parametersName[i] = argumentMapping.ArgumentName;
                }
                ConstructorInfo constructorInfo = this.GetConstructor(_class, parametersName);
                for (int i = 0; i < _parameters.Count; i++)
                {
                    ArgumentProperty argumentMapping = (ArgumentProperty)_parameters[i];

                    configScope.ErrorContext.MoreInfo = "initialize argument property : " + argumentMapping.ArgumentName;
                    argumentMapping.Initialize(configScope, constructorInfo);
                    parametersType[i] = argumentMapping.MemberType;
                }
                // Init the object factory
                _objectFactory = configScope.SqlMapper.ObjectFactory.CreateFactory(_class, parametersType);
            }
            else
            {
                if (Type.GetTypeCode(_class) == TypeCode.Object)
                {
                    _objectFactory = configScope.SqlMapper.ObjectFactory.CreateFactory(_class, Type.EmptyTypes);
                }
            }

            #endregion

            #region Load the Result Properties

            foreach (XmlNode resultNode in configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_RESULT), configScope.XmlNamespaceManager))
            {
                mapping = ResultPropertyDeSerializer.Deserialize(resultNode, configScope);

                configScope.ErrorContext.MoreInfo = "initialize result property: " + mapping.PropertyName;

                mapping.Initialize(configScope, _class);

                _properties.Add(mapping);
            }
            #endregion

            #region Load the Discriminator Property

            XmlNode discriminatorNode = configScope.NodeContext.SelectSingleNode(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_DISCRIMNATOR), configScope.XmlNamespaceManager);
            if (discriminatorNode != null)
            {
                configScope.ErrorContext.MoreInfo = "initialize discriminator";

                this.Discriminator = DiscriminatorDeSerializer.Deserialize(discriminatorNode, configScope);
                this.Discriminator.SetMapping(configScope, _class);
            }
            #endregion

            #region Load the SubMap Properties

            if (configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_SUBMAP), configScope.XmlNamespaceManager).Count > 0 && this.Discriminator == null)
            {
                throw new ConfigurationException("The discriminator is null, but somehow a subMap was reached.  This is a bug.");
            }
            foreach (XmlNode resultNode in configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_SUBMAP), configScope.XmlNamespaceManager))
            {
                configScope.ErrorContext.MoreInfo = "initialize subMap";
                subMap = SubMapDeSerializer.Deserialize(resultNode, configScope);

                this.Discriminator.Add(subMap);
            }
            #endregion
        }