Components/Binder/Castle.Components.Binder/DefaultConverter.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Components.Binder
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.ComponentModel;
  21         using System.Web;
  22
  23         public class DefaultConverter : MarshalByRefObject, IConverter
  24         {
  25                 public bool CanConvert(Type desiredType, Type inputType, object input, out bool exactMatch)
  26                 {
  27                         exactMatch = false;
  28
  29                         if (input == null)
  30                         {
  31                                 return true;
  32                         }
  33                         else if (inputType == desiredType)
  34                         {
  35                                 exactMatch = true;
  36                         }
  37                         else if (!desiredType.IsInstanceOfType(input))
  38                         {
  39                                 TypeConverter conv = TypeDescriptor.GetConverter(desiredType);
  40                                 return (conv != null && conv.CanConvertFrom(inputType));
  41                         }
  42
  43                         return false;
  44                 }
  45
  46                 public object Convert(Type desiredType, Type inputType, object input, out bool conversionSucceeded)
  47                 {
  48                         if (inputType == desiredType) // Nothing to convert
  49                         {
  50                                 if (inputType == typeof(String))
  51                                 {
  52                                         if (input == null)
  53                                         {
  54                                                 conversionSucceeded = false;
  55                                                 return null;
  56                                         }
  57                                         else if (input.ToString().Length == 0)
  58                                         {
  59                                                 conversionSucceeded = true;
  60                                                 return null;
  61                                         }
  62                                         else
  63                                         {
  64                                                 conversionSucceeded = true;
  65                                                 return input.ToString().Trim(' ');
  66                                         }
  67                                 }
  68                                 else
  69                                 {
  70                                         conversionSucceeded = true;
  71                                         return input;
  72                                 }
  73                         }
  74
  75                         return Convert(desiredType, input, out conversionSucceeded);
  76                 }
  77
  78                 /// <summary>
  79                 /// Convert the input param into the desired type
  80                 /// </summary>
  81                 /// <param name="desiredType">Type of the desired</param>
  82                 /// <param name="input">The input</param>
  83                 /// <param name="conversionSucceeded">if <c>false</c> the return value must be ignored</param>
  84                 /// <remarks>
  85                 /// There are 3 possible cases when trying to convert:
  86                 /// 1) Input data for conversion missing (input is null or an empty String)
  87                 ///             Returns default conversion value (based on desired type) and set <c>conversionSucceeded = false</c>
  88                 /// 2) Has input data but cannot convert to particular type
  89                 ///             Throw exception and set <c>conversionSucceeded = false</c>
  90                 /// 3) Has input data and can convert to particular type
  91                 ///      Return input converted to desired type and set <c>conversionSucceeded = true</c>
  92                 /// </remarks>
  93                 public object Convert(Type desiredType, object input, out bool conversionSucceeded)
  94                 {
  95                         try
  96                         {
  97                                 conversionSucceeded = (input != null);
  98
  99                                 if (desiredType.IsInstanceOfType(input))
 100                                 {
 101                                         return input;
 102                                 }
 103                                 else if (desiredType == typeof(String))
 104                                 {
 105                                         if (conversionSucceeded && input.GetType() == typeof(string) && ((String) input) == String.Empty)
 106                                         {
 107                                                 return null;
 108                                         }
 109
 110                                         return conversionSucceeded ? input.ToString().Trim(' ') : null;
 111                                 }
 112                                 else if (desiredType.IsArray)
 113                                 {
 114                                         return conversionSucceeded
 115                                                 ?
 116                                                         ConvertToArray(desiredType, input, ref conversionSucceeded)
 117                                                 : null;
 118                                 }
 119                                 else if (desiredType.IsEnum)
 120                                 {
 121                                         return ConvertEnum(desiredType, input, ref conversionSucceeded);
 122                                 }
 123                                 else if (desiredType == typeof(Decimal))
 124                                 {
 125                                         return ConvertDecimal(input, ref conversionSucceeded);
 126                                 }
 127                                 else if (desiredType.IsPrimitive)
 128                                 {
 129                                         return ConvertPrimitive(desiredType, input, ref conversionSucceeded);
 130                                 }
 131                                 else if (desiredType.IsGenericType &&
 132                                          desiredType.GetGenericTypeDefinition() == typeof(Nullable<>))
 133                                 {
 134                                         return ConvertNullable(desiredType, input, ref conversionSucceeded);
 135                                 }
 136                                 else if (desiredType == typeof(Guid))
 137                                 {
 138                                         return ConvertGuid(input, ref conversionSucceeded);
 139                                 }
 140                                 else if (desiredType == typeof(DateTime))
 141                                 {
 142                                         return ConvertDate(input, ref conversionSucceeded);
 143                                 }
 144                                 else if (desiredType == typeof(HttpPostedFile))
 145                                 {
 146                                         return input;
 147                                 }
 148                                 else if (DataBinder.IsGenericList(desiredType))
 149                                 {
 150                                         return conversionSucceeded
 151                                                 ? ConvertGenericList(desiredType, input, ref conversionSucceeded)
 152                                                 : null;
 153                                 }
 154                                 else
 155                                 {
 156                                         return ConvertUsingTypeConverter(desiredType, input, ref conversionSucceeded);
 157                                 }
 158                         }
 159                         catch(BindingException)
 160                         {
 161                                 throw;
 162                         }
 163                         catch(Exception inner)
 164                         {
 165                                 conversionSucceeded = false;
 166
 167                                 ThrowInformativeException(desiredType, input, inner);
 168                                 return null;
 169                         }
 170                 }
 171
 172                 private object ConvertNullable(Type desiredType, object input, ref bool conversionSucceeded)
 173                 {
 174                         Type underlyingType = Nullable.GetUnderlyingType(desiredType);
 175
 176                         object value = Convert(underlyingType, input, out conversionSucceeded);
 177
 178                         if (conversionSucceeded && value != null)
 179                         {
 180                                 Type typeToConstruct = typeof(Nullable<>).MakeGenericType(underlyingType);
 181
 182                                 return Activator.CreateInstance(typeToConstruct, value);
 183                         }
 184                         else if (input != null)
 185                         {
 186                                 conversionSucceeded = true;
 187                         }
 188                         else
 189                         {
 190                                 conversionSucceeded = false;
 191                         }
 192
 193                         return null;
 194                 }
 195
 196                 private object ConvertGenericList(Type desiredType, object input, ref bool conversionSucceeded)
 197                 {
 198                         Type elemType = desiredType.GetGenericArguments()[0];
 199
 200                         input = FixInputForMonoIfNeeded(elemType, input);
 201
 202                         Type listType = typeof(List<>).MakeGenericType(elemType);
 203                         IList result = (IList) Activator.CreateInstance(listType);
 204                         Array values = input as Array;
 205
 206                         bool elementConversionSucceeded;
 207
 208                         for(int i = 0; i < values.Length; i++)
 209                         {
 210                                 result.Add(Convert(elemType, values.GetValue(i), out elementConversionSucceeded));
 211
 212                                 // if at least one list element get converted
 213                                 // we consider the conversion a success
 214                                 if (elementConversionSucceeded && !conversionSucceeded)
 215                                 {
 216                                         conversionSucceeded = true;
 217                                 }
 218                         }
 219
 220                         return result;
 221                 }
 222
 223                 /// <summary>
 224                 /// Fix for mod_mono issue where array values are passed as a comma seperated String.
 225                 /// </summary>
 226                 /// <param name="elemType"></param>
 227                 /// <param name="input"></param>
 228                 /// <returns></returns>
 229                 private static object FixInputForMonoIfNeeded(Type elemType, object input)
 230                 {
 231                         if (!input.GetType().IsArray)
 232                         {
 233                                 if (input.GetType() == typeof(String))
 234                                 {
 235                                         input = NormalizeInput(input);
 236
 237                                         if (input.ToString() == String.Empty)
 238                                         {
 239                                                 input = Array.CreateInstance(elemType, 0);
 240                                         }
 241                                         else
 242                                         {
 243                                                 input = input.ToString().Split(',');
 244                                         }
 245                                 }
 246                                 else
 247                                 {
 248                                         throw new BindingException("Cannot convert to collection of {0} from type {1}", elemType.FullName,
 249                                                                    input.GetType().FullName);
 250                                 }
 251                         }
 252
 253                         return input;
 254                 }
 255
 256                 private object ConvertGuid(object input, ref bool conversionSucceeded)
 257                 {
 258                         conversionSucceeded = true;
 259
 260                         if (input == null)
 261                         {
 262                                 conversionSucceeded = false;
 263                                 return null;
 264                         }
 265
 266                         String value = NormalizeInput(input);
 267
 268                         if (value == String.Empty)
 269                         {
 270                                 conversionSucceeded = true;
 271                                 return null;
 272                         }
 273                         else
 274                         {
 275                                 return new Guid(value);
 276                         }
 277                 }
 278
 279                 private object ConvertDecimal(object input, ref bool conversionSucceeded)
 280                 {
 281                         conversionSucceeded = true;
 282
 283                         if (input == null)
 284                         {
 285                                 conversionSucceeded = false;
 286                                 return null;
 287                         }
 288
 289                         String value = NormalizeInput(input);
 290
 291                         if (value == String.Empty)
 292                         {
 293                                 conversionSucceeded = true;
 294                                 return null;
 295                         }
 296                         else
 297                         {
 298                                 return System.Convert.ToDecimal(value);
 299                         }
 300                 }
 301
 302                 private object ConvertPrimitive(Type desiredType, object input, ref bool conversionSucceeded)
 303                 {
 304                         conversionSucceeded = true;
 305
 306                         String value = NormalizeInput(input);
 307
 308                         if (IsBool(desiredType))
 309                         {
 310                                 return SpecialBoolConversion(value, input, ref conversionSucceeded);
 311                         }
 312                         else if (input == null)
 313                         {
 314                                 conversionSucceeded = false;
 315                                 return null;
 316                         }
 317                         else if (value == String.Empty)
 318                         {
 319                                 conversionSucceeded = true;
 320                                 return null;
 321                         }
 322                         else
 323                         {
 324                                 return System.Convert.ChangeType(input, desiredType);
 325                         }
 326                 }
 327
 328                 private static object SpecialBoolConversion(string value, object input, ref bool conversionSucceeded)
 329                 {
 330                         if (input == null)
 331                         {
 332                                 conversionSucceeded = false;
 333                                 return null;
 334                         }
 335                         else if (value == String.Empty)
 336                         {
 337                                 conversionSucceeded = false;
 338                                 return false;
 339                         }
 340                         else
 341                         {
 342                                 if (value.IndexOf(',') != -1)
 343                                 {
 344                                         value = value.Substring(0, value.IndexOf(','));
 345                                 }
 346
 347                                 bool performNumericConversion = false;
 348
 349                                 foreach(char c in value.ToCharArray())
 350                                 {
 351                                         if (Char.IsNumber(c))
 352                                         {
 353                                                 performNumericConversion = true;
 354                                                 break;
 355                                         }
 356                                 }
 357
 358                                 if (performNumericConversion)
 359                                 {
 360                                         return System.Convert.ToBoolean(System.Convert.ToInt32(value));
 361                                 }
 362                                 else
 363                                 {
 364                                         return !(String.Compare("false", value, true) == 0);
 365                                 }
 366                         }
 367                 }
 368
 369                 private object ConvertToArray(Type desiredType, object input, ref bool conversionSucceeded)
 370                 {
 371                         Type elemType = desiredType.GetElementType();
 372
 373                         input = FixInputForMonoIfNeeded(elemType, input);
 374
 375                         Array values = input as Array;
 376                         Array result = Array.CreateInstance(elemType, values.Length);
 377
 378                         for(int i = 0; i < values.Length; i++)
 379                         {
 380                                 bool elementConversionSucceeded;
 381
 382                                 result.SetValue(Convert(elemType, values.GetValue(i), out elementConversionSucceeded), i);
 383
 384                                 // if at least one array element get converted
 385                                 // we consider the conversion a success
 386                                 if (elementConversionSucceeded && !conversionSucceeded)
 387                                 {
 388                                         conversionSucceeded = true;
 389                                 }
 390                         }
 391
 392                         return result;
 393                 }
 394
 395                 private static bool IsBool(Type desiredType)
 396                 {
 397                         bool isBool = desiredType == typeof(Boolean);
 398
 399                         if (!isBool)
 400                         {
 401                                 isBool = desiredType == typeof(bool?);
 402                         }
 403
 404                         return isBool;
 405                 }
 406
 407                 private static object ConvertEnum(Type desiredType, object input, ref bool conversionSucceeded)
 408                 {
 409                         conversionSucceeded = true;
 410
 411                         if (input == null)
 412                         {
 413                                 conversionSucceeded = false;
 414                                 return null;
 415                         }
 416
 417                         String value = NormalizeInput(input);
 418
 419                         if (value == String.Empty)
 420                         {
 421                                 conversionSucceeded = false;
 422                                 return null;
 423                         }
 424                         else
 425                         {
 426                                 return Enum.Parse(desiredType, value, true);
 427                         }
 428                 }
 429
 430                 private static object ConvertDate(object input, ref bool conversionSucceeded)
 431                 {
 432                         conversionSucceeded = true;
 433
 434                         if (input == null)
 435                         {
 436                                 conversionSucceeded = false;
 437                                 return null;
 438                         }
 439
 440                         String value = NormalizeInput(input);
 441
 442                         if (value == String.Empty)
 443                         {
 444                                 conversionSucceeded = false;
 445
 446                                 return null;
 447                         }
 448                         else
 449                         {
 450                                 return DateTime.Parse(value);
 451                         }
 452                 }
 453
 454                 /// <summary>
 455                 /// Support for types that specify a TypeConverter,
 456                 /// i.e.: NullableTypes
 457                 /// </summary>
 458                 private static object ConvertUsingTypeConverter(Type desiredType, object input, ref bool conversionSucceeded)
 459                 {
 460                         conversionSucceeded = true;
 461
 462                         Type sourceType = (input != null ? input.GetType() : typeof(String));
 463                         TypeConverter conv = TypeDescriptor.GetConverter(desiredType);
 464
 465                         if (conv != null && conv.CanConvertFrom(sourceType))
 466                         {
 467                                 try
 468                                 {
 469                                         return conv.ConvertFrom(input);
 470                                 }
 471                                 catch(Exception ex)
 472                                 {
 473                                         String message = String.Format("Conversion error: " +
 474                                                                        "Could not convert parameter with value '{0}' to {1}", input, desiredType);
 475
 476                                         throw new BindingException(message, ex);
 477                                 }
 478                         }
 479                         else
 480                         {
 481                                 String message = String.Format("Conversion error: " +
 482                                                                "Could not convert parameter with value '{0}' to {1}", input, desiredType);
 483
 484                                 throw new BindingException(message);
 485                         }
 486                 }
 487
 488                 private static String NormalizeInput(object input)
 489                 {
 490                         if (input == null)
 491                         {
 492                                 return String.Empty;
 493                         }
 494                         else
 495                         {
 496                                 if (!input.GetType().IsArray)
 497                                 {
 498                                         return input.ToString().Trim();
 499                                 }
 500                                 else
 501                                 {
 502                                         Array array = (Array) input;
 503
 504                                         String[] stArray = new string[array.GetLength(0)];
 505
 506                                         for(int i = 0; i < stArray.Length; i++)
 507                                         {
 508                                                 object itemVal = array.GetValue(i);
 509
 510                                                 if (itemVal != null)
 511                                                 {
 512                                                         stArray[i] = itemVal.ToString();
 513                                                 }
 514                                                 else
 515                                                 {
 516                                                         stArray[i] = String.Empty;
 517                                                 }
 518                                         }
 519
 520                                         return String.Join(",", stArray);
 521                                 }
 522                         }
 523                 }
 524
 525                 private static void ThrowInformativeException(Type desiredType, object input, Exception inner)
 526                 {
 527                         String message = String.Format("Conversion error: " +
 528                                                        "Could not convert parameter with value '{0}' to expected type {1}", input,
 529                                                        desiredType);
 530
 531                         throw new BindingException(message, inner);
 532                 }
 533         }
 534 }