C# SqlTypeCode类代码示例

 public NumericType(SqlTypeCode typeCode, int precision, int scale)
     : base("NUMERIC", typeCode)
 {
     AssertIsNumeric(typeCode);
     Precision = precision;
     Scale = scale;
 }

        public void GetRuntimeType(SqlTypeCode code, Type expectedType)
        {
            var type = PrimitiveTypes.Interval(code);
            var objType = type.GetRuntimeType();

            Assert.AreEqual(expectedType, objType);
        }

 public NumericType(SqlTypeCode sqlType, int size, byte scale)
     : base("NUMERIC", sqlType)
 {
     AssertIsNumeric(sqlType);
     Size = size;
     Scale = scale;
 }

 public ColumnAttribute(string name, SqlTypeCode type, int size, int scale)
 {
     ColumnName = name;
     SqlType = type;
     Size = size;
     Scale = scale;
 }

        public static void GetRuntime(SqlTypeCode code, Type expectedType)
        {
            var type = PrimitiveTypes.Numeric(code);

            var runtimeType = type.GetRuntimeType();
            Assert.AreEqual(expectedType, runtimeType);
        }

        public void ParseString(string input, SqlTypeCode typeCode)
        {
            var sqlType = SqlType.Parse(input);

            Assert.IsNotNull(sqlType);
            Assert.IsInstanceOf<DateType>(sqlType);
            Assert.AreEqual(typeCode, sqlType.TypeCode);
        }

        public void ParseString(string input, SqlTypeCode expected)
        {
            var type = SqlType.Parse(input);

            Assert.IsNotNull(type);
            Assert.IsInstanceOf<IntervalType>(type);

            Assert.AreEqual(expected, type.TypeCode);
        }

        public StringType(SqlTypeCode typeCode, int maxSize, Encoding encoding, CultureInfo locale)
            : base("STRING", typeCode)
        {
            if (encoding == null)
                throw new ArgumentNullException("encoding");

            AssertIsString(typeCode);
            MaxSize = maxSize;
            Locale = locale;
            Encoding = encoding;
        }

        public void CastToString(SqlTypeCode typeCode, bool value, string expected)
        {
            var type = PrimitiveTypes.Boolean(typeCode);

            var boolean = new SqlBoolean(value);

            var casted = type.CastTo(boolean, PrimitiveTypes.String());

            Assert.IsInstanceOf<SqlString>(casted);
            Assert.AreEqual(expected, casted.ToString());
        }

        public static SqlType Resolve(SqlTypeCode typeCode, string typeName, DataTypeMeta[] metadata, ITypeResolver resolver)
        {
            if (PrimitiveTypes.IsPrimitive(typeCode))
                return PrimitiveTypes.Resolve(typeCode, typeName, metadata);

            if (resolver == null)
                throw new NotSupportedException(String.Format("Cannot resolve type '{0}' without context.", typeName));

            var resolveCcontext = new TypeResolveContext(typeCode, typeName, metadata);
            return resolver.ResolveType(resolveCcontext);
        }

        public static void ParseString(string input, SqlTypeCode expectedTypeCode, int expectedSize)
        {
            var sqlType = SqlType.Parse(input);

            Assert.IsNotNull(sqlType);
            Assert.IsInstanceOf<BinaryType>(sqlType);
            Assert.AreEqual(expectedTypeCode, sqlType.TypeCode);

            var binType = (BinaryType) sqlType;
            Assert.AreEqual(expectedSize, binType.MaxSize);
        }

        public TypeResolveContext(SqlTypeCode typeCode, string typeName, DataTypeMeta[] meta)
        {
            TypeCode = typeCode;
            TypeName = typeName;

            this.meta = new Dictionary<string, DataTypeMeta>(StringComparer.OrdinalIgnoreCase);

            if (meta != null) {
                foreach (var typeMeta in meta) {
                    this.meta[typeMeta.Name] = typeMeta;
                }
            }
        }

        public static void CreateFrom(SqlTypeCode code, int precision, int scale, object value)
        {
            var type = PrimitiveTypes.Numeric(code, precision, scale);

            var result = type.CreateFrom(value);
            Assert.IsNotNull(result);
            Assert.IsFalse(result.IsNull);
            Assert.IsInstanceOf<SqlNumber>(result);

            var number = (SqlNumber) result;
            Assert.AreEqual(scale, number.Scale);
            Assert.AreEqual(precision, number.Precision);
        }

 public static BooleanType Boolean(SqlTypeCode sqlType)
 {
     return new BooleanType(sqlType);
 }

 public static DateType DateTime(SqlTypeCode sqlType)
 {
     return new DateType(sqlType);
 }