class/System.ComponentModel.Composition/Tests/UnitTestFramework/System/ComponentModel/Composition/ReflectionModel/ReflectionModelServicesEx.cs

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.ComponentModel.Composition;
   6 using System.Linq;
   7 using System.Linq.Expressions;
   8 using System.UnitTesting;
   9 using Microsoft.VisualStudio.TestTools.UnitTesting;
  10 using System.Reflection;
  11 using System.ComponentModel.Composition.Hosting;
  12 using System.Collections.Generic;
  13 using System.ComponentModel.Composition.Primitives;
  14
  15 // NOTE : this is a helper class for exosig the EditorFactory functionality to tests until ExportFactory can be moved where it belongs
  16 namespace System.ComponentModel.Composition.ReflectionModel
  17 {
  18     public static class ReflectionModelServicesEx
  19     {
  20         public static ContractBasedImportDefinition CreateImportDefinition(
  21             Lazy<ParameterInfo> parameter,
  22             string contractName,
  23             string requiredTypeIdentity,
  24             IEnumerable<KeyValuePair<string, Type>> requiredMetadata,
  25             ImportCardinality cardinality,
  26             CreationPolicy requiredCreationPolicy,
  27             bool isExportFactory,
  28             ICompositionElement origin)
  29         {
  30             return ReflectionModelServices.CreateImportDefinition(parameter, contractName, requiredTypeIdentity, requiredMetadata, cardinality, requiredCreationPolicy, isExportFactory, origin);
  31         }
  32
  33         public static ContractBasedImportDefinition CreateImportDefinition(
  34                 LazyMemberInfo importingMember,
  35                 string contractName,
  36                 string requiredTypeIdentity,
  37                 IEnumerable<KeyValuePair<string, Type>> requiredMetadata,
  38                 ImportCardinality cardinality,
  39                 bool isRecomposable,
  40                 CreationPolicy requiredCreationPolicy,
  41                 bool isExportFactory,
  42                 ICompositionElement origin)
  43         {
  44             return ReflectionModelServices.CreateImportDefinition(importingMember, contractName, requiredTypeIdentity, requiredMetadata, cardinality, isRecomposable, requiredCreationPolicy, isExportFactory, origin);
  45         }
  46
  47         public static bool IsExportFactoryImportDefinition(ImportDefinition importDefinition)
  48         {
  49             return ReflectionModelServices.IsExportFactoryImportDefinition(importDefinition);
  50         }
  51
  52         public static ContractBasedImportDefinition CreateExportFactoryImportDefinition(ContractBasedImportDefinition productImportDefinition)
  53         {
  54             return new ExportFactoryImportDefinition(productImportDefinition);
  55         }
  56
  57         private class ExportFactoryImportDefinition : ContractBasedImportDefinition, IPartCreatorImportDefinition
  58         {
  59             private readonly ContractBasedImportDefinition _productImportDefinition;
  60
  61             public ExportFactoryImportDefinition(ContractBasedImportDefinition productImportDefinition)
  62                 : base(CompositionConstants.PartCreatorContractName, CompositionConstants.PartCreatorTypeIdentity, productImportDefinition.RequiredMetadata,
  63                     productImportDefinition.Cardinality, productImportDefinition.IsRecomposable, false, CreationPolicy.Any)
  64             {
  65                 _productImportDefinition = productImportDefinition;
  66             }
  67
  68             public ContractBasedImportDefinition ProductImportDefinition
  69             {
  70                 get
  71                 {
  72                     return _productImportDefinition;
  73                 }
  74             }
  75
  76             public override Expression<Func<ExportDefinition, bool>> Constraint
  77             {
  78                 get
  79                 {
  80                     return CreateExportFactoryConstraint(base.Constraint, this._productImportDefinition);
  81                 }
  82             }
  83
  84             public override bool IsConstraintSatisfiedBy(ExportDefinition exportDefinition)
  85             {
  86                 if (!base.IsConstraintSatisfiedBy(exportDefinition))
  87                 {
  88                     return false;
  89                 }
  90
  91                 return IsProductConstraintSatisfiedBy(this._productImportDefinition, exportDefinition);
  92             }
  93
  94             private static bool IsProductConstraintSatisfiedBy(ImportDefinition productImportDefinition, ExportDefinition exportDefinition)
  95             {
  96                 object productValue = null;
  97                 if (exportDefinition.Metadata.TryGetValue(CompositionConstants.ProductDefinitionMetadataName, out productValue))
  98                 {
  99                     ExportDefinition productDefinition = productValue as ExportDefinition;
 100
 101                     if (productDefinition != null)
 102                     {
 103                         return productImportDefinition.IsConstraintSatisfiedBy(productDefinition);
 104                     }
 105                 }
 106
 107                 return false;
 108             }
 109
 110             private static readonly PropertyInfo _exportDefinitionMetadataProperty = typeof(ExportDefinition).GetProperty("Metadata");
 111             private static readonly MethodInfo _metadataContainsKeyMethod = typeof(IDictionary<string, object>).GetMethod("ContainsKey");
 112             private static readonly MethodInfo _metadataItemMethod = typeof(IDictionary<string, object>).GetMethod("get_Item");
 113
 114             private static Expression<Func<ExportDefinition, bool>> CreateExportFactoryConstraint(Expression<Func<ExportDefinition, bool>> baseConstraint, ImportDefinition productImportDefinition)
 115             {
 116                 ParameterExpression exportDefinitionParameter = baseConstraint.Parameters[0];
 117
 118                 // exportDefinition.Metadata
 119                 Expression metadataExpression = Expression.Property(exportDefinitionParameter, _exportDefinitionMetadataProperty);
 120
 121                 // exportDefinition.Metadata.ContainsKey("ProductDefinition")
 122                 Expression containsProductExpression = Expression.Call(
 123                     metadataExpression,
 124                     _metadataContainsKeyMethod,
 125                     Expression.Constant(CompositionConstants.ProductDefinitionMetadataName));
 126
 127                 // exportDefinition.Metadata["ProductDefinition"]
 128                 Expression productExportDefinitionExpression = Expression.Call(
 129                         metadataExpression,
 130                         _metadataItemMethod,
 131                         Expression.Constant(CompositionConstants.ProductDefinitionMetadataName));
 132
 133                 // ProductImportDefinition.Contraint((ExportDefinition)exportDefinition.Metadata["ProductDefinition"])
 134                 Expression productMatchExpression =
 135                     Expression.Invoke(productImportDefinition.Constraint,
 136                         Expression.Convert(productExportDefinitionExpression, typeof(ExportDefinition)));
 137
 138                 // baseContraint(exportDefinition) &&
 139                 // exportDefinition.Metadata.ContainsKey("ProductDefinition") &&
 140                 // ProductImportDefinition.Contraint((ExportDefinition)exportDefinition.Metadata["ProductDefinition"])
 141                 Expression<Func<ExportDefinition, bool>> constraint =
 142                      Expression.Lambda<Func<ExportDefinition, bool>>(
 143                         Expression.AndAlso(
 144                             baseConstraint.Body,
 145                             Expression.AndAlso(
 146                                containsProductExpression,
 147                                productMatchExpression)),
 148                         exportDefinitionParameter);
 149
 150                 return constraint;
 151             }
 152         }
 153
 154     }
 155 }