C# Type.GetTypeCode方法代码示例

 internal static InternalPrimitiveTypeE ToCode(Type type) =>
         type == null ? ToPrimitiveTypeEnum(TypeCode.Empty) :
         type.GetTypeInfo().IsPrimitive ? ToPrimitiveTypeEnum(type.GetTypeCode()) :
         ReferenceEquals(type, s_typeofDateTime) ? InternalPrimitiveTypeE.DateTime :
         ReferenceEquals(type, s_typeofTimeSpan) ? InternalPrimitiveTypeE.TimeSpan :
         ReferenceEquals(type, s_typeofDecimal) ? InternalPrimitiveTypeE.Decimal :
         InternalPrimitiveTypeE.Invalid;

 public static bool IsInteger(Type type)
 {
     type = GetNonNullableType(type);
     if (type.GetTypeInfo().IsEnum)
     {
         return false;
     }
     switch (type.GetTypeCode())
     {
         case TypeCode.Byte:
         case TypeCode.SByte:
         case TypeCode.Int16:
         case TypeCode.Int32:
         case TypeCode.Int64:
         case TypeCode.UInt16:
         case TypeCode.UInt32:
         case TypeCode.UInt64:
             return true;
         default:
             return false;
     }
 }

 public static bool IsNumeric(Type type)
 {
     type = GetNonNullableType(type);
     if (!type.GetTypeInfo().IsEnum)
     {
         switch (type.GetTypeCode())
         {
             case TypeCode.Char:
             case TypeCode.SByte:
             case TypeCode.Byte:
             case TypeCode.Int16:
             case TypeCode.Int32:
             case TypeCode.Int64:
             case TypeCode.Double:
             case TypeCode.Single:
             case TypeCode.UInt16:
             case TypeCode.UInt32:
             case TypeCode.UInt64:
                 return true;
         }
     }
     return false;
 }

 private static string GetArrayItemName(Type type)
 {
     switch (type.GetTypeCode())
     {
         case TypeCode.Boolean:
             return "boolean";
         case TypeCode.DateTime:
             return "dateTime";
         case TypeCode.Decimal:
             return "decimal";
         case TypeCode.Int32:
             return "int";
         case TypeCode.Int64:
             return "long";
         case TypeCode.Single:
             return "float";
         case TypeCode.Double:
             return "double";
         default:
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxInvalidUseOfPrimitiveOperationFormatter));
     }
 }

 internal void WriteAnyType(object value, Type valueType)
 {
     bool handled = true;
     switch (valueType.GetTypeCode())
     {
         case TypeCode.Boolean:
             WriteBoolean((bool)value);
             break;
         case TypeCode.Char:
             WriteChar((char)value);
             break;
         case TypeCode.Byte:
             WriteUnsignedByte((byte)value);
             break;
         case TypeCode.Int16:
             WriteShort((short)value);
             break;
         case TypeCode.Int32:
             WriteInt((int)value);
             break;
         case TypeCode.Int64:
             WriteLong((long)value);
             break;
         case TypeCode.Single:
             WriteFloat((float)value);
             break;
         case TypeCode.Double:
             WriteDouble((double)value);
             break;
         case TypeCode.Decimal:
             WriteDecimal((decimal)value);
             break;
         case TypeCode.DateTime:
             WriteDateTime((DateTime)value);
             break;
         case TypeCode.String:
             WriteString((string)value);
             break;
         case TypeCode.SByte:
             WriteSignedByte((sbyte)value);
             break;
         case TypeCode.UInt16:
             WriteUnsignedShort((ushort)value);
             break;
         case TypeCode.UInt32:
             WriteUnsignedInt((uint)value);
             break;
         case TypeCode.UInt64:
             WriteUnsignedLong((ulong)value);
             break;
         case TypeCode.Empty:
         case TypeCode.Object:
         default:
             if (valueType == Globals.TypeOfByteArray)
                 WriteBase64((byte[])value);
             else if (valueType == Globals.TypeOfObject)
             {
                 //Write Nothing
             }
             else if (valueType == Globals.TypeOfTimeSpan)
                 WriteTimeSpan((TimeSpan)value);
             else if (valueType == Globals.TypeOfGuid)
                 WriteGuid((Guid)value);
             else if (valueType == Globals.TypeOfUri)
                 WriteUri((Uri)value);
             else if (valueType == Globals.TypeOfXmlQualifiedName)
                 WriteQName((XmlQualifiedName)value);
             else
                 handled = false;
             break;
     }
     if (!handled)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateInvalidPrimitiveTypeException(valueType));
 }

 // Determines if the type is an integer we can switch on.
 private static bool CanOptimizeSwitchType(Type valueType)
 {
     // enums & char are allowed
     switch (valueType.GetTypeCode())
     {
         case TypeCode.Byte:
         case TypeCode.SByte:
         case TypeCode.Char:
         case TypeCode.Int16:
         case TypeCode.Int32:
         case TypeCode.UInt16:
         case TypeCode.UInt32:
         case TypeCode.Int64:
         case TypeCode.UInt64:
             return true;
         default:
             return false;
     }
 }

 internal SwitchInfo(SwitchExpression node, LocalBuilder value, Label @default)
 {
     Node = node;
     Value = value;
     Default = @default;
     Type = Node.SwitchValue.Type;
     IsUnsigned = TypeUtils.IsUnsigned(Type);
     var code = Type.GetTypeCode();
     Is64BitSwitch = code == TypeCode.UInt64 || code == TypeCode.Int64;
 }

 private string GetTypeNameHelper(Type type)
 {
     switch (type.GetTypeCode())
     {
         case TypeCode.Boolean:
             return "win:Boolean";
         case TypeCode.Byte:
             return "win:UInt8";
         case TypeCode.Char:
         case TypeCode.UInt16:
             return "win:UInt16";
         case TypeCode.UInt32:
             return "win:UInt32";
         case TypeCode.UInt64:
             return "win:UInt64";
         case TypeCode.SByte:
             return "win:Int8";
         case TypeCode.Int16:
             return "win:Int16";
         case TypeCode.Int32:
             return "win:Int32";
         case TypeCode.Int64:
             return "win:Int64";
         case TypeCode.String:
             return "win:UnicodeString";
         case TypeCode.Single:
             return "win:Float";
         case TypeCode.Double:
             return "win:Double";
         case TypeCode.DateTime:
             return "win:FILETIME";
         default:
             if (type == typeof(Guid))
                 return "win:GUID";
             else if (type == typeof(IntPtr))
                 return "win:Pointer";
             else if ((type.IsArray || type.IsPointer) && type.GetElementType() == typeof(byte))
                 return "win:Binary";
                 
             ManifestError(Resources.GetResourceString("EventSource_UnsupportedEventTypeInManifest", type.Name), true);
             return string.Empty;
     }
 }

 public static bool IsUnsignedInt(Type type)
 {
     type = GetNonNullableType(type);
     if (!type.GetTypeInfo().IsEnum)
     {
         switch (type.GetTypeCode())
         {
             case TypeCode.UInt16:
             case TypeCode.UInt32:
             case TypeCode.UInt64:
                 return true;
         }
     }
     return false;
 }

 private void EmitConstantOne(Type type)
 {
     switch (type.GetTypeCode())
     {
         case TypeCode.UInt16:
         case TypeCode.UInt32:
         case TypeCode.Int16:
         case TypeCode.Int32:
             _ilg.Emit(OpCodes.Ldc_I4_1);
             break;
         case TypeCode.Int64:
         case TypeCode.UInt64:
             _ilg.Emit(OpCodes.Ldc_I8, (long)1);
             break;
         case TypeCode.Single:
             _ilg.Emit(OpCodes.Ldc_R4, 1.0f);
             break;
         case TypeCode.Double:
             _ilg.Emit(OpCodes.Ldc_R8, 1.0d);
             break;
         default:
             // we only have to worry about arithmetic types, see
             // TypeUtils.IsArithmetic
             throw ContractUtils.Unreachable;
     }
 }

        // Binary/unary operations on 8 and 16 bit operand types will leave a 
        // 32-bit value on the stack, because that's how IL works. For these
        // cases, we need to cast it back to the resultType, possibly using a
        // checked conversion if the original operator was convert
        private void EmitConvertArithmeticResult(ExpressionType op, Type resultType)
        {
            Debug.Assert(!resultType.IsNullableType());

            switch (resultType.GetTypeCode())
            {
                case TypeCode.Byte:
                    _ilg.Emit(IsChecked(op) ? OpCodes.Conv_Ovf_U1 : OpCodes.Conv_U1);
                    break;
                case TypeCode.SByte:
                    _ilg.Emit(IsChecked(op) ? OpCodes.Conv_Ovf_I1 : OpCodes.Conv_I1);
                    break;
                case TypeCode.UInt16:
                    _ilg.Emit(IsChecked(op) ? OpCodes.Conv_Ovf_U2 : OpCodes.Conv_U2);
                    break;
                case TypeCode.Int16:
                    _ilg.Emit(IsChecked(op) ? OpCodes.Conv_Ovf_I2 : OpCodes.Conv_I2);
                    break;
            }
        }

 internal static bool IsFloatingPoint(Type type)
 {
     type = GetNonNullableType(type);
     switch (type.GetTypeCode())
     {
         case TypeCode.Single:
         case TypeCode.Double:
             return true;
         default:
             return false;
     }
 }

 internal static bool IsUnsigned(Type type)
 {
     type = GetNonNullableType(type);
     switch (type.GetTypeCode())
     {
         case TypeCode.Byte:
         case TypeCode.UInt16:
         case TypeCode.Char:
         case TypeCode.UInt32:
         case TypeCode.UInt64:
             return true;
         default:
             return false;
     }
 }

 public static bool IsConvertible(Type type)
 {
     type = GetNonNullableType(type);
     if (type.GetTypeInfo().IsEnum)
     {
         return true;
     }
     switch (type.GetTypeCode())
     {
         case TypeCode.Boolean:
         case TypeCode.Byte:
         case TypeCode.SByte:
         case TypeCode.Int16:
         case TypeCode.Int32:
         case TypeCode.Int64:
         case TypeCode.UInt16:
         case TypeCode.UInt32:
         case TypeCode.UInt64:
         case TypeCode.Single:
         case TypeCode.Double:
         case TypeCode.Char:
             return true;
         default:
             return false;
     }
 }

 public static bool IsIntegerOrBool(Type type)
 {
     type = GetNonNullableType(type);
     if (!type.GetTypeInfo().IsEnum)
     {
         switch (type.GetTypeCode())
         {
             case TypeCode.Int64:
             case TypeCode.Int32:
             case TypeCode.Int16:
             case TypeCode.UInt64:
             case TypeCode.UInt32:
             case TypeCode.UInt16:
             case TypeCode.Boolean:
             case TypeCode.SByte:
             case TypeCode.Byte:
                 return true;
         }
     }
     return false;
 }