class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/DynamicMetadata.cs

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.Collections.Generic;
   6 using System.ComponentModel;
   7 using System.ComponentModel.Composition;
   8 using System.Linq;
   9 using System.Reflection;
  10 using Microsoft.VisualStudio.TestTools.UnitTesting;
  11 using System.ComponentModel.Composition.Hosting;
  12
  13 namespace System.ComponentModel.Composition
  14 {
  15     [TestClass]
  16     public class DynamicMetadata
  17     {
  18         [TestMethod]
  19         public void SimpleAttachment()
  20         {
  21             MetadataStore.Container = new CompositionContainer();
  22             DynamicMetadataTestClass val = DynamicMetadataTestClass.Get("42");
  23
  24             var notYetAttached = TypeDescriptor.GetConverter(val);
  25             Assert.IsFalse(notYetAttached.CanConvertFrom(typeof(string)), "The default type converter for DynamicMetadataTestClass shouldn't support round tripping");
  26
  27             MetadataStore.AddAttribute(
  28                 typeof(DynamicMetadataTestClass),
  29                 ( type, attributes) =>
  30                     Enumerable.Concat(
  31                         attributes,
  32                         new Attribute[] { new TypeConverterAttribute(typeof(DynamicMetadataTestClassConverter)) }
  33                     )
  34             );
  35             var attached = TypeDescriptor.GetConverter(val);
  36             Assert.IsTrue(attached.CanConvertFrom(typeof(string)), "The new type converter for DynamicMetadataTestClass should support round tripping");
  37         }
  38
  39         [TestMethod]
  40         public void LocalContainer()
  41         {
  42             var container1 = new CompositionContainer();
  43             TypeDescriptorServices dat = new TypeDescriptorServices();
  44             CompositionBatch batch = new CompositionBatch();
  45             batch.AddPart(dat);
  46             container1.Compose(batch);
  47             MetadataStore.AddAttribute(
  48                 typeof(DynamicMetadataTestClass),
  49                 ( type, attributes) =>
  50                     Enumerable.Concat(
  51                         attributes,
  52                         new Attribute[] { new TypeConverterAttribute(typeof(DynamicMetadataTestClassConverter)) }
  53                     ),
  54                 container1
  55             );
  56             DynamicMetadataTestClass val = DynamicMetadataTestClass.Get("42");
  57
  58             var notYetAttached = TypeDescriptor.GetConverter(val.GetType());
  59             Assert.IsFalse(notYetAttached.CanConvertFrom(typeof(string)), "The default type converter for DynamicMetadataTestClass shouldn't support round tripping");
  60
  61             var attached = dat.GetConverter(val.GetType());
  62             Assert.IsTrue(attached.CanConvertFrom(typeof(string)), "The new type converter for DynamicMetadataTestClass should support round tripping");
  63         }
  64
  65         [TestMethod]
  66         public void DualContainers()
  67         {
  68             var container1 = new CompositionContainer();
  69             TypeDescriptorServices dat1 = new TypeDescriptorServices();
  70             CompositionBatch batch = new CompositionBatch();
  71             batch.AddPart(dat1);
  72             container1.Compose(batch);
  73             MetadataStore.AddAttribute(
  74                 typeof(DynamicMetadataTestClass),
  75                 ( type, attributes) =>
  76                     Enumerable.Concat(
  77                         attributes,
  78                         new Attribute[] { new TypeConverterAttribute(typeof(DynamicMetadataTestClassConverter)) }
  79                     ),
  80                 container1
  81             );
  82
  83
  84             var container2 = new CompositionContainer();
  85             CompositionBatch batch2 = new CompositionBatch();
  86             TypeDescriptorServices dat2 = new TypeDescriptorServices();
  87             batch2.AddPart(dat2);
  88             container2.Compose(batch2);
  89
  90             DynamicMetadataTestClass val = DynamicMetadataTestClass.Get("42");
  91
  92             var attached1 = dat1.GetConverter(val.GetType());
  93             Assert.IsTrue(attached1.CanConvertFrom(typeof(string)), "The new type converter for DynamicMetadataTestClass should support round tripping");
  94
  95             var attached2 = dat2.GetConverter(val.GetType());
  96             Assert.IsFalse(attached2.CanConvertFrom(typeof(string)), "The default type converter for DynamicMetadataTestClass shouldn't support round tripping");
  97         }
  98
  99         [TestCleanup]
 100         public void ResetContainer()
 101         {
 102             MetadataStore.Container = null;
 103         }
 104     }
 105
 106
 107     [Export]
 108     public class TypeDescriptorServices
 109     {
 110         Dictionary<Type, TypeDescriptionProvider> providers = new Dictionary<Type, TypeDescriptionProvider>();
 111
 112         internal Dictionary<Type, TypeDescriptionProvider> Providers
 113         {
 114             get { return providers; }
 115             set { providers = value; }
 116         }
 117
 118         public ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
 119         {
 120             if (Providers.ContainsKey(objectType))
 121             {
 122                 return Providers[objectType].GetTypeDescriptor(objectType);
 123             }
 124             else
 125             {
 126                 return null;
 127             }
 128         }
 129         public void AddProvider(TypeDescriptionProvider provider, Type type)
 130         {
 131             Providers[type] = provider;
 132         }
 133         public TypeConverter GetConverter(Type type)
 134         {
 135             var ictd = GetTypeDescriptor(type, null);
 136             if (ictd != null)
 137             {
 138                 return ictd.GetConverter();
 139             }
 140             else
 141             {
 142                 return TypeDescriptor.GetConverter(type);
 143             }
 144         }
 145     }
 146
 147     public static class MetadataStore
 148     {
 149         public static CompositionContainer Container { get; set; }
 150         static Dictionary<Type, TypeDescriptionProvider> registeredRedirect = new Dictionary<Type, TypeDescriptionProvider>();
 151
 152         public static void AddAttribute(Type target, Func<MemberInfo, IEnumerable<Attribute>, IEnumerable<Attribute>> provider)
 153         {
 154             AddAttribute(target, provider, MetadataStore.Container);
 155         }
 156         public static void AddAttribute(Type target, Func<MemberInfo, IEnumerable<Attribute>, IEnumerable<Attribute>> provider, CompositionContainer container)
 157         {
 158             ContainerUnawareProviderRedirect.GetRedirect(container)[target] = new MetadataStoreProvider(target, provider);
 159             RegisterTypeDescriptorInterop(target);
 160         }
 161         private static void RegisterTypeDescriptorInterop(Type target)
 162         {
 163             if (!registeredRedirect.ContainsKey(target))
 164             {
 165                 var r = new ContainerUnawareProviderRedirect(target);
 166                 TypeDescriptor.AddProvider(r, target);
 167                 registeredRedirect[target] = r;
 168             }
 169             else
 170             {
 171                 // force a uncache of the information from TypeDescriptor
 172                 //
 173                 TypeDescriptor.RemoveProvider(registeredRedirect[target], target);
 174                 TypeDescriptor.AddProvider(registeredRedirect[target], target);
 175             }
 176         }
 177         public static TypeDescriptorServices GetTypeDescriptorServicesForContainer(CompositionContainer container)
 178         {
 179             if (container != null)
 180             {
 181                 var result = container.GetExportedValueOrDefault<TypeDescriptorServices>();
 182                 if (result == null)
 183                 {
 184                     var v = new TypeDescriptorServices();
 185                     CompositionBatch batch = new CompositionBatch();
 186                     batch.AddPart(v);
 187                     container.Compose(batch);
 188                     return v;
 189                 }
 190
 191                 return result;
 192             }
 193             return null;
 194         }
 195
 196         private class ContainerUnawareProviderRedirect : TypeDescriptionProvider
 197         {
 198             public ContainerUnawareProviderRedirect(Type forType)
 199                 : base(TypeDescriptor.GetProvider(forType))
 200             {
 201             }
 202             public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
 203             {
 204                 var datd = GetTypeDescriptorServicesForContainer(MetadataStore.Container);
 205                 if (datd == null || !datd.Providers.ContainsKey(objectType))
 206                 {
 207                     return base.GetTypeDescriptor(objectType, instance);
 208                 }
 209                 else
 210                 {
 211                     return datd.GetTypeDescriptor(objectType, instance);
 212                 }
 213             }
 214
 215             internal static Dictionary<Type, TypeDescriptionProvider> GetRedirect(CompositionContainer container)
 216             {
 217                 TypeDescriptorServices v = GetTypeDescriptorServicesForContainer(container);
 218                 return v != null ? v.Providers : null;
 219             }
 220         }
 221
 222         private class MetadataStoreProvider : TypeDescriptionProvider
 223         {
 224             Func<MemberInfo, IEnumerable<Attribute>, IEnumerable<Attribute>> provider;
 225             public MetadataStoreProvider(Type forType, Func<MemberInfo, IEnumerable<Attribute>, IEnumerable<Attribute>> provider)
 226                 : base(TypeDescriptor.GetProvider(forType))
 227             {
 228                 this.provider = provider;
 229             }
 230             public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
 231             {
 232                 ICustomTypeDescriptor descriptor = base.GetTypeDescriptor(objectType, instance);
 233                 descriptor = new MetadataStoreTypeDescriptor(objectType, descriptor, provider);
 234                 return descriptor;
 235             }
 236
 237         }
 238
 239         private class MetadataStoreTypeDescriptor : CustomTypeDescriptor
 240         {
 241             Type targetType;
 242             Func<MemberInfo, IEnumerable<Attribute>, IEnumerable<Attribute>> provider;
 243             public MetadataStoreTypeDescriptor(Type targetType, ICustomTypeDescriptor parent, Func<MemberInfo, IEnumerable<Attribute>, IEnumerable<Attribute>> provider)
 244                 : base(parent)
 245             {
 246                 this.targetType = targetType;
 247                 this.provider = provider;
 248             }
 249             public override TypeConverter GetConverter()
 250             {
 251                 TypeConverterAttribute attribute = (TypeConverterAttribute)GetAttributes()[typeof(TypeConverterAttribute)];
 252                 if (attribute != null)
 253                 {
 254                     Type c = this.GetTypeFromName(attribute.ConverterTypeName);
 255                     if ((c != null) && typeof(TypeConverter).IsAssignableFrom(c))
 256                     {
 257                         return (TypeConverter)Activator.CreateInstance(c);
 258                     }
 259                 }
 260                 return base.GetConverter();
 261             }
 262             private Type GetTypeFromName(string typeName)
 263             {
 264                 if ((typeName == null) || (typeName.Length == 0))
 265                 {
 266                     return null;
 267                 }
 268                 int length = typeName.IndexOf(',');
 269                 Type type = null;
 270                 if (length == -1)
 271                 {
 272                     type = targetType.Assembly.GetType(typeName);
 273                 }
 274                 if (type == null)
 275                 {
 276                     type = Type.GetType(typeName);
 277                 }
 278                 if ((type == null) && (length != -1))
 279                 {
 280                     type = Type.GetType(typeName.Substring(0, length));
 281                 }
 282                 return type;
 283             }
 284             public override AttributeCollection GetAttributes()
 285             {
 286                 var n = new List<Attribute>();
 287                 foreach (var attr in provider(targetType, base.GetAttributes().OfType<Attribute>()))
 288                 {
 289                     n.Add(attr);
 290                 }
 291                 return new AttributeCollection(n.ToArray());
 292             }
 293         }
 294     }
 295
 296     public class DynamicMetadataTestClass
 297     {
 298         int i;
 299
 300         private DynamicMetadataTestClass(int i)
 301         {
 302             this.i = i;
 303         }
 304
 305         public override string ToString()
 306         {
 307             return i.ToString();
 308         }
 309
 310         public static DynamicMetadataTestClass Get(string s)
 311         {
 312             return new DynamicMetadataTestClass(Int32.Parse(s));
 313         }
 314     }
 315
 316     public class DynamicMetadataTestClassConverter : TypeConverter
 317     {
 318         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
 319         {
 320             return sourceType == typeof(string);
 321         }
 322         public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
 323         {
 324             return ((DynamicMetadataTestClass)value).ToString();
 325         }
 326         public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
 327         {
 328             return DynamicMetadataTestClass.Get((string)value);
 329         }
 330         public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
 331         {
 332             return destinationType == typeof(string);
 333         }
 334     }
 335 }