mcs/class/referencesource/System.Data/System/Data/Common/SQLConvert.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="SQLConvert.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">Microsoft</owner>
   6 // <owner current="true" primary="false">Microsoft</owner>
   7 //------------------------------------------------------------------------------
   8 namespace System.Data.Common {
   9
  10     using System;
  11     using System.Data.SqlTypes;
  12     using System.Xml;
  13     using System.Globalization;
  14     using System.Diagnostics;
  15
  16     internal static class SqlConvert {
  17
  18         public static SqlByte ConvertToSqlByte(object value) {
  19             Debug.Assert(value != null, "null argument in ConvertToSqlByte");
  20             if ((value == DBNull.Value)) { // null is not valid, SqlByte is struct
  21                 return SqlByte.Null;
  22             }
  23             Type valueType = value.GetType();
  24             StorageType stype = DataStorage.GetStorageType(valueType);
  25
  26             switch(stype) {
  27             case StorageType.SqlByte:
  28                 return (SqlByte)value;
  29             case StorageType.Byte:
  30                 return (byte)value;
  31             default:
  32                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlByte));
  33             }
  34         }
  35
  36         public static SqlInt16 ConvertToSqlInt16(object value) {
  37             Debug.Assert(value != null, "null argument in ConvertToSqlInt16");
  38             if (value == DBNull.Value) {
  39                 return SqlInt16.Null;
  40             }
  41             Type valueType = value.GetType();
  42             StorageType stype = DataStorage.GetStorageType(valueType);
  43             switch(stype) {
  44             case StorageType.Byte:
  45                 return (byte)value;
  46             case StorageType.Int16:
  47                 return (Int16)value;
  48             case StorageType.SqlByte:
  49                 return (SqlByte) value;
  50             case StorageType.SqlInt16:
  51                 return (SqlInt16) value;
  52             default:
  53                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlInt16));
  54             }
  55         }
  56
  57         public static SqlInt32 ConvertToSqlInt32(object value) {
  58             Debug.Assert(value != null, "null argument in ConvertToSqlInt32");
  59            if (value == DBNull.Value) {
  60                return SqlInt32.Null;
  61             }
  62             Type valueType = value.GetType();
  63             StorageType stype = DataStorage.GetStorageType(valueType);
  64             switch(stype) {
  65             case StorageType.SqlInt32:
  66                 return (SqlInt32) value;
  67             case StorageType.Int32:
  68                 return (int) value;
  69             case StorageType.SqlInt16:
  70                 return  (SqlInt16)value;
  71             case StorageType.Int16:
  72                 return (Int16) value;
  73             case StorageType.UInt16:
  74                 return (UInt16) value;
  75             case StorageType.SqlByte:
  76                 return (SqlByte)value;
  77             case StorageType.Byte:
  78                 return (byte)value;
  79
  80             default:
  81                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlInt32));
  82             }
  83         }
  84
  85         public static SqlInt64 ConvertToSqlInt64(object value) {
  86             Debug.Assert(value != null, "null argument in ConvertToSqlInt64");
  87            if (value == DBNull.Value) {
  88                return SqlInt32.Null;
  89             }
  90             Type valueType = value.GetType();
  91             StorageType stype = DataStorage.GetStorageType(valueType);
  92             switch(stype) {
  93             case StorageType.SqlInt64:
  94                 return (SqlInt64) value;
  95             case StorageType.Int64:
  96                 return (Int64) value;
  97             case StorageType.SqlInt16:
  98                 return (SqlInt16)value;
  99             case StorageType.Int16:
 100                 return (Int16)value;
 101             case StorageType.UInt16:
 102                 return (UInt16)value;
 103             case StorageType.SqlInt32:
 104                 return (SqlInt32)value;
 105             case StorageType.Int32:
 106                 return (Int32)value;
 107             case StorageType.UInt32:
 108                 return (UInt32)value;
 109             case StorageType.SqlByte:
 110                 return (SqlByte)value;
 111             case StorageType.Byte:
 112                 return (byte)value;
 113             default:
 114                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlInt64));
 115             }
 116         }
 117
 118        public static SqlDouble ConvertToSqlDouble(object value) {
 119            Debug.Assert(value != null, "null argument in ConvertToSqlDouble");
 120            if (value == DBNull.Value) {
 121                return SqlDouble.Null;
 122             }
 123             Type valueType = value.GetType();
 124             StorageType stype = DataStorage.GetStorageType(valueType);
 125
 126             switch(stype) {
 127             case StorageType.SqlDouble:
 128                 return (SqlDouble)value;
 129             case StorageType.Double:
 130                 return (double)value;
 131             case StorageType.SqlInt64:
 132                 return (SqlInt64) value;
 133             case StorageType.Int64:
 134                 return (Int64) value;
 135             case StorageType.UInt64:
 136                 return (UInt64) value;
 137             case StorageType.SqlInt16:
 138                 return (SqlInt16)value;
 139             case StorageType.Int16:
 140                 return (Int16)value;
 141             case StorageType.UInt16:
 142                 return (UInt16)value;
 143             case StorageType.SqlInt32:
 144                 return (SqlInt32)value;
 145             case StorageType.Int32:
 146                 return (Int32)value;
 147             case StorageType.UInt32:
 148                 return (UInt32)value;
 149             case StorageType.SqlByte:
 150                 return (SqlByte)value;
 151             case StorageType.Byte:
 152                 return (byte)value;
 153             case StorageType.SqlSingle:
 154                 return (SqlSingle)value;
 155             case StorageType.Single:
 156                 return (Single)value;
 157             case StorageType.SqlMoney:
 158                 return (SqlMoney)value;
 159             case StorageType.SqlDecimal:
 160                 return (SqlDecimal)value;
 161             default:
 162                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlDouble));
 163             }
 164         }
 165
 166        public static SqlDecimal ConvertToSqlDecimal(object value) {
 167            Debug.Assert(value != null, "null argument in ConvertToSqlDecimal");
 168            if (value == DBNull.Value) {
 169                return SqlDecimal.Null;
 170             }
 171             Type valueType = value.GetType();
 172             StorageType stype = DataStorage.GetStorageType(valueType);
 173
 174             switch(stype) {
 175             case StorageType.SqlDecimal:
 176                 return (SqlDecimal)value;
 177             case StorageType.Decimal:
 178                 return (decimal)value;
 179             case StorageType.SqlInt64:
 180                 return (SqlInt64) value;
 181             case StorageType.Int64:
 182                 return (Int64) value;
 183             case StorageType.UInt64:
 184                 return (UInt64) value;
 185             case StorageType.SqlInt16:
 186                 return (SqlInt16)value;
 187             case StorageType.Int16:
 188                 return (Int16)value;
 189             case StorageType.UInt16:
 190                 return (UInt16)value;
 191             case StorageType.SqlInt32:
 192                 return (SqlInt32)value;
 193             case StorageType.Int32:
 194                 return (Int32)value;
 195             case StorageType.UInt32:
 196                 return (UInt32)value;
 197             case StorageType.SqlByte:
 198                 return (SqlByte)value;
 199             case StorageType.Byte:
 200                 return (byte)value;
 201             case StorageType.SqlMoney:
 202                 return (SqlMoney)value;
 203             default:
 204                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlDecimal));
 205             }
 206         }
 207
 208         public static SqlSingle ConvertToSqlSingle(object value) {
 209            Debug.Assert(value != null, "null argument in ConvertToSqlSingle");
 210            if (value == DBNull.Value) {
 211                return SqlSingle.Null;
 212             }
 213             Type valueType = value.GetType();
 214             StorageType stype = DataStorage.GetStorageType(valueType);
 215
 216             switch(stype) {
 217             case StorageType.SqlSingle:
 218                 return (SqlSingle)value;
 219             case StorageType.Single:
 220                 return (Single)value;
 221             case StorageType.SqlInt64:
 222                 return (SqlInt64) value;
 223             case StorageType.Int64:
 224                 return (Int64) value;
 225             case StorageType.UInt64:
 226                 return (UInt64) value;
 227             case StorageType.SqlInt16:
 228                 return (SqlInt16)value;
 229             case StorageType.Int16:
 230                 return (Int16)value;
 231             case StorageType.UInt16:
 232                 return (UInt16)value;
 233             case StorageType.SqlInt32:
 234                 return (SqlInt32)value;
 235             case StorageType.Int32:
 236                 return (Int32)value;
 237             case StorageType.UInt32:
 238                 return (UInt32)value;
 239             case StorageType.SqlByte:
 240                 return (SqlByte)value;
 241             case StorageType.Byte:
 242                 return (byte)value;
 243             case StorageType.SqlMoney:
 244                 return (SqlMoney)value;
 245             case StorageType.SqlDecimal:
 246                 return (SqlDecimal)value;
 247             default:
 248                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlSingle));
 249             }
 250         }
 251
 252         public static SqlMoney ConvertToSqlMoney(object value) {
 253            Debug.Assert(value != null, "null argument in ConvertToSqlMoney");
 254            if (value == DBNull.Value) {
 255                return SqlMoney.Null;
 256             }
 257             Type valueType = value.GetType();
 258             StorageType stype = DataStorage.GetStorageType(valueType);
 259
 260             switch(stype) {
 261             case StorageType.SqlMoney:
 262                 return (SqlMoney)value;
 263             case StorageType.Decimal:
 264                 return (decimal)value;
 265             case StorageType.SqlInt64:
 266                 return (SqlInt64) value;
 267             case StorageType.Int64:
 268                 return (Int64) value;
 269             case StorageType.UInt64:
 270                 return (UInt64) value;
 271             case StorageType.SqlInt16:
 272                 return (SqlInt16)value;
 273             case StorageType.Int16:
 274                 return (Int16)value;
 275             case StorageType.UInt16:
 276                 return (UInt16)value;
 277             case StorageType.SqlInt32:
 278                 return (SqlInt32)value;
 279             case StorageType.Int32:
 280                 return (Int32)value;
 281             case StorageType.UInt32:
 282                 return (UInt32)value;
 283             case StorageType.SqlByte:
 284                 return (SqlByte)value;
 285             case StorageType.Byte:
 286                 return (byte)value;
 287             default:
 288                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlMoney));
 289             }
 290         }
 291
 292
 293         public static SqlDateTime ConvertToSqlDateTime(object value) {
 294            Debug.Assert(value != null, "null argument in ConvertToSqlDateTime");
 295            if (value == DBNull.Value) {
 296                return SqlDateTime.Null;
 297             }
 298             Type valueType = value.GetType();
 299             StorageType stype = DataStorage.GetStorageType(valueType);
 300
 301             switch(stype) {
 302             case StorageType.SqlDateTime:
 303                 return (SqlDateTime)value;
 304             case StorageType.DateTime:
 305                 return (DateTime) value;
 306             default:
 307                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlDateTime));
 308             }
 309         }
 310
 311         public static SqlBoolean ConvertToSqlBoolean(object value) {
 312            Debug.Assert(value != null, "null argument in ConvertToSqlBoolean");
 313            if ((value == DBNull.Value) || (value == null)) {
 314                return SqlBoolean.Null;
 315             }
 316             Type valueType = value.GetType();
 317             StorageType stype = DataStorage.GetStorageType(valueType);
 318
 319             switch(stype) {
 320             case StorageType.SqlBoolean:
 321                 return (SqlBoolean)value;
 322             case StorageType.Boolean:
 323                 return (bool) value;
 324             default:
 325                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlBoolean));
 326             }
 327         }
 328
 329         public static SqlGuid ConvertToSqlGuid(object value) {
 330             Debug.Assert(value != null, "null argument in ConvertToSqlGuid");
 331             if (value == DBNull.Value) {
 332                 return SqlGuid.Null;
 333             }
 334             Type valueType = value.GetType();
 335             StorageType stype = DataStorage.GetStorageType(valueType);
 336
 337             switch(stype) {
 338             case StorageType.SqlGuid:
 339                 return (SqlGuid)value;
 340             case StorageType.Guid:
 341                 return (Guid) value;
 342             default:
 343                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlGuid));
 344             }
 345         }
 346
 347        public static SqlBinary ConvertToSqlBinary(object value) {
 348            Debug.Assert(value != null, "null argument in ConvertToSqlBinary");
 349             if (value == DBNull.Value) {
 350                 return SqlBinary.Null;
 351             }
 352             Type valueType = value.GetType();
 353             StorageType stype = DataStorage.GetStorageType(valueType);
 354
 355             switch(stype) {
 356             case StorageType.SqlBinary:
 357                 return (SqlBinary) value;
 358             case StorageType.ByteArray:
 359                 return (byte[])value;
 360             default:
 361                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlBinary));
 362             }
 363        }
 364
 365        public static SqlString ConvertToSqlString(object value) {
 366            Debug.Assert(value != null, "null argument in ConvertToSqlString");
 367            if ((value == DBNull.Value) || (value == null)) {
 368                  return SqlString.Null;
 369             }
 370             Type valueType = value.GetType();
 371             StorageType stype = DataStorage.GetStorageType(valueType);
 372
 373             switch(stype) {
 374             case StorageType.SqlString:
 375                 return (SqlString)value;
 376             case StorageType.String:
 377                 return (string)value;
 378             default:
 379                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlString));
 380             }
 381        }
 382
 383        public static SqlChars ConvertToSqlChars(object value) {
 384            Debug.Assert(value != null, "null argument in ConvertToSqlChars");
 385            if (value == DBNull.Value) {
 386                return SqlChars.Null;
 387            }
 388            Type valueType = value.GetType();
 389            StorageType stype = DataStorage.GetStorageType(valueType);
 390            switch(stype) {
 391             case StorageType.SqlChars:
 392                 return (SqlChars)value;
 393             default:
 394                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlChars));
 395             }
 396        }
 397
 398        public static SqlBytes ConvertToSqlBytes(object value) {
 399            Debug.Assert(value != null, "null argument in ConvertToSqlBytes");
 400            if (value == DBNull.Value) {
 401                return SqlBytes.Null;
 402            }
 403            Type valueType = value.GetType();
 404            StorageType stype = DataStorage.GetStorageType(valueType);
 405            switch(stype) {
 406             case StorageType.SqlBytes:
 407                 return (SqlBytes)value;
 408             default:
 409                 throw ExceptionBuilder.ConvertFailed(valueType, typeof(SqlBytes));
 410             }
 411        }
 412
 413        public static DateTimeOffset ConvertStringToDateTimeOffset(string value, IFormatProvider formatProvider) {
 414            return DateTimeOffset.Parse(value, formatProvider);
 415        }
 416         // this should not be called for XmlSerialization
 417         public static object ChangeTypeForDefaultValue(object value, Type type, IFormatProvider formatProvider) {
 418             if (type == typeof(System.Numerics.BigInteger)) {
 419                 if ((DBNull.Value == value) || (null == value)) { return DBNull.Value; }
 420                 return BigIntegerStorage.ConvertToBigInteger(value, formatProvider);
 421             }
 422             else if (value is System.Numerics.BigInteger) {
 423                 return BigIntegerStorage.ConvertFromBigInteger((System.Numerics.BigInteger)value, type, formatProvider);
 424             }
 425
 426             return ChangeType2(value, DataStorage.GetStorageType(type), type, formatProvider);
 427         }
 428
 429         // this should not be called for XmlSerialization
 430         public static object ChangeType2(object value, StorageType stype, Type type, IFormatProvider formatProvider) {
 431             switch(stype) { // if destination is SQL type
 432             case StorageType.SqlBinary:
 433                 return (SqlConvert.ConvertToSqlBinary(value));
 434             case StorageType.SqlBoolean:
 435                 return (SqlConvert.ConvertToSqlBoolean(value));
 436             case StorageType.SqlByte:
 437                 return (SqlConvert.ConvertToSqlByte(value));
 438             case StorageType.SqlBytes:
 439                 return (SqlConvert.ConvertToSqlBytes(value));
 440             case StorageType.SqlChars:
 441                 return (SqlConvert.ConvertToSqlChars(value));
 442             case StorageType.SqlDateTime:
 443                 return (SqlConvert.ConvertToSqlDateTime(value));
 444             case StorageType.SqlDecimal:
 445                 return (SqlConvert.ConvertToSqlDecimal(value));
 446             case StorageType.SqlDouble:
 447                 return (SqlConvert.ConvertToSqlDouble(value));
 448             case StorageType.SqlGuid:
 449                 return (SqlConvert.ConvertToSqlGuid(value));
 450             case StorageType.SqlInt16:
 451                 return (SqlConvert.ConvertToSqlInt16(value));
 452             case StorageType.SqlInt32:
 453                 return (SqlConvert.ConvertToSqlInt32(value));
 454             case StorageType.SqlInt64:
 455                 return (SqlConvert.ConvertToSqlInt64(value));
 456             case StorageType.SqlMoney:
 457                 return (SqlConvert.ConvertToSqlMoney(value));
 458             case StorageType.SqlSingle:
 459                 return (SqlConvert.ConvertToSqlSingle(value));
 460             case StorageType.SqlString:
 461                 return (SqlConvert.ConvertToSqlString(value));
 462 /*            case StorageType.SqlXml:
 463                 if (DataStorage.IsObjectNull(value)) {
 464                     return SqlXml.Null;
 465                 }
 466                 goto default;
 467 */
 468             default: // destination is CLR
 469                 if ((DBNull.Value == value) || (null == value)) {
 470                     return DBNull.Value;
 471                 }
 472                 Type valueType = value.GetType();
 473                 StorageType vtype = DataStorage.GetStorageType(valueType);
 474                 // destination is CLR
 475                 switch(vtype) {// and source is SQL type
 476                 case StorageType.SqlBinary:
 477                 case StorageType.SqlBoolean:
 478                 case StorageType.SqlByte:
 479                 case StorageType.SqlBytes:
 480                 case StorageType.SqlChars:
 481                 case StorageType.SqlDateTime:
 482                 case StorageType.SqlDecimal:
 483                 case StorageType.SqlDouble:
 484                 case StorageType.SqlGuid:
 485                 case StorageType.SqlInt16:
 486                 case StorageType.SqlInt32:
 487                 case StorageType.SqlInt64:
 488                 case StorageType.SqlMoney:
 489                 case StorageType.SqlSingle:
 490                 case StorageType.SqlString:
 491                     throw ExceptionBuilder.ConvertFailed(valueType, type);
 492                 default: // source is CLR type
 493                     if (StorageType.String == stype) { // destination is string
 494                         switch(vtype) { // source's  type
 495                         case StorageType.Boolean:
 496                             return ((IConvertible)(bool)value).ToString(formatProvider);
 497                         case StorageType.Char:
 498                             return ((IConvertible)(Char)value).ToString(formatProvider);
 499                         case StorageType.SByte:
 500                             return ((IConvertible)(SByte)value).ToString(formatProvider);
 501                         case StorageType.Byte:
 502                             return ((IConvertible)(Byte)value).ToString(formatProvider);
 503                         case StorageType.Int16:
 504                             return ((IConvertible)(Int16)value).ToString(formatProvider);
 505                         case StorageType.UInt16:
 506                             return ((IConvertible)(UInt16)value).ToString(formatProvider);
 507                         case StorageType.Int32:
 508                             return ((IConvertible)(Int32)value).ToString(formatProvider);
 509                         case StorageType.UInt32:
 510                             return ((IConvertible)(UInt32)value).ToString(formatProvider);
 511                         case StorageType.Int64:
 512                             return ((IConvertible)(Int64)value).ToString(formatProvider);
 513                         case StorageType.UInt64:
 514                             return ((IConvertible)(UInt64)value).ToString(formatProvider);
 515                         case StorageType.Single:
 516                             return ((IConvertible)(Single)value).ToString(formatProvider);
 517                         case StorageType.Double:
 518                             return ((IConvertible)(Double)value).ToString(formatProvider);
 519                         case StorageType.Decimal:
 520                             return ((IConvertible)(Decimal)value).ToString(formatProvider);
 521                         case StorageType.DateTime:
 522                             return ((IConvertible)(DateTime)value).ToString(formatProvider);
 523                             //return  XmlConvert.ToString((DateTime) value, XmlDateTimeSerializationMode.RoundtripKind);
 524                         case StorageType.TimeSpan:
 525                             return  XmlConvert.ToString((TimeSpan) value);
 526                         case StorageType.Guid:
 527                             return  XmlConvert.ToString((Guid) value);
 528                         case StorageType.String:
 529                             return  (string)value;
 530                         case StorageType.CharArray:
 531                             return new string((char[])value);
 532                         case StorageType.DateTimeOffset:
 533                             return ((DateTimeOffset)value).ToString(formatProvider);
 534                         case StorageType.BigInteger:
 535                             break;
 536                         default:
 537                             IConvertible iconvertible = (value as IConvertible);
 538                             if (null != iconvertible) {
 539                                 return iconvertible.ToString(formatProvider);
 540                             }
 541                             // catch additional classes like Guid
 542                             IFormattable iformattable = (value as IFormattable);
 543                             if (null != iformattable) {
 544                                 return iformattable.ToString((string)null, formatProvider);
 545                             }
 546                             return value.ToString();
 547                         }
 548                     }
 549                     else if (StorageType.TimeSpan == stype) { // destination is TimeSpan
 550                         //WebData 110216, Handle TimeSpan convert the same way as we handle in storage
 551                         switch(vtype) {
 552                         case StorageType.String:
 553                             return XmlConvert.ToTimeSpan((string) value);
 554                         case StorageType.Int32:
 555                             return new TimeSpan((Int64)(Int32)value);
 556                         case StorageType.Int64:
 557                             return new TimeSpan((Int64)value);
 558                         default:
 559                             return (TimeSpan) value;
 560                         }
 561                     }
 562                     else if (StorageType.DateTimeOffset == stype) { // destination is DateTimeOffset
 563                         return (DateTimeOffset) value;
 564                     }
 565                     else if (StorageType.String == vtype){ // if source is string
 566                         switch(stype) { // type of destination
 567                         case StorageType.String:
 568                             return  (string)value;
 569                         case StorageType.Boolean:
 570                             if ("1" == (string)value) return true;
 571                             if ("0" == (string)value) return false;
 572                             break;
 573                         case StorageType.Char:
 574                             return ((IConvertible)(string)value).ToChar(formatProvider);
 575                         case StorageType.SByte:
 576                             return ((IConvertible)(string)value).ToSByte(formatProvider);
 577                         case StorageType.Byte:
 578                             return ((IConvertible)(string)value).ToByte(formatProvider);
 579                         case StorageType.Int16:
 580                             return ((IConvertible)(string)value).ToInt16(formatProvider);
 581                         case StorageType.UInt16:
 582                             return ((IConvertible)(string)value).ToUInt16(formatProvider);
 583                         case StorageType.Int32:
 584                             return ((IConvertible)(string)value).ToInt32(formatProvider);
 585                         case StorageType.UInt32:
 586                             return ((IConvertible)(string)value).ToUInt32(formatProvider);
 587                         case StorageType.Int64:
 588                             return ((IConvertible)(string)value).ToInt64(formatProvider);
 589                         case StorageType.UInt64:
 590                             return ((IConvertible)(string)value).ToUInt64(formatProvider);
 591                         case StorageType.Single:
 592                             return ((IConvertible)(string)value).ToSingle(formatProvider);
 593                         case StorageType.Double:
 594                             return ((IConvertible)(string)value).ToDouble(formatProvider);
 595                         case StorageType.Decimal:
 596                             return ((IConvertible)(string)value).ToDecimal(formatProvider);
 597                         case StorageType.DateTime:
 598                             return ((IConvertible)(string)value).ToDateTime(formatProvider);
 599                             //return  XmlConvert.ToDateTime((string) value, XmlDateTimeSerializationMode.RoundtripKind);
 600                         case StorageType.TimeSpan:
 601                             return  XmlConvert.ToTimeSpan((string) value);
 602                         case StorageType.Guid:
 603                             return  XmlConvert.ToGuid((string) value);
 604                         case StorageType.Uri:
 605                             return  new Uri((string) value);
 606                         default: // other clr types,
 607                             break;
 608                         }
 609                     }
 610                     return Convert.ChangeType(value, type, formatProvider);
 611                 }
 612             }
 613         }
 614
 615         // this should be called for XmlSerialization
 616         public static object ChangeTypeForXML(object value, Type type) {
 617             Debug.Assert(value is string || type == typeof(string) , "invalid call to ChangeTypeForXML");
 618             StorageType destinationType = DataStorage.GetStorageType(type);
 619             Type valueType = value.GetType();
 620             StorageType vtype = DataStorage.GetStorageType(valueType);
 621
 622             switch(destinationType) { // if destination is not string
 623                 case StorageType.SqlBinary:
 624                     return new SqlBinary(Convert.FromBase64String((string)value));
 625                 case StorageType.SqlBoolean:
 626                     return new SqlBoolean(XmlConvert.ToBoolean((string)value));
 627                 case StorageType.SqlByte:
 628                     return new SqlByte(XmlConvert.ToByte((string)value));
 629                 case StorageType.SqlBytes:
 630                     return new SqlBytes(Convert.FromBase64String((string)value));
 631                 case StorageType.SqlChars:
 632                     return new SqlChars(((string)value).ToCharArray());
 633                 case StorageType.SqlDateTime:
 634                     return new SqlDateTime(XmlConvert.ToDateTime((string)value, XmlDateTimeSerializationMode.RoundtripKind));
 635                 case StorageType.SqlDecimal:
 636                     return SqlDecimal.Parse((string)value); // parses invariant format and is larger has larger range then Decimal
 637                 case StorageType.SqlDouble:
 638                     return new SqlDouble(XmlConvert.ToDouble((string)value));
 639                 case StorageType.SqlGuid:
 640                     return new SqlGuid(XmlConvert.ToGuid((string)value));
 641                 case StorageType.SqlInt16:
 642                     return new SqlInt16(XmlConvert.ToInt16((string)value));
 643                 case StorageType.SqlInt32:
 644                     return new SqlInt32(XmlConvert.ToInt32((string)value));
 645                 case StorageType.SqlInt64:
 646                     return new SqlInt64(XmlConvert.ToInt64((string)value));
 647                 case StorageType.SqlMoney:
 648                     return new SqlMoney(XmlConvert.ToDecimal((string)value));
 649                 case StorageType.SqlSingle:
 650                     return new SqlSingle(XmlConvert.ToSingle((string)value));
 651                 case StorageType.SqlString:
 652                     return new SqlString((string)value);
 653 //                case StorageType.SqlXml: // What to do
 654 //                    if (DataStorage.IsObjectNull(value)) {
 655 //                        return SqlXml.Null;
 656 //                    }
 657 //                    goto default;
 658                 case StorageType.Boolean:
 659                     if ("1" == (string)value) return true;
 660                     if ("0" == (string)value) return false;
 661                     return XmlConvert.ToBoolean((string) value);
 662                 case StorageType.Char:
 663                     return  XmlConvert.ToChar((string) value);
 664                 case StorageType.SByte:
 665                     return  XmlConvert.ToSByte((string) value);
 666                 case StorageType.Byte:
 667                     return  XmlConvert.ToByte((string) value);
 668                 case StorageType.Int16:
 669                     return  XmlConvert.ToInt16((string) value);
 670                 case StorageType.UInt16:
 671                     return  XmlConvert.ToUInt16((string) value);
 672                 case StorageType.Int32:
 673                     return  XmlConvert.ToInt32((string) value);
 674                 case StorageType.UInt32:
 675                     return  XmlConvert.ToUInt32((string) value);
 676                 case StorageType.Int64:
 677                     return  XmlConvert.ToInt64((string) value);
 678                 case StorageType.UInt64:
 679                     return  XmlConvert.ToUInt64((string) value);
 680                 case StorageType.Single:
 681                     return  XmlConvert.ToSingle((string) value);
 682                 case StorageType.Double:
 683                     return  XmlConvert.ToDouble((string) value);
 684                 case StorageType.Decimal:
 685                     return  XmlConvert.ToDecimal((string) value);
 686                 case StorageType.DateTime:
 687                     return XmlConvert.ToDateTime((string)value, XmlDateTimeSerializationMode.RoundtripKind);
 688                 case StorageType.Guid:
 689                     return  XmlConvert.ToGuid((string) value);
 690                 case StorageType.Uri:
 691                     return  new Uri((string) value);
 692                 case StorageType.DateTimeOffset:
 693                     return XmlConvert.ToDateTimeOffset((string)value);
 694                 case StorageType.TimeSpan:
 695                     //WebData 110216, Handle TimeSpan convert the same way as we handle in storage
 696                     switch(vtype) {
 697                         case StorageType.String:
 698                             return XmlConvert.ToTimeSpan((string) value);
 699                         case StorageType.Int32:
 700                             return new TimeSpan((Int64)(Int32)value);
 701                         case StorageType.Int64:
 702                             return new TimeSpan((Int64)value);
 703                         default:
 704                             return (TimeSpan) value;
 705                     }
 706                 default: {
 707                     if ((DBNull.Value == value) || (null == value)) {
 708                         return DBNull.Value;
 709                     }
 710
 711                     switch(vtype) { // To String
 712                         case StorageType.SqlBinary:
 713                             return Convert.ToBase64String(((SqlBinary)value).Value);
 714                         case StorageType.SqlBoolean:
 715                             return XmlConvert.ToString(((SqlBoolean)value).Value);
 716                         case StorageType.SqlByte:
 717                             return XmlConvert.ToString(((SqlByte)value).Value);
 718                         case StorageType.SqlBytes:
 719                             return Convert.ToBase64String(((SqlBytes)value).Value);
 720                         case StorageType.SqlChars:
 721                             return new string(((SqlChars)value).Value);
 722                         case StorageType.SqlDateTime:
 723                             return XmlConvert.ToString(((SqlDateTime)value).Value, XmlDateTimeSerializationMode.RoundtripKind);
 724                         case StorageType.SqlDecimal:
 725                             return ((SqlDecimal)value).ToString(); // converts using invariant format and is larger has larger range then Decimal
 726                         case StorageType.SqlDouble:
 727                             return XmlConvert.ToString(((SqlDouble)value).Value);
 728                         case StorageType.SqlGuid:
 729                             return XmlConvert.ToString(((SqlGuid)value).Value);
 730                         case StorageType.SqlInt16:
 731                             return XmlConvert.ToString(((SqlInt16)value).Value);
 732                         case StorageType.SqlInt32:
 733                             return XmlConvert.ToString(((SqlInt32)value).Value);
 734                         case StorageType.SqlInt64:
 735                             return XmlConvert.ToString(((SqlInt64)value).Value);
 736                         case StorageType.SqlMoney:
 737                             return XmlConvert.ToString(((SqlMoney)value).Value);
 738                         case StorageType.SqlSingle:
 739                             return XmlConvert.ToString(((SqlSingle)value).Value);
 740                         case StorageType.SqlString:
 741                             return ((SqlString)value).Value;
 742                         case StorageType.Boolean:
 743                             return  XmlConvert.ToString((bool) value);
 744                         case StorageType.Char:
 745                             return  XmlConvert.ToString((Char) value);
 746                         case StorageType.SByte:
 747                             return  XmlConvert.ToString((SByte) value);
 748                         case StorageType.Byte:
 749                             return  XmlConvert.ToString((Byte) value);
 750                         case StorageType.Int16:
 751                             return  XmlConvert.ToString((Int16) value);
 752                         case StorageType.UInt16:
 753                             return  XmlConvert.ToString((UInt16) value);
 754                         case StorageType.Int32:
 755                             return  XmlConvert.ToString((Int32) value);
 756                         case StorageType.UInt32:
 757                             return  XmlConvert.ToString((UInt32) value);
 758                         case StorageType.Int64:
 759                             return  XmlConvert.ToString((Int64) value);
 760                         case StorageType.UInt64:
 761                             return  XmlConvert.ToString((UInt64) value);
 762                         case StorageType.Single:
 763                             return  XmlConvert.ToString((Single) value);
 764                         case StorageType.Double:
 765                             return  XmlConvert.ToString((Double) value);
 766                         case StorageType.Decimal:
 767                             return  XmlConvert.ToString((Decimal) value);
 768                         case StorageType.DateTime:
 769                             return XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.RoundtripKind);
 770                         case StorageType.TimeSpan:
 771                             return  XmlConvert.ToString((TimeSpan) value);
 772                         case StorageType.Guid:
 773                             return  XmlConvert.ToString((Guid) value);
 774                         case StorageType.String:
 775                             return  (string)value;
 776                         case StorageType.CharArray:
 777                             return new string((char[])value);
 778                         case StorageType.DateTimeOffset:
 779                             return XmlConvert.ToString((DateTimeOffset)value);
 780                         default:
 781                             IConvertible iconvertible = (value as IConvertible);
 782                             if (null != iconvertible) {
 783                                 return iconvertible.ToString(System.Globalization.CultureInfo.InvariantCulture);
 784                             }
 785                             // catch additional classes like Guid
 786                             IFormattable iformattable = (value as IFormattable);
 787                             if (null != iformattable) {
 788                                 return iformattable.ToString((string)null, System.Globalization.CultureInfo.InvariantCulture);
 789                             }
 790                             return value.ToString();
 791                     }
 792                 }
 793             }
 794         }
 795     }
 796 }