The Labs \ Source Viewer \ SSCLI \ System.Runtime.Serialization.Formatters.Binary \ Converter

  1. // ==++==
  2. //
  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. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class: Converter
  18. **
  19. **
  20. ** Purpose: Hexify and bin.base64 conversions
  21. **
  22. **
  23. ===========================================================*/
  24. namespace System.Runtime.Serialization.Formatters.Binary
  25. {
  26.    
  27.     using System.Threading;
  28.     using System.Runtime.Remoting;
  29.     using System.Runtime.Serialization;
  30.     using System;
  31.     using System.Reflection;
  32.     using System.Globalization;
  33.     using System.Text;
  34.     using System.Security.Permissions;
  35.    
  36.     internal sealed class Converter
  37.     {
  38.         private Converter()
  39.         {
  40.         }
  41.        
  42.        
  43.         private static int primitiveTypeEnumLength = 17;
  44.         //Number of PrimitiveTypeEnums
  45.         // The following section are utilities to read and write XML types
  46.        
  47.         static internal InternalPrimitiveTypeE ToCode(Type type)
  48.         {
  49.             SerTrace.Log("Converter", "ToCode Type Entry ", type);
  50.             InternalPrimitiveTypeE code;
  51.             if (type != null && !type.IsPrimitive) {
  52.                 if (type == typeofDateTime)
  53.                     code = InternalPrimitiveTypeE.DateTime;
  54.                 else if (type == typeofTimeSpan)
  55.                     code = InternalPrimitiveTypeE.TimeSpan;
  56.                 else if (type == typeofDecimal)
  57.                     code = InternalPrimitiveTypeE.Decimal;
  58.                 else
  59.                     code = InternalPrimitiveTypeE.Invalid;
  60.             }
  61.             else
  62.                 code = ToPrimitiveTypeEnum(Type.GetTypeCode(type));
  63.            
  64.             SerTrace.Log("Converter", "ToCode Exit ", ((Enum)code).ToString());
  65.             return code;
  66.         }
  67.        
  68.        
  69.        
  70.        
  71.         static internal bool IsWriteAsByteArray(InternalPrimitiveTypeE code)
  72.         {
  73.             bool isWrite = false;
  74.            
  75.             switch (code) {
  76.                 case InternalPrimitiveTypeE.Boolean:
  77.                 case InternalPrimitiveTypeE.Char:
  78.                 case InternalPrimitiveTypeE.Byte:
  79.                 case InternalPrimitiveTypeE.Double:
  80.                 case InternalPrimitiveTypeE.Int16:
  81.                 case InternalPrimitiveTypeE.Int32:
  82.                 case InternalPrimitiveTypeE.Int64:
  83.                 case InternalPrimitiveTypeE.SByte:
  84.                 case InternalPrimitiveTypeE.Single:
  85.                 case InternalPrimitiveTypeE.UInt16:
  86.                 case InternalPrimitiveTypeE.UInt32:
  87.                 case InternalPrimitiveTypeE.UInt64:
  88.                     isWrite = true;
  89.                     break;
  90.             }
  91.             return isWrite;
  92.         }
  93.        
  94.         static internal int TypeLength(InternalPrimitiveTypeE code)
  95.         {
  96.             int length = 0;
  97.            
  98.             switch (code) {
  99.                 case InternalPrimitiveTypeE.Boolean:
  100.                     length = 1;
  101.                     break;
  102.                 case InternalPrimitiveTypeE.Char:
  103.                     length = 2;
  104.                     break;
  105.                 case InternalPrimitiveTypeE.Byte:
  106.                     length = 1;
  107.                     break;
  108.                 case InternalPrimitiveTypeE.Double:
  109.                     length = 8;
  110.                     break;
  111.                 case InternalPrimitiveTypeE.Int16:
  112.                     length = 2;
  113.                     break;
  114.                 case InternalPrimitiveTypeE.Int32:
  115.                     length = 4;
  116.                     break;
  117.                 case InternalPrimitiveTypeE.Int64:
  118.                     length = 8;
  119.                     break;
  120.                 case InternalPrimitiveTypeE.SByte:
  121.                     length = 1;
  122.                     break;
  123.                 case InternalPrimitiveTypeE.Single:
  124.                     length = 4;
  125.                     break;
  126.                 case InternalPrimitiveTypeE.UInt16:
  127.                     length = 2;
  128.                     break;
  129.                 case InternalPrimitiveTypeE.UInt32:
  130.                     length = 4;
  131.                     break;
  132.                 case InternalPrimitiveTypeE.UInt64:
  133.                     length = 8;
  134.                     break;
  135.             }
  136.             return length;
  137.         }
  138.        
  139.        
  140.         static internal InternalNameSpaceE GetNameSpaceEnum(InternalPrimitiveTypeE code, Type type, WriteObjectInfo objectInfo, out string typeName)
  141.         {
  142.             SerTrace.Log("Converter", "GetNameSpaceEnum Entry ", ((Enum)code).ToString(), " type ", type);
  143.             InternalNameSpaceE nameSpaceEnum = InternalNameSpaceE.None;
  144.             typeName = null;
  145.            
  146.             if (code != InternalPrimitiveTypeE.Invalid) {
  147.                 switch (code) {
  148.                     case InternalPrimitiveTypeE.Boolean:
  149.                     case InternalPrimitiveTypeE.Char:
  150.                     case InternalPrimitiveTypeE.Byte:
  151.                     case InternalPrimitiveTypeE.Double:
  152.                     case InternalPrimitiveTypeE.Int16:
  153.                     case InternalPrimitiveTypeE.Int32:
  154.                     case InternalPrimitiveTypeE.Int64:
  155.                     case InternalPrimitiveTypeE.SByte:
  156.                     case InternalPrimitiveTypeE.Single:
  157.                     case InternalPrimitiveTypeE.UInt16:
  158.                     case InternalPrimitiveTypeE.UInt32:
  159.                     case InternalPrimitiveTypeE.UInt64:
  160.                     case InternalPrimitiveTypeE.DateTime:
  161.                     case InternalPrimitiveTypeE.TimeSpan:
  162.                         nameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
  163.                         typeName = "System." + ToComType(code);
  164.                         break;
  165.                     case InternalPrimitiveTypeE.Decimal:
  166.                        
  167.                         nameSpaceEnum = InternalNameSpaceE.UrtSystem;
  168.                         typeName = "System." + ToComType(code);
  169.                         break;
  170.                 }
  171.             }
  172.            
  173.             if ((nameSpaceEnum == InternalNameSpaceE.None) && (type != null)) {
  174.                 if (type == typeofString)
  175.                     nameSpaceEnum = InternalNameSpaceE.XdrString;
  176.                 else {
  177.                     if (objectInfo == null) {
  178.                         typeName = type.FullName;
  179.                         if (type.Assembly == urtAssembly)
  180.                             nameSpaceEnum = InternalNameSpaceE.UrtSystem;
  181.                         else
  182.                             nameSpaceEnum = InternalNameSpaceE.UrtUser;
  183.                     }
  184.                     else {
  185.                         typeName = objectInfo.GetTypeFullName();
  186.                         if (objectInfo.GetAssemblyString().Equals(urtAssemblyString))
  187.                             nameSpaceEnum = InternalNameSpaceE.UrtSystem;
  188.                         else
  189.                             nameSpaceEnum = InternalNameSpaceE.UrtUser;
  190.                     }
  191.                 }
  192.             }
  193.            
  194.             SerTrace.Log("Converter", "GetNameSpaceEnum Exit ", ((Enum)nameSpaceEnum).ToString(), " typeName ", typeName);
  195.             return nameSpaceEnum;
  196.         }
  197.        
  198.         // Returns a COM runtime type associated with the type code
  199.        
  200.         static internal Type ToArrayType(InternalPrimitiveTypeE code)
  201.         {
  202.             SerTrace.Log("Converter", "ToType Entry ", ((Enum)code).ToString());
  203.             if (arrayTypeA == null)
  204.                 InitArrayTypeA();
  205.             SerTrace.Log("Converter", "ToType Exit ", ((arrayTypeA[(int)code] == null) ? "null " : arrayTypeA[(int)code].Name));
  206.             return arrayTypeA[(int)code];
  207.         }
  208.        
  209.        
  210.         private static Type[] typeA;
  211.        
  212.         private static void InitTypeA()
  213.         {
  214.             Type[] typeATemp = new Type[primitiveTypeEnumLength];
  215.             typeATemp[(int)InternalPrimitiveTypeE.Invalid] = null;
  216.             typeATemp[(int)InternalPrimitiveTypeE.Boolean] = typeofBoolean;
  217.             typeATemp[(int)InternalPrimitiveTypeE.Byte] = typeofByte;
  218.             typeATemp[(int)InternalPrimitiveTypeE.Char] = typeofChar;
  219.             typeATemp[(int)InternalPrimitiveTypeE.Decimal] = typeofDecimal;
  220.             typeATemp[(int)InternalPrimitiveTypeE.Double] = typeofDouble;
  221.             typeATemp[(int)InternalPrimitiveTypeE.Int16] = typeofInt16;
  222.             typeATemp[(int)InternalPrimitiveTypeE.Int32] = typeofInt32;
  223.             typeATemp[(int)InternalPrimitiveTypeE.Int64] = typeofInt64;
  224.             typeATemp[(int)InternalPrimitiveTypeE.SByte] = typeofSByte;
  225.             typeATemp[(int)InternalPrimitiveTypeE.Single] = typeofSingle;
  226.             typeATemp[(int)InternalPrimitiveTypeE.TimeSpan] = typeofTimeSpan;
  227.             typeATemp[(int)InternalPrimitiveTypeE.DateTime] = typeofDateTime;
  228.             typeATemp[(int)InternalPrimitiveTypeE.UInt16] = typeofUInt16;
  229.             typeATemp[(int)InternalPrimitiveTypeE.UInt32] = typeofUInt32;
  230.             typeATemp[(int)InternalPrimitiveTypeE.UInt64] = typeofUInt64;
  231.             typeA = typeATemp;
  232.         }
  233.        
  234.        
  235.         private static Type[] arrayTypeA;
  236.        
  237.         private static void InitArrayTypeA()
  238.         {
  239.             Type[] arrayTypeATemp = new Type[primitiveTypeEnumLength];
  240.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Invalid] = null;
  241.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Boolean] = typeofBooleanArray;
  242.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Byte] = typeofByteArray;
  243.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Char] = typeofCharArray;
  244.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Decimal] = typeofDecimalArray;
  245.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Double] = typeofDoubleArray;
  246.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Int16] = typeofInt16Array;
  247.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Int32] = typeofInt32Array;
  248.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Int64] = typeofInt64Array;
  249.             arrayTypeATemp[(int)InternalPrimitiveTypeE.SByte] = typeofSByteArray;
  250.             arrayTypeATemp[(int)InternalPrimitiveTypeE.Single] = typeofSingleArray;
  251.             arrayTypeATemp[(int)InternalPrimitiveTypeE.TimeSpan] = typeofTimeSpanArray;
  252.             arrayTypeATemp[(int)InternalPrimitiveTypeE.DateTime] = typeofDateTimeArray;
  253.             arrayTypeATemp[(int)InternalPrimitiveTypeE.UInt16] = typeofUInt16Array;
  254.             arrayTypeATemp[(int)InternalPrimitiveTypeE.UInt32] = typeofUInt32Array;
  255.             arrayTypeATemp[(int)InternalPrimitiveTypeE.UInt64] = typeofUInt64Array;
  256.             arrayTypeA = arrayTypeATemp;
  257.         }
  258.        
  259.        
  260.         // Returns a COM runtime type associated with the type code
  261.        
  262.         static internal Type ToType(InternalPrimitiveTypeE code)
  263.         {
  264.             SerTrace.Log("Converter", "ToType Entry ", ((Enum)code).ToString());
  265.             if (typeA == null)
  266.                 InitTypeA();
  267.             SerTrace.Log("Converter", "ToType Exit ", ((typeA[(int)code] == null) ? "null " : typeA[(int)code].Name));
  268.             return typeA[(int)code];
  269.         }
  270.        
  271.        
  272.        
  273.        
  274.         static internal Array CreatePrimitiveArray(InternalPrimitiveTypeE code, int length)
  275.         {
  276.             Array array = null;
  277.             switch (code) {
  278.                 case InternalPrimitiveTypeE.Boolean:
  279.                     array = new bool[length];
  280.                     break;
  281.                 case InternalPrimitiveTypeE.Byte:
  282.                     array = new byte[length];
  283.                     break;
  284.                 case InternalPrimitiveTypeE.Char:
  285.                     array = new char[length];
  286.                     break;
  287.                 case InternalPrimitiveTypeE.Decimal:
  288.                     array = new decimal[length];
  289.                     break;
  290.                 case InternalPrimitiveTypeE.Double:
  291.                     array = new double[length];
  292.                     break;
  293.                 case InternalPrimitiveTypeE.Int16:
  294.                     array = new Int16[length];
  295.                     break;
  296.                 case InternalPrimitiveTypeE.Int32:
  297.                     array = new Int32[length];
  298.                     break;
  299.                 case InternalPrimitiveTypeE.Int64:
  300.                     array = new Int64[length];
  301.                     break;
  302.                 case InternalPrimitiveTypeE.SByte:
  303.                     array = new sbyte[length];
  304.                     break;
  305.                 case InternalPrimitiveTypeE.Single:
  306.                     array = new float[length];
  307.                     break;
  308.                 case InternalPrimitiveTypeE.TimeSpan:
  309.                     array = new TimeSpan[length];
  310.                     break;
  311.                 case InternalPrimitiveTypeE.DateTime:
  312.                     array = new DateTime[length];
  313.                     break;
  314.                 case InternalPrimitiveTypeE.UInt16:
  315.                     array = new UInt16[length];
  316.                     break;
  317.                 case InternalPrimitiveTypeE.UInt32:
  318.                     array = new UInt32[length];
  319.                     break;
  320.                 case InternalPrimitiveTypeE.UInt64:
  321.                     array = new UInt64[length];
  322.                     break;
  323.             }
  324.             return array;
  325.         }
  326.        
  327.         static internal bool IsPrimitiveArray(Type type, out object typeInformation)
  328.         {
  329.             typeInformation = null;
  330.             bool bIsPrimitive = true;
  331.            
  332.             if (type == typeofBooleanArray)
  333.                 typeInformation = InternalPrimitiveTypeE.Boolean;
  334.             else if (type == typeofByteArray)
  335.                 typeInformation = InternalPrimitiveTypeE.Byte;
  336.             else if (type == typeofCharArray)
  337.                 typeInformation = InternalPrimitiveTypeE.Char;
  338.             else if (type == typeofDoubleArray)
  339.                 typeInformation = InternalPrimitiveTypeE.Double;
  340.             else if (type == typeofInt16Array)
  341.                 typeInformation = InternalPrimitiveTypeE.Int16;
  342.             else if (type == typeofInt32Array)
  343.                 typeInformation = InternalPrimitiveTypeE.Int32;
  344.             else if (type == typeofInt64Array)
  345.                 typeInformation = InternalPrimitiveTypeE.Int64;
  346.             else if (type == typeofSByteArray)
  347.                 typeInformation = InternalPrimitiveTypeE.SByte;
  348.             else if (type == typeofSingleArray)
  349.                 typeInformation = InternalPrimitiveTypeE.Single;
  350.             else if (type == typeofUInt16Array)
  351.                 typeInformation = InternalPrimitiveTypeE.UInt16;
  352.             else if (type == typeofUInt32Array)
  353.                 typeInformation = InternalPrimitiveTypeE.UInt32;
  354.             else if (type == typeofUInt64Array)
  355.                 typeInformation = InternalPrimitiveTypeE.UInt64;
  356.             else
  357.                 bIsPrimitive = false;
  358.             return bIsPrimitive;
  359.         }
  360.        
  361.        
  362.         private static string[] valueA;
  363.        
  364.         private static void InitValueA()
  365.         {
  366.             string[] valueATemp = new string[primitiveTypeEnumLength];
  367.             valueATemp[(int)InternalPrimitiveTypeE.Invalid] = null;
  368.             valueATemp[(int)InternalPrimitiveTypeE.Boolean] = "Boolean";
  369.             valueATemp[(int)InternalPrimitiveTypeE.Byte] = "Byte";
  370.             valueATemp[(int)InternalPrimitiveTypeE.Char] = "Char";
  371.             valueATemp[(int)InternalPrimitiveTypeE.Decimal] = "Decimal";
  372.             valueATemp[(int)InternalPrimitiveTypeE.Double] = "Double";
  373.             valueATemp[(int)InternalPrimitiveTypeE.Int16] = "Int16";
  374.             valueATemp[(int)InternalPrimitiveTypeE.Int32] = "Int32";
  375.             valueATemp[(int)InternalPrimitiveTypeE.Int64] = "Int64";
  376.             valueATemp[(int)InternalPrimitiveTypeE.SByte] = "SByte";
  377.             valueATemp[(int)InternalPrimitiveTypeE.Single] = "Single";
  378.             valueATemp[(int)InternalPrimitiveTypeE.TimeSpan] = "TimeSpan";
  379.             valueATemp[(int)InternalPrimitiveTypeE.DateTime] = "DateTime";
  380.             valueATemp[(int)InternalPrimitiveTypeE.UInt16] = "UInt16";
  381.             valueATemp[(int)InternalPrimitiveTypeE.UInt32] = "UInt32";
  382.             valueATemp[(int)InternalPrimitiveTypeE.UInt64] = "UInt64";
  383.             valueA = valueATemp;
  384.         }
  385.        
  386.         // Returns a String containg a COM+ runtime type associated with the type code
  387.        
  388.         static internal string ToComType(InternalPrimitiveTypeE code)
  389.         {
  390.             SerTrace.Log("Converter", "ToComType Entry ", ((Enum)code).ToString());
  391.            
  392.             if (valueA == null)
  393.                 InitValueA();
  394.            
  395.             SerTrace.Log("Converter", "ToComType Exit ", ((valueA[(int)code] == null) ? "null" : valueA[(int)code]));
  396.            
  397.             return valueA[(int)code];
  398.         }
  399.        
  400.         private static TypeCode[] typeCodeA;
  401.        
  402.         private static void InitTypeCodeA()
  403.         {
  404.             TypeCode[] typeCodeATemp = new TypeCode[primitiveTypeEnumLength];
  405.             typeCodeATemp[(int)InternalPrimitiveTypeE.Invalid] = TypeCode.Object;
  406.             typeCodeATemp[(int)InternalPrimitiveTypeE.Boolean] = TypeCode.Boolean;
  407.             typeCodeATemp[(int)InternalPrimitiveTypeE.Byte] = TypeCode.Byte;
  408.             typeCodeATemp[(int)InternalPrimitiveTypeE.Char] = TypeCode.Char;
  409.             typeCodeATemp[(int)InternalPrimitiveTypeE.Decimal] = TypeCode.Decimal;
  410.             typeCodeATemp[(int)InternalPrimitiveTypeE.Double] = TypeCode.Double;
  411.             typeCodeATemp[(int)InternalPrimitiveTypeE.Int16] = TypeCode.Int16;
  412.             typeCodeATemp[(int)InternalPrimitiveTypeE.Int32] = TypeCode.Int32;
  413.             typeCodeATemp[(int)InternalPrimitiveTypeE.Int64] = TypeCode.Int64;
  414.             typeCodeATemp[(int)InternalPrimitiveTypeE.SByte] = TypeCode.SByte;
  415.             typeCodeATemp[(int)InternalPrimitiveTypeE.Single] = TypeCode.Single;
  416.             typeCodeATemp[(int)InternalPrimitiveTypeE.TimeSpan] = TypeCode.Object;
  417.             typeCodeATemp[(int)InternalPrimitiveTypeE.DateTime] = TypeCode.DateTime;
  418.             typeCodeATemp[(int)InternalPrimitiveTypeE.UInt16] = TypeCode.UInt16;
  419.             typeCodeATemp[(int)InternalPrimitiveTypeE.UInt32] = TypeCode.UInt32;
  420.             typeCodeATemp[(int)InternalPrimitiveTypeE.UInt64] = TypeCode.UInt64;
  421.             typeCodeA = typeCodeATemp;
  422.         }
  423.        
  424.         // Returns a System.TypeCode from a InternalPrimitiveTypeE
  425.         static internal TypeCode ToTypeCode(InternalPrimitiveTypeE code)
  426.         {
  427.             if (typeCodeA == null)
  428.                 InitTypeCodeA();
  429.             return typeCodeA[(int)code];
  430.         }
  431.        
  432.        
  433.         private static InternalPrimitiveTypeE[] codeA;
  434.        
  435.         private static void InitCodeA()
  436.         {
  437.             InternalPrimitiveTypeE[] codeATemp = new InternalPrimitiveTypeE[19];
  438.             codeATemp[(int)TypeCode.Empty] = InternalPrimitiveTypeE.Invalid;
  439.             codeATemp[(int)TypeCode.Object] = InternalPrimitiveTypeE.Invalid;
  440.             codeATemp[(int)TypeCode.DBNull] = InternalPrimitiveTypeE.Invalid;
  441.             codeATemp[(int)TypeCode.Boolean] = InternalPrimitiveTypeE.Boolean;
  442.             codeATemp[(int)TypeCode.Char] = InternalPrimitiveTypeE.Char;
  443.             codeATemp[(int)TypeCode.SByte] = InternalPrimitiveTypeE.SByte;
  444.             codeATemp[(int)TypeCode.Byte] = InternalPrimitiveTypeE.Byte;
  445.             codeATemp[(int)TypeCode.Int16] = InternalPrimitiveTypeE.Int16;
  446.             codeATemp[(int)TypeCode.UInt16] = InternalPrimitiveTypeE.UInt16;
  447.             codeATemp[(int)TypeCode.Int32] = InternalPrimitiveTypeE.Int32;
  448.             codeATemp[(int)TypeCode.UInt32] = InternalPrimitiveTypeE.UInt32;
  449.             codeATemp[(int)TypeCode.Int64] = InternalPrimitiveTypeE.Int64;
  450.             codeATemp[(int)TypeCode.UInt64] = InternalPrimitiveTypeE.UInt64;
  451.             codeATemp[(int)TypeCode.Single] = InternalPrimitiveTypeE.Single;
  452.             codeATemp[(int)TypeCode.Double] = InternalPrimitiveTypeE.Double;
  453.             codeATemp[(int)TypeCode.Decimal] = InternalPrimitiveTypeE.Decimal;
  454.             codeATemp[(int)TypeCode.DateTime] = InternalPrimitiveTypeE.DateTime;
  455.             codeATemp[17] = InternalPrimitiveTypeE.Invalid;
  456.             codeATemp[(int)TypeCode.String] = InternalPrimitiveTypeE.Invalid;
  457.             codeA = codeATemp;
  458.         }
  459.        
  460.         // Returns a InternalPrimitiveTypeE from a System.TypeCode
  461.         static internal InternalPrimitiveTypeE ToPrimitiveTypeEnum(TypeCode typeCode)
  462.         {
  463.             if (codeA == null)
  464.                 InitCodeA();
  465.             return codeA[(int)typeCode];
  466.         }
  467.        
  468.         // Translates a string into an Object
  469.         static internal object FromString(string value, InternalPrimitiveTypeE code)
  470.         {
  471.             object var;
  472.             SerTrace.Log("Converter", "FromString Entry ", value, " ", ((Enum)code).ToString());
  473.             // InternalPrimitiveTypeE needs to be a primitive type
  474.             BCLDebug.Assert((code != InternalPrimitiveTypeE.Invalid), "[Converter.FromString]!InternalPrimitiveTypeE.Invalid ");
  475.             if (code != InternalPrimitiveTypeE.Invalid)
  476.                 var = Convert.ChangeType(value, ToTypeCode(code), CultureInfo.InvariantCulture);
  477.             else
  478.                 var = value;
  479.             SerTrace.Log("Converter", "FromString Exit " + ((var == null) ? "null" : var + " var type " + ((var == null) ? "<null>" : var.GetType().ToString())));
  480.             return var;
  481.         }
  482.        
  483.         static internal Type typeofISerializable = typeof(ISerializable);
  484.         static internal Type typeofString = typeof(string);
  485.         static internal Type typeofConverter = typeof(Converter);
  486.         static internal Type typeofBoolean = typeof(bool);
  487.         static internal Type typeofByte = typeof(byte);
  488.         static internal Type typeofChar = typeof(char);
  489.         static internal Type typeofDecimal = typeof(decimal);
  490.         static internal Type typeofDouble = typeof(double);
  491.         static internal Type typeofInt16 = typeof(Int16);
  492.         static internal Type typeofInt32 = typeof(Int32);
  493.         static internal Type typeofInt64 = typeof(Int64);
  494.         static internal Type typeofSByte = typeof(sbyte);
  495.         static internal Type typeofSingle = typeof(float);
  496.         static internal Type typeofTimeSpan = typeof(TimeSpan);
  497.         static internal Type typeofDateTime = typeof(DateTime);
  498.         static internal Type typeofUInt16 = typeof(UInt16);
  499.         static internal Type typeofUInt32 = typeof(UInt32);
  500.         static internal Type typeofUInt64 = typeof(UInt64);
  501.         static internal Type typeofObject = typeof(object);
  502.        
  503.         static internal Type typeofSystemVoid = typeof(void);
  504.         static internal Assembly urtAssembly = Assembly.GetAssembly(typeofString);
  505.         static internal string urtAssemblyString = urtAssembly.FullName;
  506.        
  507.         // Arrays
  508.         static internal Type typeofTypeArray = typeof(System.Type[]);
  509.         static internal Type typeofObjectArray = typeof(object[]);
  510.         static internal Type typeofStringArray = typeof(string[]);
  511.         static internal Type typeofBooleanArray = typeof(bool[]);
  512.         static internal Type typeofByteArray = typeof(byte[]);
  513.         static internal Type typeofCharArray = typeof(char[]);
  514.         static internal Type typeofDecimalArray = typeof(decimal[]);
  515.         static internal Type typeofDoubleArray = typeof(double[]);
  516.         static internal Type typeofInt16Array = typeof(Int16[]);
  517.         static internal Type typeofInt32Array = typeof(Int32[]);
  518.         static internal Type typeofInt64Array = typeof(Int64[]);
  519.         static internal Type typeofSByteArray = typeof(sbyte[]);
  520.         static internal Type typeofSingleArray = typeof(float[]);
  521.         static internal Type typeofTimeSpanArray = typeof(TimeSpan[]);
  522.         static internal Type typeofDateTimeArray = typeof(DateTime[]);
  523.         static internal Type typeofUInt16Array = typeof(UInt16[]);
  524.         static internal Type typeofUInt32Array = typeof(UInt32[]);
  525.         static internal Type typeofUInt64Array = typeof(UInt64[]);
  526.         static internal Type typeofMarshalByRefObject = typeof(System.MarshalByRefObject);
  527.     }
  528.    
  529. }

Developer Fusion