Example #1
0
 static EnumUtils()
 {
     Class6.yDnXvgqzyB5jw();
     EnumUtils.ValuesAndNamesPerEnum    = new ThreadSafeStore <StructMultiKey <Type, NamingStrategy>, EnumInfo>(new Func <StructMultiKey <Type, NamingStrategy>, EnumInfo>(EnumUtils.InitializeValuesAndNames));
     EnumUtils._camelCaseNamingStrategy = new CamelCaseNamingStrategy();
 }
Example #2
0
        static ConvertUtils()
        {
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(char), PrimitiveTypeCode.Char);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(char?), PrimitiveTypeCode.CharNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(bool), PrimitiveTypeCode.Boolean);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(bool?), PrimitiveTypeCode.BooleanNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(sbyte), PrimitiveTypeCode.SByte);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(sbyte?), PrimitiveTypeCode.SByteNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(short), PrimitiveTypeCode.Int16);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(short?), PrimitiveTypeCode.Int16Nullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(ushort), PrimitiveTypeCode.UInt16);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(ushort?), PrimitiveTypeCode.UInt16Nullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(int), PrimitiveTypeCode.Int32);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(int?), PrimitiveTypeCode.Int32Nullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(byte), PrimitiveTypeCode.Byte);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(byte?), PrimitiveTypeCode.ByteNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(uint), PrimitiveTypeCode.UInt32);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(uint?), PrimitiveTypeCode.UInt32Nullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(long), PrimitiveTypeCode.Int64);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(long?), PrimitiveTypeCode.Int64Nullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(ulong), PrimitiveTypeCode.UInt64);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(ulong?), PrimitiveTypeCode.UInt64Nullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(float), PrimitiveTypeCode.Single);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(float?), PrimitiveTypeCode.SingleNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(double), PrimitiveTypeCode.Double);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(double?), PrimitiveTypeCode.DoubleNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(DateTime), PrimitiveTypeCode.DateTime);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(DateTime?), PrimitiveTypeCode.DateTimeNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(DateTimeOffset), PrimitiveTypeCode.DateTimeOffset);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(DateTimeOffset?), PrimitiveTypeCode.DateTimeOffsetNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(decimal), PrimitiveTypeCode.Decimal);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(decimal?), PrimitiveTypeCode.DecimalNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(Guid), PrimitiveTypeCode.Guid);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(Guid?), PrimitiveTypeCode.GuidNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(TimeSpan), PrimitiveTypeCode.TimeSpan);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(TimeSpan?), PrimitiveTypeCode.TimeSpanNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(BigInteger), PrimitiveTypeCode.BigInteger);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(BigInteger?), PrimitiveTypeCode.BigIntegerNullable);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(Uri), PrimitiveTypeCode.Uri);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(string), PrimitiveTypeCode.String);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(byte[]), PrimitiveTypeCode.Bytes);
            new Dictionary <Type, PrimitiveTypeCode>().Add(typeof(DBNull), PrimitiveTypeCode.DBNull);
            TypeCodeMap = new Dictionary <Type, PrimitiveTypeCode>();
            TypeInformation[] informationArray1 = new TypeInformation[0x13];
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Empty
            }.Type = typeof(object);
            TypeInformation information1 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Empty
            };

            informationArray1[0] = information1;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Object
            }.Type = typeof(object);
            TypeInformation information2 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Object
            };

            informationArray1[1] = information2;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.DBNull
            }.Type = typeof(object);
            TypeInformation information3 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.DBNull
            };

            informationArray1[2] = information3;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Boolean
            }.Type = typeof(bool);
            TypeInformation information4 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Boolean
            };

            informationArray1[3] = information4;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Char
            }.Type = typeof(char);
            TypeInformation information5 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Char
            };

            informationArray1[4] = information5;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.SByte
            }.Type = typeof(sbyte);
            TypeInformation information6 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.SByte
            };

            informationArray1[5] = information6;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Byte
            }.Type = typeof(byte);
            TypeInformation information7 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Byte
            };

            informationArray1[6] = information7;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Int16
            }.Type = typeof(short);
            TypeInformation information8 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Int16
            };

            informationArray1[7] = information8;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.UInt16
            }.Type = typeof(ushort);
            TypeInformation information9 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.UInt16
            };

            informationArray1[8] = information9;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Int32
            }.Type = typeof(int);
            TypeInformation information10 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Int32
            };

            informationArray1[9] = information10;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.UInt32
            }.Type = typeof(uint);
            TypeInformation information11 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.UInt32
            };

            informationArray1[10] = information11;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Int64
            }.Type = typeof(long);
            TypeInformation information12 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Int64
            };

            informationArray1[11] = information12;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.UInt64
            }.Type = typeof(ulong);
            TypeInformation information13 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.UInt64
            };

            informationArray1[12] = information13;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Single
            }.Type = typeof(float);
            TypeInformation information14 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Single
            };

            informationArray1[13] = information14;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Double
            }.Type = typeof(double);
            TypeInformation information15 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Double
            };

            informationArray1[14] = information15;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Decimal
            }.Type = typeof(decimal);
            TypeInformation information16 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Decimal
            };

            informationArray1[15] = information16;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.DateTime
            }.Type = typeof(DateTime);
            TypeInformation information17 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.DateTime
            };

            informationArray1[0x10] = information17;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.Empty
            }.Type = typeof(object);
            TypeInformation information18 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.Empty
            };

            informationArray1[0x11] = information18;
            new TypeInformation {
                TypeCode = PrimitiveTypeCode.String
            }.Type = typeof(string);
            TypeInformation information19 = new TypeInformation {
                TypeCode = PrimitiveTypeCode.String
            };

            informationArray1[0x12] = information19;
            PrimitiveTypeCodes      = informationArray1;
            CastConverters          = new ThreadSafeStore <TypeConvertKey, Func <object, object> >(new Func <TypeConvertKey, Func <object, object> >(ConvertUtils.CreateCastConverter));
        }
Example #3
0
 static ConvertUtils()
 {
     Class6.yDnXvgqzyB5jw();
     ConvertUtils.TypeCodeMap = new Dictionary <Type, PrimitiveTypeCode>()
     {
         { typeof(char), PrimitiveTypeCode.Char },
         { typeof(char?), PrimitiveTypeCode.CharNullable },
         { typeof(bool), PrimitiveTypeCode.Boolean },
         { typeof(bool?), PrimitiveTypeCode.BooleanNullable },
         { typeof(sbyte), PrimitiveTypeCode.SByte },
         { typeof(sbyte?), PrimitiveTypeCode.SByteNullable },
         { typeof(short), PrimitiveTypeCode.Int16 },
         { typeof(short?), PrimitiveTypeCode.Int16Nullable },
         { typeof(ushort), PrimitiveTypeCode.UInt16 },
         { typeof(ushort?), PrimitiveTypeCode.UInt16Nullable },
         { typeof(int), PrimitiveTypeCode.Int32 },
         { typeof(int?), PrimitiveTypeCode.Int32Nullable },
         { typeof(byte), PrimitiveTypeCode.Byte },
         { typeof(byte?), PrimitiveTypeCode.ByteNullable },
         { typeof(uint), PrimitiveTypeCode.UInt32 },
         { typeof(uint?), PrimitiveTypeCode.UInt32Nullable },
         { typeof(long), PrimitiveTypeCode.Int64 },
         { typeof(long?), PrimitiveTypeCode.Int64Nullable },
         { typeof(ulong), PrimitiveTypeCode.UInt64 },
         { typeof(ulong?), PrimitiveTypeCode.UInt64Nullable },
         { typeof(float), PrimitiveTypeCode.Single },
         { typeof(float?), PrimitiveTypeCode.SingleNullable },
         { typeof(double), PrimitiveTypeCode.Double },
         { typeof(double?), PrimitiveTypeCode.DoubleNullable },
         { typeof(DateTime), PrimitiveTypeCode.DateTime },
         { typeof(DateTime?), PrimitiveTypeCode.DateTimeNullable },
         { typeof(DateTimeOffset), PrimitiveTypeCode.DateTimeOffset },
         { typeof(DateTimeOffset?), PrimitiveTypeCode.DateTimeOffsetNullable },
         { typeof(decimal), PrimitiveTypeCode.Decimal },
         { typeof(decimal?), PrimitiveTypeCode.DecimalNullable },
         { typeof(Guid), PrimitiveTypeCode.Guid },
         { typeof(Guid?), PrimitiveTypeCode.GuidNullable },
         { typeof(TimeSpan), PrimitiveTypeCode.TimeSpan },
         { typeof(TimeSpan?), PrimitiveTypeCode.TimeSpanNullable },
         { typeof(BigInteger), PrimitiveTypeCode.BigInteger },
         { typeof(BigInteger?), PrimitiveTypeCode.BigIntegerNullable },
         { typeof(Uri), PrimitiveTypeCode.Uri },
         { typeof(string), PrimitiveTypeCode.String },
         { typeof(byte[]), PrimitiveTypeCode.Bytes },
         { typeof(DBNull), PrimitiveTypeCode.DBNull }
     };
     ConvertUtils.PrimitiveTypeCodes = new TypeInformation[] { new TypeInformation()
                                                               {
                                                                   Type     = typeof(object),
                                                                   TypeCode = PrimitiveTypeCode.Empty
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(object),
                                                                   TypeCode = PrimitiveTypeCode.Object
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(object),
                                                                   TypeCode = PrimitiveTypeCode.DBNull
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(bool),
                                                                   TypeCode = PrimitiveTypeCode.Boolean
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(char),
                                                                   TypeCode = PrimitiveTypeCode.Char
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(sbyte),
                                                                   TypeCode = PrimitiveTypeCode.SByte
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(byte),
                                                                   TypeCode = PrimitiveTypeCode.Byte
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(short),
                                                                   TypeCode = PrimitiveTypeCode.Int16
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(ushort),
                                                                   TypeCode = PrimitiveTypeCode.UInt16
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(int),
                                                                   TypeCode = PrimitiveTypeCode.Int32
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(uint),
                                                                   TypeCode = PrimitiveTypeCode.UInt32
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(long),
                                                                   TypeCode = PrimitiveTypeCode.Int64
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(ulong),
                                                                   TypeCode = PrimitiveTypeCode.UInt64
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(float),
                                                                   TypeCode = PrimitiveTypeCode.Single
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(double),
                                                                   TypeCode = PrimitiveTypeCode.Double
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(decimal),
                                                                   TypeCode = PrimitiveTypeCode.Decimal
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(DateTime),
                                                                   TypeCode = PrimitiveTypeCode.DateTime
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(object),
                                                                   TypeCode = PrimitiveTypeCode.Empty
                                                               }, new TypeInformation()
                                                               {
                                                                   Type     = typeof(string),
                                                                   TypeCode = PrimitiveTypeCode.String
                                                               } };
     ConvertUtils.CastConverters = new ThreadSafeStore <StructMultiKey <Type, Type>, Func <object, object> >(new Func <StructMultiKey <Type, Type>, Func <object, object> >(ConvertUtils.CreateCastConverter));
 }
Example #4
0
 static EnumUtils()
 {
     EnumUtils.EnumMemberNamesPerType = new ThreadSafeStore <Type, BidirectionalDictionary <string, string> >(new Func <Type, BidirectionalDictionary <string, string> >(EnumUtils.InitializeEnumType));
 }
 static ConvertUtils()
 {
     ConvertUtils.CastConverters = new ThreadSafeStore <ConvertUtils.TypeConvertKey, Func <object, object> >(new Func <ConvertUtils.TypeConvertKey, Func <object, object> >(ConvertUtils.CreateCastConverter));
 }