The Labs \ Source Viewer \ SSCLI \ System.Configuration \ SettingsPropertyValue

  1. //------------------------------------------------------------------------------
  2. // <copyright file="SettingsPropertyValue.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Configuration
  16. {
  17.     using System.Collections;
  18.     using System.Collections.Specialized;
  19.     using System.Runtime.Serialization;
  20.     using System.Configuration.Provider;
  21.     using System.Globalization;
  22.     using System.IO;
  23.     using System.Runtime.Serialization.Formatters.Binary;
  24.     using System.Xml.Serialization;
  25.     using System.ComponentModel;
  26.     using System.Security.Permissions;
  27.     using System.Reflection;
  28.    
  29.     //////////////////////////////////////////////////////////////////////////////////
  30.     //////////////////////////////////////////////////////////////////////////////////
  31.     public class SettingsPropertyValue
  32.     {
  33.         public string Name {
  34.             get { return _Property.Name; }
  35.         }
  36.         public bool IsDirty {
  37.             get { return _IsDirty; }
  38.             set { _IsDirty = value; }
  39.         }
  40.         public SettingsProperty Property {
  41.             get { return _Property; }
  42.         }
  43.        
  44.         public bool UsingDefaultValue {
  45.             get { return _UsingDefaultValue; }
  46.         }
  47.        
  48.         public SettingsPropertyValue(SettingsProperty property)
  49.         {
  50.             _Property = property;
  51.         }
  52.        
  53.         public object PropertyValue {
  54.             get {
  55.                 if (!_Deserialized) {
  56.                     _Value = Deserialize();
  57.                     _Deserialized = true;
  58.                 }
  59.                
  60.                 if (_Value != null && !Property.PropertyType.IsPrimitive && !(_Value is string) && !(_Value is DateTime)) {
  61.                     _UsingDefaultValue = false;
  62.                     _ChangedSinceLastSerialized = true;
  63.                     _IsDirty = true;
  64.                 }
  65.                
  66.                 return _Value;
  67.             }
  68.             set {
  69.                 _Value = value;
  70.                 _IsDirty = true;
  71.                 _ChangedSinceLastSerialized = true;
  72.                 _Deserialized = true;
  73.                 _UsingDefaultValue = false;
  74.             }
  75.         }
  76.        
  77.         public object SerializedValue {
  78.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
  79.             get {
  80.                 if (_ChangedSinceLastSerialized) {
  81.                     _ChangedSinceLastSerialized = false;
  82.                     _SerializedValue = SerializePropertyValue();
  83.                 }
  84.                 return _SerializedValue;
  85.             }
  86.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
  87.             set {
  88.                 _UsingDefaultValue = false;
  89.                 _SerializedValue = value;
  90.             }
  91.         }
  92.        
  93.         public bool Deserialized {
  94.             get { return _Deserialized; }
  95.             set { _Deserialized = value; }
  96.         }
  97.        
  98.        
  99.         private object Deserialize()
  100.         {
  101.             object val = null;
  102.             //////////////////////////////////////////////
  103.             /// Step 1: Try creating from Serailized value
  104.             if (SerializedValue != null) {
  105.                 try {
  106.                     if (SerializedValue is string) {
  107.                         val = GetObjectFromString(Property.PropertyType, Property.SerializeAs, (string)SerializedValue);
  108.                     }
  109.                     else {
  110.                         MemoryStream ms = new System.IO.MemoryStream((byte[])SerializedValue);
  111.                         try {
  112.                             val = (new BinaryFormatter()).Deserialize(ms);
  113.                         }
  114.                         finally {
  115.                             ms.Close();
  116.                         }
  117.                     }
  118.                 }
  119.                 catch (Exception exception) {
  120.                 }
  121.                
  122.                
  123.                 if (val != null && !Property.PropertyType.IsAssignableFrom(val.GetType()))
  124.                     // is it the correct type
  125.                     val = null;
  126.             }
  127.            
  128.             //////////////////////////////////////////////
  129.             /// Step 2: Try creating from default value
  130.             if (val == null) {
  131.                 _UsingDefaultValue = true;
  132.                 if (Property.DefaultValue == null || Property.DefaultValue.ToString() == "[null]") {
  133.                     if (Property.PropertyType.IsValueType)
  134.                         return Activator.CreateInstance(Property.PropertyType);
  135.                     else
  136.                         return null;
  137.                 }
  138.                 if (!(Property.DefaultValue is string)) {
  139.                     val = Property.DefaultValue;
  140.                 }
  141.                 else {
  142.                     try {
  143.                         val = GetObjectFromString(Property.PropertyType, Property.SerializeAs, (string)Property.DefaultValue);
  144.                     }
  145.                     catch (Exception e) {
  146.                         throw new ArgumentException(SR.GetString(SR.Could_not_create_from_default_value, Property.Name, e.Message));
  147.                     }
  148.                 }
  149.                 if (val != null && !Property.PropertyType.IsAssignableFrom(val.GetType()))
  150.                     // is it the correct type
  151.                     throw new ArgumentException(SR.GetString(SR.Could_not_create_from_default_value_2, Property.Name));
  152.             }
  153.            
  154.             //////////////////////////////////////////////
  155.             /// Step 3: Create a new one by calling the parameterless constructor
  156.             if (val == null) {
  157.                 if (Property.PropertyType == typeof(string)) {
  158.                     val = "";
  159.                 }
  160.                 else {
  161.                     try {
  162.                         val = Activator.CreateInstance(Property.PropertyType);
  163.                     }
  164.                     catch {
  165.                     }
  166.                 }
  167.             }
  168.            
  169.             return val;
  170.         }
  171.        
  172.         private static object GetObjectFromString(Type type, SettingsSerializeAs serializeAs, string attValue)
  173.         {
  174.             // Deal with string types
  175.             if (type == typeof(string) && (attValue == null || attValue.Length < 1 || serializeAs == SettingsSerializeAs.String))
  176.                 return attValue;
  177.            
  178.             // Return null if there is nothing to convert
  179.             if (attValue == null || attValue.Length < 1)
  180.                 return null;
  181.            
  182.             // Convert based on the serialized type
  183.             switch (serializeAs) {
  184.                 case SettingsSerializeAs.Binary:
  185.                     byte[] buf = Convert.FromBase64String(attValue);
  186.                     MemoryStream ms = null;
  187.                     try {
  188.                         ms = new System.IO.MemoryStream(buf);
  189.                         return (new BinaryFormatter()).Deserialize(ms);
  190.                     }
  191.                     finally {
  192.                         if (ms != null)
  193.                             ms.Close();
  194.                     }
  195.                     break;
  196.                 case SettingsSerializeAs.Xml:
  197.                    
  198.                     StringReader sr = new StringReader(attValue);
  199.                     XmlSerializer xs = new XmlSerializer(type);
  200.                     return xs.Deserialize(sr);
  201.                 case SettingsSerializeAs.String:
  202.                    
  203.                     TypeConverter converter = TypeDescriptor.GetConverter(type);
  204.                     if (converter != null && converter.CanConvertTo(typeof(string)) && converter.CanConvertFrom(typeof(string)))
  205.                         return converter.ConvertFromInvariantString(attValue);
  206.                     throw new ArgumentException(SR.GetString(SR.Unable_to_convert_type_from_string, type.ToString()), "type");
  207.                     break;
  208.                 default:
  209.                    
  210.                     return null;
  211.             }
  212.         }
  213.        
  214.         private object SerializePropertyValue()
  215.         {
  216.             if (_Value == null)
  217.                 return null;
  218.            
  219.             if (Property.SerializeAs != SettingsSerializeAs.Binary)
  220.                 return ConvertObjectToString(_Value, Property.PropertyType, Property.SerializeAs, Property.ThrowOnErrorSerializing);
  221.            
  222.             MemoryStream ms = new System.IO.MemoryStream();
  223.             try {
  224.                 BinaryFormatter bf = new BinaryFormatter();
  225.                 bf.Serialize(ms, _Value);
  226.                 return ms.ToArray();
  227.             }
  228.             finally {
  229.                 ms.Close();
  230.             }
  231.         }
  232.        
  233.        
  234.         private static string ConvertObjectToString(object propValue, Type type, SettingsSerializeAs serializeAs, bool throwOnError)
  235.         {
  236.             if (serializeAs == SettingsSerializeAs.ProviderSpecific) {
  237.                 if (type == typeof(string) || type.IsPrimitive)
  238.                     serializeAs = SettingsSerializeAs.String;
  239.                 else
  240.                     serializeAs = SettingsSerializeAs.Xml;
  241.             }
  242.            
  243.             try {
  244.                 switch (serializeAs) {
  245.                     case SettingsSerializeAs.String:
  246.                         TypeConverter converter = TypeDescriptor.GetConverter(type);
  247.                         if (converter != null && converter.CanConvertTo(typeof(string)) && converter.CanConvertFrom(typeof(string)))
  248.                             return converter.ConvertToInvariantString(propValue);
  249.                         throw new ArgumentException(SR.GetString(SR.Unable_to_convert_type_to_string, type.ToString()), "type");
  250.                         break;
  251.                     case SettingsSerializeAs.Binary:
  252.                         MemoryStream ms = new System.IO.MemoryStream();
  253.                         try {
  254.                             BinaryFormatter bf = new BinaryFormatter();
  255.                             bf.Serialize(ms, propValue);
  256.                             byte[] buffer = ms.ToArray();
  257.                             return Convert.ToBase64String(buffer);
  258.                         }
  259.                         finally {
  260.                             ms.Close();
  261.                         }
  262.                         break;
  263.                     case SettingsSerializeAs.Xml:
  264.                        
  265.                         XmlSerializer xs = new XmlSerializer(type);
  266.                         StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
  267.                        
  268.                         xs.Serialize(sw, propValue);
  269.                         return sw.ToString();
  270.                 }
  271.             }
  272.             catch (Exception) {
  273.                 if (throwOnError)
  274.                     throw;
  275.             }
  276.             return null;
  277.         }
  278.        
  279.         private object _Value = null;
  280.         private object _SerializedValue = null;
  281.         private bool _Deserialized = false;
  282.         private bool _IsDirty = false;
  283.         private SettingsProperty _Property = null;
  284.         private bool _ChangedSinceLastSerialized = false;
  285.         private bool _UsingDefaultValue = true;
  286.     }
  287. }

Developer Fusion