Exemplo n.º 1
0
        /// <summary>
        /// This method will set the ini value to the supplied value or use the default if non supplied
        /// </summary>
        /// <param name="propertyValue"></param>
        public void UseValueOrDefault(string propertyValue)
        {
            Type   valueType              = ValueType;
            string propertyName           = _attributes.Name;
            string defaultValue           = _attributes.DefaultValue;
            bool   defaultUsed            = false;
            object defaultValueFromConfig = _containingIniSection.GetDefault(propertyName);

            if (string.IsNullOrEmpty(propertyValue))
            {
                if (defaultValue != null && defaultValue.Trim().Length != 0)
                {
                    propertyValue = defaultValue;
                    defaultUsed   = true;
                }
                else if (defaultValueFromConfig != null)
                {
                    Log.DebugFormat("Default for Property {0} implemented!", propertyName);
                }
                else
                {
                    if (_attributes.ExcludeIfNull)
                    {
                        Value = null;
                        return;
                    }
                    Log.DebugFormat("Property {0} has no value or default value!", propertyName);
                }
            }
            // Now set the value
            if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Dictionary <,>))
            {
                // Logic for Dictionary<,>
                Type type1 = valueType.GetGenericArguments()[0];
                Type type2 = valueType.GetGenericArguments()[1];
                //LOG.Info(String.Format("Found Dictionary<{0},{1}>", type1.Name, type2.Name));
                object     dictionary    = Activator.CreateInstance(valueType);
                MethodInfo addMethodInfo = valueType.GetMethod("Add");
                bool       addedElements = false;
                IDictionary <string, string> properties = IniConfig.PropertiesForSection(_containingIniSection);
                foreach (string key in properties.Keys)
                {
                    if (key != null && key.StartsWith(propertyName + "."))
                    {
                        // What "key" do we need to store it under?
                        string subPropertyName = key.Substring(propertyName.Length + 1);
                        string stringValue     = properties[key];
                        object newValue1       = null;
                        object newValue2       = null;
                        try {
                            newValue1 = ConvertStringToValueType(type1, subPropertyName, _attributes.Separator);
                        } catch (Exception ex) {
                            Log.Warn(ex);
                            //LOG.Error("Problem converting " + subPropertyName + " to type " + type1.FullName, e);
                        }
                        try {
                            newValue2 = ConvertStringToValueType(type2, stringValue, _attributes.Separator);
                        } catch (Exception ex) {
                            Log.Warn(ex);
                            //LOG.Error("Problem converting " + stringValue + " to type " + type2.FullName, e);
                        }
                        addMethodInfo.Invoke(dictionary, new[] { newValue1, newValue2 });
                        addedElements = true;
                    }
                }
                // No need to return something that isn't filled!
                if (addedElements)
                {
                    Value = dictionary;
                    return;
                }
                if (defaultValueFromConfig != null)
                {
                    Value = defaultValueFromConfig;
                    return;
                }
            }
            else if (!string.IsNullOrEmpty(propertyValue))
            {
                if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Nullable <>))
                {
                    // We are dealing with a generic type that is nullable
                    valueType = Nullable.GetUnderlyingType(valueType);
                }
                object newValue;
                try {
                    newValue = ConvertStringToValueType(valueType, propertyValue, _attributes.Separator);
                } catch (Exception ex1) {
                    newValue = null;
                    if (!defaultUsed)
                    {
                        try {
                            Log.WarnFormat("Problem '{0}' while converting {1} to type {2} trying fallback...", ex1.Message, propertyValue, valueType.FullName);
                            newValue = ConvertStringToValueType(valueType, defaultValue, _attributes.Separator);
                            ContainingIniSection.IsDirty = true;
                            Log.InfoFormat("Used default value {0} for property {1}", defaultValue, propertyName);
                        } catch (Exception ex2) {
                            Log.Warn("Problem converting fallback value " + defaultValue + " to type " + valueType.FullName, ex2);
                        }
                    }
                    else
                    {
                        Log.Warn("Problem converting " + propertyValue + " to type " + valueType.FullName, ex1);
                    }
                }
                Value = newValue;
                return;
            }

            // If nothing is set, we can use the default value from the config (if we habe one)
            if (defaultValueFromConfig != null)
            {
                Value = defaultValueFromConfig;
                return;
            }
            if (ValueType != typeof(string))
            {
                try {
                    Value = Activator.CreateInstance(ValueType);
                } catch (Exception) {
                    Log.WarnFormat("Couldn't create instance of {0} for {1}, using default value.", ValueType.FullName, _attributes.Name);
                    Value = default(ValueType);
                }
            }
            else
            {
                Value = default(ValueType);
            }
        }
        /// <summary>
        /// This method will set the ini value to the supplied value or use the default if non supplied
        /// </summary>
        /// <param name="propertyValue"></param>
        public void UseValueOrDefault(string propertyValue)
        {
            Type   valueType              = ValueType;
            string propertyName           = attributes.Name;
            string defaultValue           = attributes.DefaultValue;
            bool   defaultUsed            = false;
            object defaultValueFromConfig = containingIniSection.GetDefault(propertyName);

            if (string.IsNullOrEmpty(propertyValue))
            {
                if (defaultValue != null && defaultValue.Trim().Length != 0)
                {
                    propertyValue = defaultValue;
                    defaultUsed   = true;
                }
                else if (defaultValueFromConfig != null)
                {
                    LOG.DebugFormat("Default for Property {0} implemented!", propertyName);
                }
                else
                {
                    if (attributes.ExcludeIfNull)
                    {
                        Value = null;
                        return;
                    }
                    LOG.DebugFormat("Property {0} has no value or default value!", propertyName);
                }
            }
            // Now set the value
            if (valueType.IsGenericType && ValueType.GetGenericTypeDefinition() == typeof(List <>))
            {
                string arraySeparator = attributes.Separator;
                object list           = Activator.CreateInstance(ValueType);
                // Logic for List<>
                if (propertyValue == null)
                {
                    if (defaultValueFromConfig != null)
                    {
                        Value = defaultValueFromConfig;
                        return;
                    }
                    Value = list;
                    return;
                }
                string[] arrayValues = propertyValue.Split(new string[] { arraySeparator }, StringSplitOptions.None);
                if (arrayValues == null || arrayValues.Length == 0)
                {
                    Value = list;
                    return;
                }
                bool       addedElements = false;
                bool       parseProblems = false;
                MethodInfo addMethodInfo = valueType.GetMethod("Add");

                foreach (string arrayValue in arrayValues)
                {
                    if (arrayValue != null && arrayValue.Length > 0)
                    {
                        object newValue = null;
                        try
                        {
                            newValue = ConvertStringToValueType(valueType.GetGenericArguments()[0], arrayValue);
                        }
                        catch (Exception ex)
                        {
                            LOG.Warn(ex);
                            //LOG.Error("Problem converting " + arrayValue + " to type " + fieldType.FullName, e);
                            parseProblems = true;
                        }
                        if (newValue != null)
                        {
                            addMethodInfo.Invoke(list, new object[] { newValue });
                            addedElements = true;
                        }
                    }
                }
                // Try to fallback on a default
                if (!addedElements && parseProblems)
                {
                    try
                    {
                        object fallbackValue = ConvertStringToValueType(valueType.GetGenericArguments()[0], defaultValue);
                        addMethodInfo.Invoke(list, new object[] { fallbackValue });
                        Value = list;
                        return;
                    }
                    catch (Exception ex)
                    {
                        LOG.Warn(ex);
                        //LOG.Error("Problem converting " + defaultValue + " to type " + fieldType.FullName, e);
                    }
                }
                Value = list;
                return;
            }
            else if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(Dictionary <,>))
            {
                // Logic for Dictionary<,>
                Type type1 = valueType.GetGenericArguments()[0];
                Type type2 = valueType.GetGenericArguments()[1];
                //LOG.Info(String.Format("Found Dictionary<{0},{1}>", type1.Name, type2.Name));
                object     dictionary    = Activator.CreateInstance(valueType);
                MethodInfo addMethodInfo = valueType.GetMethod("Add");
                bool       addedElements = false;
                Dictionary <string, string> properties = IniConfig.PropertiesForSection(containingIniSection);
                foreach (string key in properties.Keys)
                {
                    if (key != null && key.StartsWith(propertyName + "."))
                    {
                        // What "key" do we need to store it under?
                        string subPropertyName = key.Substring(propertyName.Length + 1);
                        string stringValue     = properties[key];
                        object newValue1       = null;
                        object newValue2       = null;
                        try
                        {
                            newValue1 = ConvertStringToValueType(type1, subPropertyName);
                        }
                        catch (Exception ex)
                        {
                            LOG.Warn(ex);
                            //LOG.Error("Problem converting " + subPropertyName + " to type " + type1.FullName, e);
                        }
                        try
                        {
                            newValue2 = ConvertStringToValueType(type2, stringValue);
                        }
                        catch (Exception ex)
                        {
                            LOG.Warn(ex);
                            //LOG.Error("Problem converting " + stringValue + " to type " + type2.FullName, e);
                        }
                        addMethodInfo.Invoke(dictionary, new object[] { newValue1, newValue2 });
                        addedElements = true;
                    }
                }
                // No need to return something that isn't filled!
                if (addedElements)
                {
                    Value = dictionary;
                    return;
                }
                else if (defaultValueFromConfig != null)
                {
                    Value = defaultValueFromConfig;
                    return;
                }
            }
            if (defaultValueFromConfig != null)
            {
                Value = defaultValueFromConfig;
                return;
            }
            else
            {
                if (valueType.IsGenericType && valueType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
                {
                    // We are dealing with a generic type that is nullable
                    valueType = Nullable.GetUnderlyingType(valueType);
                }
                object newValue = null;
                try
                {
                    newValue = ConvertStringToValueType(valueType, propertyValue);
                }
                catch (Exception ex1)
                {
                    newValue = null;
                    if (!defaultUsed)
                    {
                        try
                        {
                            newValue = ConvertStringToValueType(valueType, defaultValue);
                        }
                        catch (Exception ex2)
                        {
                            LOG.Warn("Problem converting " + propertyValue + " to type " + valueType.FullName, ex2);
                        }
                    }
                    else
                    {
                        LOG.Warn("Problem converting " + propertyValue + " to type " + valueType.FullName, ex1);
                    }
                }
                Value = newValue;
                return;
            }
        }