コード例 #1
0
        private static Array DecodeArray(string propValue)
        {
            if (propValue == null)
            {
                throw new FormatException();
            }
            int num = propValue.IndexOf('-');

            if (num < 0)
            {
                throw new FormatException();
            }
            int   num2 = int.Parse(propValue.Substring(0, num));
            Array result;

            if (num2 == (int)Type.GetTypeCode(typeof(byte)))
            {
                result = Convert.FromBase64String(propValue.Substring(num + 1));
            }
            else
            {
                if (num2 != (int)Type.GetTypeCode(typeof(string)))
                {
                    throw new FormatException();
                }
                result = ConfigurationDictionary.DecodeStringArray(propValue);
            }
            return(result);
        }
コード例 #2
0
        private static object ConstructObject(string value, TypeCode typeCode)
        {
            object result = null;

            if (typeCode == TypeCode.Empty)
            {
                if (value != "0")
                {
                    throw new FormatException(ServerStrings.ExBadValueForTypeCode0);
                }
            }
            else if (typeCode == TypeCode.DateTime)
            {
                result = ExDateTime.FromBinary(long.Parse(value, CultureInfo.InvariantCulture));
            }
            else if (typeCode == TypeCode.Int16 || typeCode == TypeCode.Int32)
            {
                result = int.Parse(value, NumberStyles.Any, CultureInfo.InvariantCulture);
            }
            else if (typeCode == TypeCode.UInt16 || typeCode == TypeCode.UInt32)
            {
                result = uint.Parse(value, NumberStyles.Any, CultureInfo.InvariantCulture);
            }
            else if (typeCode == TypeCode.Int64)
            {
                result = long.Parse(value, NumberStyles.Any, CultureInfo.InvariantCulture);
            }
            else if (typeCode == TypeCode.UInt64)
            {
                result = ulong.Parse(value, NumberStyles.Any, CultureInfo.InvariantCulture);
            }
            else if (typeCode == TypeCode.Boolean)
            {
                result = bool.Parse(value);
            }
            else if (typeCode == TypeCode.Byte)
            {
                result = byte.Parse(value, CultureInfo.InvariantCulture);
            }
            else if (typeCode == TypeCode.String)
            {
                result = value;
            }
            else
            {
                if (typeCode != TypeCode.Object)
                {
                    throw new FormatException(ServerStrings.ExBadValueForTypeCode0);
                }
                result = ConfigurationDictionary.DecodeArray(value);
            }
            return(result);
        }
コード例 #3
0
        public IDictionary GetDictionary()
        {
            IDictionary result;

            using (StringReader stringReader = new StringReader(this.Memento.DictionaryXmlString))
            {
                using (XmlReader xmlReader = AggregatedUserConfigurationPart.InternalGetXmlReader(stringReader))
                {
                    ConfigurationDictionary configurationDictionary = new ConfigurationDictionary();
                    configurationDictionary.ReadXml(xmlReader);
                    result = configurationDictionary;
                }
            }
            return(result);
        }
コード例 #4
0
        private static string SerializeObject(object o)
        {
            TypeCode typeCode = TypeCode.Empty;
            string   arg      = string.Empty;
            Array    array    = o as Array;

            if (o == null)
            {
                arg = "0";
            }
            else if (array != null)
            {
                typeCode = TypeCode.Object;
                arg      = ConfigurationDictionary.EncodeArray(array);
            }
            else if (o is ExDateTime)
            {
                typeCode = TypeCode.DateTime;
                arg      = ((ExDateTime)o).ToBinary().ToString(CultureInfo.InvariantCulture);
            }
            else
            {
                typeCode = Type.GetTypeCode(o.GetType());
                int i;
                for (i = 0; i < ConfigurationDictionary.simpleSerializableTypes.Length; i++)
                {
                    if (ConfigurationDictionary.simpleSerializableTypes[i] == typeCode)
                    {
                        IFormattable formattable = o as IFormattable;
                        arg = ((formattable != null) ? formattable.ToString(null, CultureInfo.InvariantCulture) : o.ToString());
                        break;
                    }
                }
                if (i == ConfigurationDictionary.simpleSerializableTypes.Length)
                {
                    ExTraceGlobals.StorageTracer.TraceError <Type>(0L, "ConfigurationDictionary::SerializeObject. The type '{0}' is not supported by user configuration for serialization.", o.GetType());
                    throw new NotSupportedException(ServerStrings.ExTypeSerializationNotSupported(o.GetType()));
                }
            }
            return(string.Format("{0}{1}{2}", (int)typeCode, '-', arg));
        }
コード例 #5
0
        private static string EncodeArray(Array objects)
        {
            StringBuilder stringBuilder = new StringBuilder();

            byte[] array = objects as byte[];
            if (array != null)
            {
                stringBuilder.Append((int)Type.GetTypeCode(typeof(byte)));
                stringBuilder.Append('-');
                stringBuilder.Append(Convert.ToBase64String(array));
            }
            else
            {
                string[] array2 = objects as string[];
                if (array2 != null)
                {
                    ConfigurationDictionary.EncodeStringArray(stringBuilder, array2);
                }
            }
            return(stringBuilder.ToString());
        }
コード例 #6
0
 public void WriteXml(XmlWriter writer)
 {
     writer.WriteStartDocument();
     writer.WriteStartElement("UserConfiguration");
     writer.WriteStartElement("Info");
     writer.WriteAttributeString("version", "Exchange.12");
     writer.WriteEndElement();
     writer.WriteStartElement("Data");
     foreach (object obj in base.Dictionary)
     {
         DictionaryEntry dictionaryEntry = (DictionaryEntry)obj;
         writer.WriteStartElement("e");
         string value  = ConfigurationDictionary.SerializeObject(dictionaryEntry.Key);
         string value2 = ConfigurationDictionary.SerializeObject(dictionaryEntry.Value);
         writer.WriteAttributeString("k", value);
         writer.WriteAttributeString("v", value2);
         writer.WriteEndElement();
     }
     writer.WriteEndElement();
     writer.WriteEndElement();
     writer.WriteEndDocument();
 }
コード例 #7
0
        private void CheckSupportedType(object o, bool allowNull)
        {
            bool  flag  = false;
            Array array = o as Array;

            if (array != null)
            {
                if (array is byte[] && array.Length > 0)
                {
                    flag = true;
                    goto IL_71;
                }
                if (!(array is string[]) || array.Length <= 0)
                {
                    goto IL_71;
                }
                flag = true;
                using (IEnumerator enumerator = array.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        if (enumerator.Current == null)
                        {
                            flag = false;
                            break;
                        }
                    }
                    goto IL_71;
                }
            }
            flag = ConfigurationDictionary.CheckElementSupportedType(o, allowNull);
IL_71:
            if (!flag)
            {
                ExTraceGlobals.StorageTracer.TraceError <Type>((long)this.GetHashCode(), "ConfigurationDictionary::CheckSupportedType. The type is not supported. Type = {0}.", o.GetType());
                throw new NotSupportedException(ServerStrings.ExTypeSerializationNotSupported(o.GetType()));
            }
        }
コード例 #8
0
        private object DeserializeObject(string compoundValue)
        {
            int num = compoundValue.IndexOf('-');

            if (num < 0)
            {
                this.ThrowOnCorruptedData("DeserializeObject", ServerStrings.ExSeparatorNotFoundOnCompoundValue, compoundValue);
            }
            string text = compoundValue.Substring(0, num);
            int    num2;

            if (!int.TryParse(text, out num2))
            {
                this.ThrowOnCorruptedData("DeserializeObject", ServerStrings.ExBadObjectType, text);
            }
            TypeCode typeCode = (TypeCode)num2;
            object   result   = null;

            try
            {
                string value = compoundValue.Substring(num + 1);
                result = ConfigurationDictionary.ConstructObject(value, typeCode);
            }
            catch (ArgumentException)
            {
                this.ThrowOnCorruptedData("DeserializeObject", ServerStrings.ExCannotParseValue, compoundValue);
            }
            catch (OverflowException)
            {
                this.ThrowOnCorruptedData("DeserializeObject", ServerStrings.ExCannotParseValue, compoundValue);
            }
            catch (FormatException)
            {
                this.ThrowOnCorruptedData("DeserializeObject", ServerStrings.ExCannotParseValue, compoundValue);
            }
            return(result);
        }
コード例 #9
0
 public void ReadXml(XmlReader reader)
 {
     reader.ReadStartElement("UserConfiguration");
     if (ConfigurationDictionary.GetNode(reader, "Info") == null)
     {
         this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNoField, "Info");
     }
     if (ConfigurationDictionary.GetAttribute(reader, "version") == null)
     {
         this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNoField, "version");
     }
     if (reader.Value != "Exchange.12")
     {
         ExTraceGlobals.StorageTracer.TraceDebug <string>((long)this.GetHashCode(), "The version is not supported. Version = {0}.", reader.Value);
     }
     if (ConfigurationDictionary.GetNode(reader, "Data") == null)
     {
         this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNoField, "Data");
     }
     reader.Read();
     while (reader.NodeType != XmlNodeType.EndElement)
     {
         if (reader.Name == "e" && reader.HasAttributes)
         {
             reader.MoveToFirstAttribute();
             object obj  = null;
             object obj2 = null;
             bool   flag = true;
             do
             {
                 if (reader.Name == "k")
                 {
                     if (obj == null)
                     {
                         obj = this.DeserializeObject(reader.Value);
                     }
                 }
                 else if (reader.Name == "v")
                 {
                     flag = false;
                     if (obj2 == null)
                     {
                         obj2 = this.DeserializeObject(reader.Value);
                     }
                 }
             }while (reader.MoveToNextAttribute());
             if (obj == null)
             {
                 this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNullKey, "k");
             }
             if (flag)
             {
                 this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedNoField, "v");
             }
             if (base.Dictionary.Contains(obj))
             {
                 this.ThrowOnCorruptedData("ReadXml", ServerStrings.ExDictionaryDataCorruptedDuplicateKey(obj.ToString()), obj.ToString());
             }
             else
             {
                 base.Dictionary.Add(obj, obj2);
             }
         }
         reader.Read();
     }
 }