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

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.Collections.Generic;
   6 using System.ComponentModel.Composition.Primitives;
   7 using System.Diagnostics.CodeAnalysis;
   8 using System.Linq;
   9 using System.Reflection;
  10 using System.Threading;
  11 using Microsoft.Internal;
  12
  13 namespace System.ComponentModel.Composition.ReflectionModel
  14 {
  15     internal class ReflectionComposablePartDefinition : ComposablePartDefinition, ICompositionElement
  16     {
  17         private readonly IReflectionPartCreationInfo _creationInfo;
  18
  19         private volatile IEnumerable<ImportDefinition> _imports;
  20         private volatile IEnumerable<ExportDefinition> _exports;
  21         private volatile IDictionary<string, object> _metadata;
  22         private volatile ConstructorInfo _constructor;
  23         private object _lock = new object();
  24
  25         public ReflectionComposablePartDefinition(IReflectionPartCreationInfo creationInfo)
  26         {
  27             Assumes.NotNull(creationInfo);
  28             this._creationInfo = creationInfo;
  29         }
  30
  31         public Type GetPartType()
  32         {
  33             return this._creationInfo.GetPartType();
  34         }
  35
  36         public Lazy<Type> GetLazyPartType()
  37         {
  38             return this._creationInfo.GetLazyPartType();
  39         }
  40
  41         public ConstructorInfo GetConstructor()
  42         {
  43             if (this._constructor == null)
  44             {
  45                 ConstructorInfo constructor = this._creationInfo.GetConstructor();
  46                 lock (this._lock)
  47                 {
  48                     if (this._constructor == null)
  49                     {
  50                         this._constructor = constructor;
  51                     }
  52                 }
  53             }
  54
  55             return this._constructor;
  56         }
  57
  58         public override IEnumerable<ExportDefinition> ExportDefinitions
  59         {
  60             get
  61             {
  62                 if (this._exports == null)
  63                 {
  64                     ExportDefinition[] exports = this._creationInfo.GetExports().ToArray();
  65                     lock (this._lock)
  66                     {
  67                         if (this._exports == null)
  68                         {
  69                             this._exports = exports;
  70                         }
  71                     }
  72                 }
  73                 return this._exports;
  74             }
  75         }
  76
  77         public override IEnumerable<ImportDefinition> ImportDefinitions
  78         {
  79             get
  80             {
  81                 if (this._imports == null)
  82                 {
  83                     ImportDefinition[] imports = this._creationInfo.GetImports().ToArray();
  84                     lock (this._lock)
  85                     {
  86                         if (this._imports == null)
  87                         {
  88                             this._imports = imports;
  89                         }
  90                     }
  91                 }
  92                 return this._imports;
  93             }
  94         }
  95
  96         public override IDictionary<string, object> Metadata
  97         {
  98             get
  99             {
 100                 if (this._metadata == null)
 101                 {
 102                     IDictionary<string, object> metadata = this._creationInfo.GetMetadata().AsReadOnly();
 103                     lock (this._lock)
 104                     {
 105                         if (this._metadata == null)
 106                         {
 107                             this._metadata = metadata;
 108                         }
 109                     }
 110                 }
 111                 return this._metadata;
 112             }
 113         }
 114
 115         internal bool IsDisposalRequired
 116         {
 117             get
 118             {
 119                 return this._creationInfo.IsDisposalRequired;
 120             }
 121         }
 122
 123         [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
 124         public override ComposablePart CreatePart()
 125         {
 126             if (this.IsDisposalRequired)
 127             {
 128                 return new DisposableReflectionComposablePart(this);
 129             }
 130             else
 131             {
 132                 return new ReflectionComposablePart(this);
 133             }
 134         }
 135
 136         string ICompositionElement.DisplayName
 137         {
 138             get { return this._creationInfo.DisplayName; }
 139         }
 140
 141         ICompositionElement ICompositionElement.Origin
 142         {
 143             get { return this._creationInfo.Origin; }
 144         }
 145
 146         public override string ToString()
 147         {
 148             return this._creationInfo.DisplayName;
 149         }
 150     }
 151 }