class/System.ComponentModel.Composition/src/ComponentModel/System/ComponentModel/Composition/ReflectionModel/ImportingMember.cs

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.Collections;
   6 using System.ComponentModel.Composition.Hosting;
   7 using System.ComponentModel.Composition.Primitives;
   8 using System.Collections.Generic;
   9 using System.Diagnostics.CodeAnalysis;
  10 using System.Globalization;
  11 using System.Reflection;
  12 using Microsoft.Internal;
  13 using Microsoft.Internal.Collections;
  14
  15 namespace System.ComponentModel.Composition.ReflectionModel
  16 {
  17     internal class ImportingMember : ImportingItem
  18     {
  19         private readonly ReflectionWritableMember _member;
  20
  21         public ImportingMember(ContractBasedImportDefinition definition, ReflectionWritableMember member, ImportType importType)
  22             : base(definition, importType)
  23         {
  24             Assumes.NotNull(definition, member);
  25
  26             this._member = member;
  27         }
  28
  29         public void SetExportedValue(object instance, object value)
  30         {
  31             if (RequiresCollectionNormalization())
  32             {
  33                 this.SetCollectionMemberValue(instance, (IEnumerable)value);
  34             }
  35             else
  36             {
  37                 this.SetSingleMemberValue(instance, value);
  38             }
  39         }
  40
  41         private bool RequiresCollectionNormalization()
  42         {
  43             if (this.Definition.Cardinality != ImportCardinality.ZeroOrMore)
  44             {   // If we're not looking at a collection import, then don't
  45                 // 'normalize' the collection.
  46
  47                 return false;
  48             }
  49
  50             if (this._member.CanWrite && this.ImportType.IsAssignableCollectionType)
  51             {   // If we can simply replace the entire value of the property/field, then
  52                 // we don't need to 'normalize' the collection.
  53
  54                 return false;
  55             }
  56
  57             return true;
  58         }
  59
  60         private void SetSingleMemberValue(object instance, object value)
  61         {
  62             EnsureWritable();
  63
  64             try
  65             {
  66                 this._member.SetValue(instance, value);
  67             }
  68             catch (TargetInvocationException exception)
  69             {   // Member threw an exception. Avoid letting this
  70                 // leak out as a 'raw' unhandled exception, instead,
  71                 // we'll add some context and rethrow.
  72
  73                 throw new ComposablePartException(
  74                     CompositionErrorId.ReflectionModel_ImportThrewException,
  75                     String.Format(CultureInfo.CurrentCulture,
  76                         Strings.ReflectionModel_ImportThrewException,
  77                         this._member.GetDisplayName()),
  78                     Definition.ToElement(),
  79                     exception.InnerException);
  80             }
  81         }
  82
  83         private void EnsureWritable()
  84         {
  85             if (!this._member.CanWrite)
  86             {   // Property does not have a setter, or
  87                 // field is marked as read-only.
  88
  89                 throw new ComposablePartException(
  90                     CompositionErrorId.ReflectionModel_ImportNotWritable,
  91                     String.Format(CultureInfo.CurrentCulture,
  92                         Strings.ReflectionModel_ImportNotWritable,
  93                         this._member.GetDisplayName()),
  94                         Definition.ToElement());
  95             }
  96         }
  97
  98         private void SetCollectionMemberValue(object instance, IEnumerable values)
  99         {
 100             Assumes.NotNull(values);
 101
 102             ICollection<object> collection = null;
 103             Type itemType = CollectionServices.GetCollectionElementType(this.ImportType.ActualType);
 104             if (itemType != null)
 105             {
 106                 collection = GetNormalizedCollection(itemType, instance);
 107             }
 108
 109             EnsureCollectionIsWritable(collection);
 110             PopulateCollection(collection, values);
 111         }
 112
 113         private ICollection<object> GetNormalizedCollection(Type itemType, object instance)
 114         {
 115             Assumes.NotNull(itemType);
 116
 117             object collectionObject = null;
 118
 119             if (this._member.CanRead)
 120             {
 121                 try
 122                 {
 123                     collectionObject = this._member.GetValue(instance);
 124                 }
 125                 catch (TargetInvocationException exception)
 126                 {
 127                     throw new ComposablePartException(
 128                         CompositionErrorId.ReflectionModel_ImportCollectionGetThrewException,
 129                         String.Format(CultureInfo.CurrentCulture,
 130                             Strings.ReflectionModel_ImportCollectionGetThrewException,
 131                             this._member.GetDisplayName()),
 132                         this.Definition.ToElement(),
 133                         exception.InnerException);
 134                 }
 135             }
 136
 137             if (collectionObject == null)
 138             {
 139                 ConstructorInfo constructor = this.ImportType.ActualType.GetConstructor(Type.EmptyTypes);
 140
 141                 // If it contains a default public constructor create a new instance.
 142                 if (constructor != null)
 143                 {
 144                     try
 145                     {
 146                         collectionObject = constructor.SafeInvoke();
 147                     }
 148                     catch (TargetInvocationException exception)
 149                     {
 150                         throw new ComposablePartException(
 151                             CompositionErrorId.ReflectionModel_ImportCollectionConstructionThrewException,
 152                             String.Format(CultureInfo.CurrentCulture,
 153                                 Strings.ReflectionModel_ImportCollectionConstructionThrewException,
 154                                 this._member.GetDisplayName(),
 155                                 this.ImportType.ActualType.FullName),
 156                             this.Definition.ToElement(),
 157                             exception.InnerException);
 158                     }
 159
 160                     SetSingleMemberValue(instance, collectionObject);
 161                 }
 162             }
 163
 164             if (collectionObject == null)
 165             {
 166                 throw new ComposablePartException(
 167                     CompositionErrorId.ReflectionModel_ImportCollectionNull,
 168                     String.Format(CultureInfo.CurrentCulture,
 169                         Strings.ReflectionModel_ImportCollectionNull,
 170                         this._member.GetDisplayName()),
 171                     this.Definition.ToElement());
 172             }
 173
 174             return CollectionServices.GetCollectionWrapper(itemType, collectionObject);
 175         }
 176
 177         [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
 178         private void EnsureCollectionIsWritable(ICollection<object> collection)
 179         {
 180             bool isReadOnly = true;
 181
 182             try
 183             {
 184                 if (collection != null)
 185                 {
 186                     isReadOnly = collection.IsReadOnly;
 187                 }
 188             }
 189             catch (Exception exception)
 190             {
 191                 throw new ComposablePartException(
 192                     CompositionErrorId.ReflectionModel_ImportCollectionIsReadOnlyThrewException,
 193                     String.Format(CultureInfo.CurrentCulture,
 194                         Strings.ReflectionModel_ImportCollectionIsReadOnlyThrewException,
 195                         this._member.GetDisplayName(),
 196                         collection.GetType().FullName),
 197                     this.Definition.ToElement(),
 198                     exception);
 199             }
 200
 201             if (isReadOnly)
 202             {
 203                 throw new ComposablePartException(
 204                     CompositionErrorId.ReflectionModel_ImportCollectionNotWritable,
 205                     String.Format(CultureInfo.CurrentCulture,
 206                         Strings.ReflectionModel_ImportCollectionNotWritable,
 207                         this._member.GetDisplayName()),
 208                     this.Definition.ToElement());
 209             }
 210         }
 211
 212         [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
 213         private void PopulateCollection(ICollection<object> collection, IEnumerable values)
 214         {
 215             Assumes.NotNull(collection, values);
 216
 217             try
 218             {
 219                 collection.Clear();
 220             }
 221             catch (Exception exception)
 222             {
 223                 throw new ComposablePartException(
 224                     CompositionErrorId.ReflectionModel_ImportCollectionClearThrewException,
 225                     String.Format(CultureInfo.CurrentCulture,
 226                         Strings.ReflectionModel_ImportCollectionClearThrewException,
 227                         this._member.GetDisplayName(),
 228                         collection.GetType().FullName),
 229                     this.Definition.ToElement(),
 230                     exception);
 231             }
 232
 233             foreach (object value in values)
 234             {
 235                 try
 236                 {
 237                     collection.Add(value);
 238                 }
 239                 catch (Exception exception)
 240                 {
 241                     throw new ComposablePartException(
 242                         CompositionErrorId.ReflectionModel_ImportCollectionAddThrewException,
 243                         String.Format(CultureInfo.CurrentCulture,
 244                             Strings.ReflectionModel_ImportCollectionAddThrewException,
 245                             this._member.GetDisplayName(),
 246                             collection.GetType().FullName),
 247                         this.Definition.ToElement(),
 248                         exception);
 249                 }
 250             }
 251         }
 252     }
 253 }