InversionOfControl/Castle.MicroKernel/SubSystems/Conversion/Converters/Generics/GenericListConverter.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.MicroKernel.SubSystems.Conversion
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19         using System.Diagnostics;
  20         using Castle.Core.Configuration;
  21
  22         [Serializable]
  23         public class GenericListConverter : AbstractTypeConverter
  24         {
  25                 /// <summary>
  26                 /// Initializes a new instance of the <see cref="GenericListConverter"/> class.
  27                 /// </summary>
  28                 public GenericListConverter()
  29                 {
  30                 }
  31
  32                 public override bool CanHandleType(Type type)
  33                 {
  34                         if (!type.IsGenericType) return false;
  35
  36                         Type genericDef = type.GetGenericTypeDefinition();
  37
  38                         return (genericDef == typeof(IList<>)
  39                                 || genericDef == typeof(ICollection<>)
  40                                 || genericDef == typeof(List<>)
  41                                 || genericDef == typeof(IEnumerable<>));
  42                 }
  43
  44                 public override object PerformConversion(String value, Type targetType)
  45                 {
  46                         throw new NotImplementedException();
  47                 }
  48
  49                 public override object PerformConversion(IConfiguration configuration, Type targetType)
  50                 {
  51                         Debug.Assert(CanHandleType(targetType));
  52
  53                         Type[] argTypes = targetType.GetGenericArguments();
  54
  55                         if (argTypes.Length != 1)
  56                         {
  57                                 throw new ConverterException("Expected type with one generic argument.");
  58                         }
  59
  60                         String itemType = configuration.Attributes["type"];
  61                         Type convertTo = argTypes[0];
  62
  63                         if (itemType != null)
  64                         {
  65                                 convertTo = (Type) Context.Composition.PerformConversion(itemType, typeof(Type));
  66                         }
  67
  68                         IGenericCollectionConverterHelper converterHelper = (IGenericCollectionConverterHelper)
  69                                                                             Activator.CreateInstance(
  70                                                                                 typeof(ListHelper<>).MakeGenericType(convertTo),
  71                                                                                 this);
  72                         return converterHelper.ConvertConfigurationToCollection(configuration);
  73                 }
  74
  75                 private class ListHelper<T> : IGenericCollectionConverterHelper
  76                 {
  77                         private GenericListConverter parent;
  78
  79                         public ListHelper(GenericListConverter parent)
  80                         {
  81                                 this.parent = parent;
  82                         }
  83
  84                         public object ConvertConfigurationToCollection(IConfiguration configuration)
  85                         {
  86                                 List<T> list = new List<T>();
  87
  88                                 foreach(IConfiguration itemConfig in configuration.Children)
  89                                 {
  90                                         T item = (T) parent.Context.Composition.PerformConversion(itemConfig, typeof(T));
  91                                         list.Add(item);
  92                                 }
  93
  94                                 return list;
  95                         }
  96                 }
  97         }
  98 }