class/System.ComponentModel.Composition/src/ComponentModel/System/ComponentModel/Composition/AttributedModelServices.cs

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.ComponentModel.Composition.Hosting;
   6 using System.ComponentModel.Composition.Primitives;
   7 using System.Runtime.Serialization;
   8 using System.ComponentModel.Composition.AttributedModel;
   9 using System.Reflection;
  10 using System.Linq;
  11 using Microsoft.Internal;
  12 using System.Collections.Generic;
  13 using System.Diagnostics.CodeAnalysis;
  14
  15 namespace System.ComponentModel.Composition
  16 {
  17     public static class AttributedModelServices
  18     {
  19         [SuppressMessage("Microsoft.Design", "CA1004")]
  20         public static TMetadataView GetMetadataView<TMetadataView>(IDictionary<string, object> metadata)
  21         {
  22             Requires.NotNull(metadata, "metadata");
  23
  24             return MetadataViewProvider.GetMetadataView<TMetadataView>(metadata);
  25         }
  26
  27         public static ComposablePart CreatePart(object attributedPart)
  28         {
  29             Requires.NotNull(attributedPart, "attributedPart");
  30             return AttributedModelDiscovery.CreatePart(attributedPart);
  31         }
  32
  33         public static ComposablePartDefinition CreatePartDefinition(Type type, ICompositionElement origin)
  34         {
  35             Requires.NotNull(type, "type");
  36             return AttributedModelServices.CreatePartDefinition(type, origin, false);
  37         }
  38
  39         public static ComposablePartDefinition CreatePartDefinition(Type type, ICompositionElement origin, bool ensureIsDiscoverable)
  40         {
  41             Requires.NotNull(type, "type");
  42             if (ensureIsDiscoverable)
  43             {
  44                 return AttributedModelDiscovery.CreatePartDefinitionIfDiscoverable(type, origin);
  45             }
  46             else
  47             {
  48                 return AttributedModelDiscovery.CreatePartDefinition(type, null, false, origin);
  49             }
  50         }
  51
  52         public static string GetTypeIdentity(Type type)
  53         {
  54             Requires.NotNull(type, "type");
  55
  56             return ContractNameServices.GetTypeIdentity(type);
  57         }
  58
  59         public static string GetTypeIdentity(MethodInfo method)
  60         {
  61             Requires.NotNull(method, "method");
  62
  63             return ContractNameServices.GetTypeIdentityFromMethod(method);
  64         }
  65
  66         public static string GetContractName(Type type)
  67         {
  68             return AttributedModelServices.GetTypeIdentity(type);
  69         }
  70
  71         public static ComposablePart AddExportedValue<T>(this CompositionBatch batch, T exportedValue)
  72         {
  73             Requires.NotNull(batch, "batch");
  74             string contractName = AttributedModelServices.GetContractName(typeof(T));
  75
  76             return batch.AddExportedValue<T>(contractName, exportedValue);
  77         }
  78
  79         public static void ComposeExportedValue<T>(this CompositionContainer container, T exportedValue)
  80         {
  81             Requires.NotNull(container, "container");
  82
  83             CompositionBatch batch = new CompositionBatch();
  84             batch.AddExportedValue<T>(exportedValue);
  85             container.Compose(batch);
  86         }
  87
  88         public static ComposablePart AddExportedValue<T>(this CompositionBatch batch, string contractName, T exportedValue)
  89         {
  90             Requires.NotNull(batch, "batch");
  91
  92             string typeIdentity = AttributedModelServices.GetTypeIdentity(typeof(T));
  93
  94             IDictionary<string, object> metadata = new Dictionary<string, object>();
  95             metadata.Add(CompositionConstants.ExportTypeIdentityMetadataName, typeIdentity);
  96
  97             return batch.AddExport(new Export(contractName, metadata, () => exportedValue));
  98         }
  99
 100         public static void ComposeExportedValue<T>(this CompositionContainer container, string contractName, T exportedValue)
 101         {
 102             Requires.NotNull(container, "container");
 103
 104             CompositionBatch batch = new CompositionBatch();
 105             batch.AddExportedValue<T>(contractName, exportedValue);
 106             container.Compose(batch);
 107         }
 108
 109         public static ComposablePart AddPart(this CompositionBatch batch, object attributedPart)
 110         {
 111             Requires.NotNull(batch, "batch");
 112             Requires.NotNull(attributedPart, "attributedPart");
 113
 114             ComposablePart part = AttributedModelServices.CreatePart(attributedPart);
 115
 116             batch.AddPart(part);
 117
 118             return part;
 119         }
 120
 121         public static void ComposeParts(this CompositionContainer container, params object[] attributedParts)
 122         {
 123             Requires.NotNull(container, "container");
 124             Requires.NotNullOrNullElements(attributedParts, "attributedParts");
 125
 126             CompositionBatch batch = new CompositionBatch(
 127                 attributedParts.Select(attributedPart => AttributedModelServices.CreatePart(attributedPart)).ToArray(),
 128                 Enumerable.Empty<ComposablePart>());
 129
 130             container.Compose(batch);
 131         }
 132
 133         /// <summary>
 134         ///     Satisfies the imports of the specified attributed object exactly once and they will not
 135         ///     ever be recomposed.
 136         /// </summary>
 137         /// <param name="part">
 138         ///     The attributed object to set the imports.
 139         /// </param>
 140         /// <exception cref="ArgumentNullException">
 141         ///     <paramref name="attributedPart"/> is <see langword="null"/>.
 142         /// </exception>
 143         /// <exception cref="CompositionException">
 144         ///     An error occurred during composition. <see cref="CompositionException.Errors"/> will
 145         ///     contain a collection of errors that occurred.
 146         /// </exception>
 147         /// <exception cref="ObjectDisposedException">
 148         ///     The <see cref="ICompositionService"/> has been disposed of.
 149         /// </exception>
 150         public static ComposablePart SatisfyImportsOnce(this ICompositionService compositionService, object attributedPart)
 151         {
 152             Requires.NotNull(compositionService, "compositionService");
 153             Requires.NotNull(attributedPart, "attributedPart");
 154
 155             ComposablePart part = AttributedModelServices.CreatePart(attributedPart);
 156             compositionService.SatisfyImportsOnce(part);
 157
 158             return part;
 159         }
 160     }
 161 }