class/System.ComponentModel.Composition/src/ComponentModel/System/ComponentModel/Composition/Hosting/ImportEngine.RecompositionManager.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;
   8 using System.Linq;
   9 using System.Runtime.CompilerServices;
  10 using Microsoft.Internal;
  11 using Microsoft.Internal.Collections;
  12
  13 namespace System.ComponentModel.Composition.Hosting
  14 {
  15     public partial class ImportEngine
  16     {
  17         /// <summary>
  18         ///     Used by the <see cref="ImportEngine"/> to effiecently store and retrieve the list of parts
  19         ///     that will be affected by changes to exports. This allows the <see cref="ImportEngine"/> to properly
  20         ///     block breaking changes and also recompose imports as appropriate.
  21         /// </summary>
  22         private class RecompositionManager
  23         {
  24             private WeakReferenceCollection<PartManager> _partsToIndex = new WeakReferenceCollection<PartManager>();
  25             private WeakReferenceCollection<PartManager> _partsToUnindex = new WeakReferenceCollection<PartManager>();
  26             private Dictionary<string, WeakReferenceCollection<PartManager>> _partManagerIndex = new Dictionary<string, WeakReferenceCollection<PartManager>>();
  27
  28             public void AddPartToIndex(PartManager partManager)
  29             {
  30                 this._partsToIndex.Add(partManager);
  31             }
  32
  33             public void AddPartToUnindex(PartManager partManager)
  34             {
  35                 this._partsToUnindex.Add(partManager);
  36             }
  37
  38             public IEnumerable<PartManager> GetAffectedParts(IEnumerable<string> changedContractNames)
  39             {
  40                 this.UpdateImportIndex();
  41
  42                 List<PartManager> parts = new List<PartManager>();
  43
  44                 parts.AddRange(GetPartsImporting(ImportDefinition.EmptyContractName));
  45
  46                 foreach (string contractName in changedContractNames)
  47                 {
  48                     parts.AddRange(GetPartsImporting(contractName));
  49                 }
  50
  51                 return parts;
  52             }
  53
  54             public static IEnumerable<ImportDefinition> GetAffectedImports(ComposablePart part, IEnumerable<ExportDefinition> changedExports)
  55             {
  56                 return part.ImportDefinitions.Where(import => IsAffectedImport(import, changedExports));
  57             }
  58
  59             private static bool IsAffectedImport(ImportDefinition import, IEnumerable<ExportDefinition> changedExports)
  60             {
  61                 // This could be more efficient still if the export definitions were indexed by contract name,
  62                 // only worth revisiting if we need to squeeze more performance out of recomposition
  63                 foreach (var export in changedExports)
  64                 {
  65                     if (import.IsConstraintSatisfiedBy(export))
  66                     {
  67                         return true;
  68                     }
  69                 }
  70
  71                 return false;
  72             }
  73
  74             public IEnumerable<PartManager> GetPartsImporting(string contractName)
  75             {
  76                 WeakReferenceCollection<PartManager> partManagerList;
  77                 if (!this._partManagerIndex.TryGetValue(contractName, out partManagerList))
  78                 {
  79                     return Enumerable.Empty<PartManager>();
  80                 }
  81
  82                 return partManagerList.AliveItemsToList();
  83             }
  84
  85             private void AddIndexEntries(PartManager partManager)
  86             {
  87                 foreach (string contractName in partManager.GetImportedContractNames())
  88                 {
  89                     WeakReferenceCollection<PartManager> indexEntries;
  90                     if (!this._partManagerIndex.TryGetValue(contractName, out indexEntries))
  91                     {
  92                         indexEntries = new WeakReferenceCollection<PartManager>();
  93                         this._partManagerIndex.Add(contractName, indexEntries);
  94                     }
  95
  96                     if (!indexEntries.Contains(partManager))
  97                     {
  98                         indexEntries.Add(partManager);
  99                     }
 100                 }
 101             }
 102
 103             private void RemoveIndexEntries(PartManager partManager)
 104             {
 105                 foreach (string contractName in partManager.GetImportedContractNames())
 106                 {
 107                     WeakReferenceCollection<PartManager> indexEntries;
 108                     if (this._partManagerIndex.TryGetValue(contractName, out indexEntries))
 109                     {
 110                         indexEntries.Remove(partManager);
 111                         var aliveItems = indexEntries.AliveItemsToList();
 112
 113                         if (aliveItems.Count == 0)
 114                         {
 115                             this._partManagerIndex.Remove(contractName);
 116                         }
 117                     }
 118                 }
 119             }
 120
 121             private void UpdateImportIndex()
 122             {
 123                 var partsToIndex = this._partsToIndex.AliveItemsToList();
 124                 this._partsToIndex.Clear();
 125
 126                 var partsToUnindex = this._partsToUnindex.AliveItemsToList();
 127                 this._partsToUnindex.Clear();
 128
 129                 if (partsToIndex.Count == 0 && partsToUnindex.Count == 0)
 130                 {
 131                     return;
 132                 }
 133
 134                 foreach (var partManager in partsToIndex)
 135                 {
 136                     var index = partsToUnindex.IndexOf(partManager);
 137
 138                     // If the same part is being added and removed we can ignore both
 139                     if (index >= 0)
 140                     {
 141                         partsToUnindex[index] = null;
 142                     }
 143                     else
 144                     {
 145                         AddIndexEntries(partManager);
 146                     }
 147                 }
 148
 149                 foreach (var partManager in partsToUnindex)
 150                 {
 151                     if (partManager != null)
 152                     {
 153                         RemoveIndexEntries(partManager);
 154                     }
 155                 }
 156             }
 157         }
 158     }
 159 }