Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System/sys/system/configuration/SettingsPropertyValue.cs

@@ -0,0 +1,284 @@
+//------------------------------------------------------------------------------
+// <copyright file="SettingsPropertyValue.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Configuration {
+    using  System.Collections;
+    using  System.Collections.Specialized;
+    using  System.Runtime.Serialization;
+    using  System.Configuration.Provider;
+    using  System.Globalization;
+    using  System.IO;
+    using System.Runtime.Serialization.Formatters.Binary;
+    using System.Xml.Serialization;
+    using System.ComponentModel;
+    using System.Security.Permissions;
+    using System.Reflection;
+    using System.Runtime.Versioning;
+
+    //////////////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////////////
+    public class SettingsPropertyValue
+    {
+        public string Name                  { get { return _Property.Name; } }
+        public bool   IsDirty               { get { return _IsDirty; } set { _IsDirty = value; }}
+        public SettingsProperty Property    { get { return _Property; } }
+
+        public bool UsingDefaultValue { get { return _UsingDefaultValue; } }
+
+        public SettingsPropertyValue(SettingsProperty property)
+        {
+            _Property = property;
+        }
+
+        public object PropertyValue
+        {
+            get
+            {
+                if (!_Deserialized)
+                {
+                    _Value = Deserialize();
+                    _Deserialized = true;
+                }
+
+                if (_Value != null && !Property.PropertyType.IsPrimitive && !(_Value is string) && !(_Value is DateTime))
+                {
+                    _UsingDefaultValue = false;
+                    _ChangedSinceLastSerialized = true;
+                    _IsDirty = true;
+                }
+
+                return _Value;
+            }
+            set
+            {
+                _Value = value;
+                _IsDirty = true;
+                _ChangedSinceLastSerialized = true;
+                _Deserialized = true;
+                _UsingDefaultValue = false;
+            }
+        }
+
+        public object SerializedValue
+        {
+            [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
+            get {
+                if (_ChangedSinceLastSerialized) {
+                    _ChangedSinceLastSerialized = false;
+                    _SerializedValue = SerializePropertyValue();
+                }
+                return _SerializedValue;
+            }
+            [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
+            set {
+                _UsingDefaultValue = false;
+                _SerializedValue = value;
+            }
+        }
+
+        public bool Deserialized
+        {
+            get { return _Deserialized; }
+            set { _Deserialized = value; }
+        }
+
+        [ResourceExposure(ResourceScope.None)]
+        [ResourceConsumption(ResourceScope.AppDomain, ResourceScope.AppDomain)]
+        private bool IsHostedInAspnet() {
+            // See System.Web.Hosting.ApplicationManager::PopulateDomainBindings
+            return AppDomain.CurrentDomain.GetData(".appDomain") != null;
+        }
+
+        private object Deserialize()
+        {
+            object val = null;
+            //////////////////////////////////////////////
+            /// Step 1: Try creating from Serailized value
+            if (SerializedValue != null)
+            {
+                try {
+                    if (SerializedValue is string) {
+                        val = GetObjectFromString(Property.PropertyType, Property.SerializeAs, (string)SerializedValue);
+                    } else {
+                        MemoryStream ms = new System.IO.MemoryStream((byte[])SerializedValue);
+                        try {
+                            val = (new BinaryFormatter()).Deserialize(ms);
+                        } finally {
+                            ms.Close();
+                        }
+                    }
+                } 
+                catch (Exception exception) { 
+                    try {
+                        if (IsHostedInAspnet()) {
+                            object[]    args = new object[] { Property, this, exception};
+
+                            const string webBaseEventTypeName = "System.Web.Management.WebBaseEvent, " +  AssemblyRef.SystemWeb;
+                            
+                            Type type = Type.GetType(webBaseEventTypeName, true);
+                            
+                            type.InvokeMember("RaisePropertyDeserializationWebErrorEvent",
+                                BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.InvokeMethod, 
+                                null, null, args, CultureInfo.InvariantCulture);
+                        }
+                    }
+                    catch {
+                    }
+                }
+
+               if (val != null && !Property.PropertyType.IsAssignableFrom(val.GetType())) // is it the correct type
+                    val = null;
+            }
+
+            //////////////////////////////////////////////
+            /// Step 2: Try creating from default value
+            if (val == null)
+            {
+                _UsingDefaultValue = true;
+                if (Property.DefaultValue == null || Property.DefaultValue.ToString() == "[null]") {
+                    if (Property.PropertyType.IsValueType)
+                        return SecurityUtils.SecureCreateInstance(Property.PropertyType);
+                    else
+                        return null;
+                }
+                if (!(Property.DefaultValue is string)) {
+                    val = Property.DefaultValue;
+                } else {
+                    try {
+                        val = GetObjectFromString(Property.PropertyType, Property.SerializeAs, (string)Property.DefaultValue);
+                    } catch(Exception e) {
+                        throw new ArgumentException(SR.GetString(SR.Could_not_create_from_default_value, Property.Name, e.Message));
+                    }
+                }
+                if (val != null && !Property.PropertyType.IsAssignableFrom(val.GetType())) // is it the correct type
+                    throw new ArgumentException(SR.GetString(SR.Could_not_create_from_default_value_2, Property.Name));
+            }
+
+            //////////////////////////////////////////////
+            /// Step 3: Create a new one by calling the parameterless constructor
+            if (val == null)
+            {
+                if (Property.PropertyType == typeof(string)) {
+                    val = "";
+                } else {
+                    try {
+                        val = SecurityUtils.SecureCreateInstance(Property.PropertyType);
+                    } catch {}
+                }
+            }
+
+            return val;
+        }
+
+        private static object GetObjectFromString(Type type, SettingsSerializeAs serializeAs, string attValue)
+        {
+            // Deal with string types
+            if (type == typeof(string) && (attValue == null || attValue.Length < 1 || serializeAs == SettingsSerializeAs.String))
+                return attValue;
+
+            // Return null if there is nothing to convert
+            if (attValue == null || attValue.Length < 1)
+                return null;
+
+            // Convert based on the serialized type
+            switch (serializeAs)
+            {
+                case SettingsSerializeAs.Binary:
+                    byte[]          buf = Convert.FromBase64String(attValue);
+                    MemoryStream    ms  = null;
+                    try {
+                        ms = new System.IO.MemoryStream(buf);
+                        return (new BinaryFormatter()).Deserialize(ms);
+                    } finally {
+                        if (ms != null)
+                            ms.Close();
+                    }
+
+                case SettingsSerializeAs.Xml:
+                    StringReader    sr = new StringReader(attValue);
+                    XmlSerializer   xs = new XmlSerializer(type);
+                    return xs.Deserialize(sr);
+
+                case SettingsSerializeAs.String:
+                    TypeConverter converter = TypeDescriptor.GetConverter(type);
+                    if (converter != null && converter.CanConvertTo(typeof(String)) && converter.CanConvertFrom(typeof(String)))
+                        return converter.ConvertFromInvariantString(attValue);
+                    throw new ArgumentException(SR.GetString(SR.Unable_to_convert_type_from_string, type.ToString()), "type");
+
+                default:
+                    return null;
+            }
+        }
+
+        private object SerializePropertyValue()
+        {
+            if (_Value == null)
+                return null;
+
+            if (Property.SerializeAs != SettingsSerializeAs.Binary)
+                return ConvertObjectToString(_Value, Property.PropertyType, Property.SerializeAs, Property.ThrowOnErrorSerializing);
+
+            MemoryStream ms = new System.IO.MemoryStream();
+            try {
+                BinaryFormatter bf = new BinaryFormatter();
+                bf.Serialize(ms, _Value);
+                return ms.ToArray();
+            } finally {
+                ms.Close();
+            }
+        }
+
+
+        private static string ConvertObjectToString(object propValue, Type type, SettingsSerializeAs serializeAs, bool throwOnError)
+        {
+            if (serializeAs == SettingsSerializeAs.ProviderSpecific) {
+                if (type == typeof(string) || type.IsPrimitive)
+                    serializeAs = SettingsSerializeAs.String;
+                else
+                    serializeAs = SettingsSerializeAs.Xml;
+            }
+
+            try {
+                switch (serializeAs) {
+                case SettingsSerializeAs.String:
+                    TypeConverter converter = TypeDescriptor.GetConverter(type);
+                    if (converter != null && converter.CanConvertTo(typeof(String)) && converter.CanConvertFrom(typeof(String)))
+                        return converter.ConvertToInvariantString(propValue);
+                    throw new ArgumentException(SR.GetString(SR.Unable_to_convert_type_to_string, type.ToString()), "type");
+                case SettingsSerializeAs.Binary :
+                    MemoryStream ms = new System.IO.MemoryStream();
+                    try {
+                        BinaryFormatter bf = new BinaryFormatter();
+                        bf.Serialize(ms, propValue);
+                        byte[] buffer = ms.ToArray();
+                        return Convert.ToBase64String(buffer);
+                    } finally {
+                        ms.Close();
+                    }
+
+                case SettingsSerializeAs.Xml :
+                    XmlSerializer xs = new XmlSerializer(type);
+                    StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
+
+                    xs.Serialize(sw, propValue);
+                    return sw.ToString();
+                }
+            } catch (Exception) {
+                if (throwOnError)
+                    throw;
+            }
+            return null;
+        }
+
+        private object  _Value              = null;
+        private object  _SerializedValue    = null;
+        private bool    _Deserialized       = false;
+        private bool    _IsDirty            = false;
+        private SettingsProperty _Property  = null;
+        private bool    _ChangedSinceLastSerialized = false;
+        private bool _UsingDefaultValue = true;
+    }
+}