// ----------------------------------------------------------------------- // Copyright (c) Microsoft Corporation. All rights reserved. // ----------------------------------------------------------------------- using System; using System.Collections.Generic; using System.ComponentModel.Composition; using Microsoft.VisualStudio.TestTools.UnitTesting; using System.ComponentModel.Composition.Primitives; namespace System.ComponentModel.Composition { public interface IGetString { string GetString(); } public class PublicComponentWithPublicExports { public const string PublicFieldExpectedValue = "PublicField"; [Export("PublicField")] public string PublicField = PublicFieldExpectedValue; public const string PublicPropertyExpectedValue = "PublicProperty"; [Export("PublicProperty")] public string PublicProperty { get { return PublicPropertyExpectedValue; } } public const string PublicMethodExpectedValue = "PublicMethod"; [Export("PublicDelegate")] public string PublicMethod() { return PublicMethodExpectedValue; } public const string PublicNestedClassExpectedValue = "PublicNestedClass"; [Export("PublicIGetString", typeof(IGetString))] public class PublicNestedClass : IGetString { public string GetString() { return PublicNestedClassExpectedValue; } } } [Export] public class PublicImportsExpectingPublicExports { [Import("PublicField")] public string PublicImportPublicField { get; set; } [Import("PublicProperty")] public string PublicImportPublicProperty { get; set; } [Import("PublicDelegate")] public Func PublicImportPublicMethod { get; set; } [Import("PublicIGetString")] public IGetString PublicImportPublicNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithPublicExports.PublicFieldExpectedValue, PublicImportPublicField, "PublicImportPublicField should be bound."); Assert.AreEqual(PublicComponentWithPublicExports.PublicPropertyExpectedValue, PublicImportPublicProperty, "PublicImportPublicProperty should be bound."); Assert.AreEqual(PublicComponentWithPublicExports.PublicMethodExpectedValue, PublicImportPublicMethod(), "PublicImportPublicMethod should be bound."); Assert.AreEqual(PublicComponentWithPublicExports.PublicNestedClassExpectedValue, PublicImportPublicNestedClass.GetString(), "PublicImportPublicNestedClass should be bound and have a method GetString."); } } [Export] internal class InternalImportsExpectingPublicExports { [Import("PublicField")] internal string InternalImportPublicField { get; set; } [Import("PublicProperty")] internal string InternalImportPublicProperty { get; set; } [Import("PublicDelegate")] internal Func InternalImportPublicMethod { get; set; } [Import("PublicIGetString")] internal IGetString InternalImportPublicNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithPublicExports.PublicFieldExpectedValue, InternalImportPublicField, "InternalImportPublicField should be bound."); Assert.AreEqual(PublicComponentWithPublicExports.PublicPropertyExpectedValue, InternalImportPublicProperty, "InternalImportPublicProperty should be bound."); Assert.AreEqual(PublicComponentWithPublicExports.PublicMethodExpectedValue, InternalImportPublicMethod(), "InternalImportPublicMethod should be bound."); Assert.AreEqual(PublicComponentWithPublicExports.PublicNestedClassExpectedValue, InternalImportPublicNestedClass.GetString(), "InternalImportPublicNestedClass should be bound and have a method GetString."); } } public class PublicComponentWithInternalExports { public const string InternalFieldExpectedValue = "InternalField"; [Export("InternalField")] internal string InternalField = InternalFieldExpectedValue; public const string InternalPropertyExpectedValue = "InternalProperty"; [Export("InternalProperty")] internal string InternalProperty { get { return InternalPropertyExpectedValue; } } public const string InternalMethodExpectedValue = "InternalMethod"; [Export("InternalDelegate")] internal string InternalMethod() { return InternalMethodExpectedValue; } public const string InternalNestedClassExpectedValue = "InternalNestedClass"; [Export("InternalIGetString", typeof(IGetString))] internal class InternalNestedClass : IGetString { public string GetString() { return InternalNestedClassExpectedValue; } } } [Export] public class PublicImportsExpectingInternalExports { [Import("InternalField")] public string PublicImportInternalField { get; set; } [Import("InternalProperty")] public string PublicImportInternalProperty { get; set; } [Import("InternalDelegate")] public Func PublicImportInternalMethod { get; set; } [Import("InternalIGetString", typeof(IGetString))] public IGetString PublicImportInternalNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithInternalExports.InternalFieldExpectedValue, PublicImportInternalField, "PublicImportInternalField should be bound."); Assert.AreEqual(PublicComponentWithInternalExports.InternalPropertyExpectedValue, PublicImportInternalProperty, "PublicImportInternalProperty should be bound."); Assert.AreEqual(PublicComponentWithInternalExports.InternalMethodExpectedValue, PublicImportInternalMethod(), "PublicImportInternalMethod should be bound."); Assert.AreEqual(PublicComponentWithInternalExports.InternalNestedClassExpectedValue, PublicImportInternalNestedClass.GetString(), "PublicImportInternalNestedClass should be bound and have a method GetString."); } } [Export] internal class InternalImportsExpectingInternalExports { [Import("InternalField")] internal string InternalImportInternalField { get; set; } [Import("InternalProperty")] internal string InternalImportInternalProperty { get; set; } [Import("InternalDelegate")] internal Func InternalImportInternalMethod { get; set; } [Import("InternalIGetString")] internal IGetString InternalImportInternalNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithInternalExports.InternalFieldExpectedValue, InternalImportInternalField, "InternalImportInternalField should be bound."); Assert.AreEqual(PublicComponentWithInternalExports.InternalPropertyExpectedValue, InternalImportInternalProperty, "InternalImportInternalProperty should be bound."); Assert.AreEqual(PublicComponentWithInternalExports.InternalMethodExpectedValue, InternalImportInternalMethod(), "InternalImportInternalMethod should be bound."); Assert.AreEqual(PublicComponentWithInternalExports.InternalNestedClassExpectedValue, InternalImportInternalNestedClass.GetString(), "InternalImportInternalNestedClass should be bound and have a method GetString."); } } public class PublicComponentWithProtectedExports { public const string ProtectedFieldExpectedValue = "ProtectedField"; [Export("ProtectedField")] protected string ProtectedField = ProtectedFieldExpectedValue; public const string ProtectedPropertyExpectedValue = "ProtectedProperty"; [Export("ProtectedProperty")] protected string ProtectedProperty { get { return ProtectedPropertyExpectedValue; } } public const string ProtectedMethodExpectedValue = "ProtectedMethod"; [Export("ProtectedDelegate")] protected string ProtectedMethod() { return ProtectedMethodExpectedValue; } public const string ProtectedNestedClassExpectedValue = "ProtectedNestedClass"; [Export("ProtectedIGetString", typeof(IGetString))] protected class ProtectedNestedClass : IGetString { public string GetString() { return ProtectedNestedClassExpectedValue; } } } [Export] public class PublicImportsExpectingProtectedExports { [Import("ProtectedField")] public string PublicImportProtectedField { get; set; } [Import("ProtectedProperty")] public string PublicImportProtectedProperty { get; set; } [Import("ProtectedDelegate")] public Func PublicImportProtectedMethod { get; set; } [Import("ProtectedIGetString")] public IGetString PublicImportProtectedNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithProtectedExports.ProtectedFieldExpectedValue, PublicImportProtectedField, "PublicImportProtectedField should be bound."); Assert.AreEqual(PublicComponentWithProtectedExports.ProtectedPropertyExpectedValue, PublicImportProtectedProperty, "PublicImportProtectedProperty should be bound."); Assert.AreEqual(PublicComponentWithProtectedExports.ProtectedMethodExpectedValue, PublicImportProtectedMethod(), "PublicImportProtectedMethod should be bound."); Assert.AreEqual(PublicComponentWithProtectedExports.ProtectedNestedClassExpectedValue, PublicImportProtectedNestedClass.GetString(), "PublicImportProtectedNestedClass should be bound and have a method GetString."); } } [Export] internal class InternalImportsExpectingProtectedExports { [Import("ProtectedField")] internal string InternalImportProtectedField { get; set; } [Import("ProtectedProperty")] internal string InternalImportProtectedProperty { get; set; } [Import("ProtectedDelegate")] internal Func InternalImportProtectedMethod { get; set; } [Import("ProtectedIGetString")] internal IGetString InternalImportProtectedNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithProtectedExports.ProtectedFieldExpectedValue, InternalImportProtectedField, "InternalImportProtectedField should be bound."); Assert.AreEqual(PublicComponentWithProtectedExports.ProtectedPropertyExpectedValue, InternalImportProtectedProperty, "InternalImportProtectedProperty should be bound."); Assert.AreEqual(PublicComponentWithProtectedExports.ProtectedMethodExpectedValue, InternalImportProtectedMethod(), "InternalImportProtectedMethod should be bound."); Assert.AreEqual(PublicComponentWithProtectedExports.ProtectedNestedClassExpectedValue, InternalImportProtectedNestedClass.GetString(), "InternalImportProtectedNestedClass should be bound and have a method GetString."); } } public class PublicComponentWithProtectedInternalExports { public const string ProtectedInternalFieldExpectedValue = "ProtectedInternalField"; [Export("ProtectedInternalField")] protected internal string ProtectedInternalField = ProtectedInternalFieldExpectedValue; public const string ProtectedInternalPropertyExpectedValue = "ProtectedInternalProperty"; [Export("ProtectedInternalProperty")] protected internal string ProtectedInternalProperty { get { return ProtectedInternalPropertyExpectedValue; } } public const string ProtectedInternalMethodExpectedValue = "ProtectedInternalMethod"; [Export("ProtectedInternalDelegate")] protected internal string ProtectedInternalMethod() { return ProtectedInternalMethodExpectedValue; } public const string ProtectedInternalNestedClassExpectedValue = "ProtectedInternalNestedClass"; [Export("ProtectedInternalIGetString", typeof(IGetString))] protected internal class ProtectedInternalNestedClass : IGetString { public string GetString() { return ProtectedInternalNestedClassExpectedValue; } } } [Export] public class PublicImportsExpectingProtectedInternalExports { [Import("ProtectedInternalField")] public string PublicImportProtectedInternalField { get; set; } [Import("ProtectedInternalProperty")] public string PublicImportProtectedInternalProperty { get; set; } [Import("ProtectedInternalDelegate")] public Func PublicImportProtectedInternalMethod { get; set; } [Import("ProtectedInternalIGetString")] public IGetString PublicImportProtectedInternalNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithProtectedInternalExports.ProtectedInternalFieldExpectedValue, PublicImportProtectedInternalField, "PublicImportProtectedInternalField should be bound."); Assert.AreEqual(PublicComponentWithProtectedInternalExports.ProtectedInternalPropertyExpectedValue, PublicImportProtectedInternalProperty, "PublicImportProtectedInternalProperty should be bound."); Assert.AreEqual(PublicComponentWithProtectedInternalExports.ProtectedInternalMethodExpectedValue, PublicImportProtectedInternalMethod(), "PublicImportProtectedInternalMethod should be bound."); Assert.AreEqual(PublicComponentWithProtectedInternalExports.ProtectedInternalNestedClassExpectedValue, PublicImportProtectedInternalNestedClass.GetString(), "PublicImportProtectedInternalNestedClass should be bound and have a method GetString."); } } [Export] internal class InternalImportsExpectingProtectedInternalExports { [Import("ProtectedInternalField")] internal string InternalImportProtectedInternalField { get; set; } [Import("ProtectedInternalProperty")] internal string InternalImportProtectedInternalProperty { get; set; } [Import("ProtectedInternalDelegate")] internal Func InternalImportProtectedInternalMethod { get; set; } [Import("ProtectedInternalIGetString")] internal IGetString InternalImportProtectedInternalNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithProtectedInternalExports.ProtectedInternalFieldExpectedValue, InternalImportProtectedInternalField, "InternalImportProtectedInternalField should be bound."); Assert.AreEqual(PublicComponentWithProtectedInternalExports.ProtectedInternalPropertyExpectedValue, InternalImportProtectedInternalProperty, "InternalImportProtectedInternalProperty should be bound."); Assert.AreEqual(PublicComponentWithProtectedInternalExports.ProtectedInternalMethodExpectedValue, InternalImportProtectedInternalMethod(), "InternalImportProtectedInternalMethod should be bound."); Assert.AreEqual(PublicComponentWithProtectedInternalExports.ProtectedInternalNestedClassExpectedValue, InternalImportProtectedInternalNestedClass.GetString(), "InternalImportProtectedInternalNestedClass should be bound and have a method GetString."); } } public class PublicComponentWithPrivateExports { public const string PrivateFieldExpectedValue = "PrivateField"; [Export("PrivateField")] private string PrivateField = PrivateFieldExpectedValue; public const string PrivatePropertyExpectedValue = "PrivateProperty"; [Export("PrivateProperty")] private string PrivateProperty { get { return PrivatePropertyExpectedValue; } } public const string PrivateMethodExpectedValue = "PrivateMethod"; [Export("PrivateDelegate")] private string PrivateMethod() { return PrivateMethodExpectedValue; } public const string PrivateNestedClassExpectedValue = "PrivateNestedClass"; [Export("PrivateIGetString", typeof(IGetString))] private class PrivateNestedClass : IGetString { public string GetString() { return PrivateNestedClassExpectedValue; } } } [Export] public class PublicImportsExpectingPrivateExports { [Import("PrivateField")] public string PublicImportPrivateField { get; set; } [Import("PrivateProperty")] public string PublicImportPrivateProperty { get; set; } [Import("PrivateDelegate")] public Func PublicImportPrivateMethod { get; set; } [Import("PrivateIGetString")] public IGetString PublicImportPrivateNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithPrivateExports.PrivateFieldExpectedValue, PublicImportPrivateField, "PublicImportPrivateField should be bound."); Assert.AreEqual(PublicComponentWithPrivateExports.PrivatePropertyExpectedValue, PublicImportPrivateProperty, "PublicImportPrivateProperty should be bound."); Assert.AreEqual(PublicComponentWithPrivateExports.PrivateMethodExpectedValue, PublicImportPrivateMethod(), "PublicImportPrivateMethod should be bound."); Assert.AreEqual(PublicComponentWithPrivateExports.PrivateNestedClassExpectedValue, PublicImportPrivateNestedClass.GetString(), "PublicImportPrivateNestedClass should be bound and have a method GetString."); } } [Export] internal class InternalImportsExpectingPrivateExports { [Import("PrivateField")] internal string InternalImportPrivateField { get; set; } [Import("PrivateProperty")] internal string InternalImportPrivateProperty { get; set; } [Import("PrivateDelegate")] internal Func InternalImportPrivateMethod { get; set; } [Import("PrivateIGetString")] internal IGetString InternalImportPrivateNestedClass { get; set; } public void VerifyIsBound() { Assert.AreEqual(PublicComponentWithPrivateExports.PrivateFieldExpectedValue, InternalImportPrivateField, "InternalImportPrivateField should be bound."); Assert.AreEqual(PublicComponentWithPrivateExports.PrivatePropertyExpectedValue, InternalImportPrivateProperty, "InternalImportPrivateProperty should be bound."); Assert.AreEqual(PublicComponentWithPrivateExports.PrivateMethodExpectedValue, InternalImportPrivateMethod(), "InternalImportPrivateMethod should be bound."); Assert.AreEqual(PublicComponentWithPrivateExports.PrivateNestedClassExpectedValue, InternalImportPrivateNestedClass.GetString(), "InternalImportPrivateNestedClass should be bound and have a method GetString."); } } [Export("ImportDefaultFunctions")] public class ImportDefaultFunctions { [Import("FunctionWith0Args")] public Func MyFunction0; [Import("FunctionWith1Arg")] public Func MyFunction1; [Import("FunctionWith2Args")] public Func MyFunction2; [Import("FunctionWith3Args")] public Func MyFunction3; [Import("FunctionWith4Args")] public Func MyFunction4; [Import("ActionWith0Args")] public Action MyAction0; [Import("ActionWith1Arg")] public Action MyAction1; [Import("ActionWith2Args")] public Action MyAction2; [Import("ActionWith3Args")] public Action MyAction3; [Import("ActionWith4Args")] public Action MyAction4; public void VerifyIsBound() { Assert.AreEqual(0, MyFunction0.Invoke()); Assert.AreEqual(1, MyFunction1.Invoke(1)); Assert.AreEqual(3, MyFunction2.Invoke(1, 2)); Assert.AreEqual(6, MyFunction3.Invoke(1, 2, 3)); Assert.AreEqual(10, MyFunction4.Invoke(1, 2, 3, 4)); MyAction0.Invoke(); MyAction1.Invoke(1); MyAction2.Invoke(1, 2); MyAction3.Invoke(1, 2, 3); MyAction4.Invoke(1, 2, 3, 4); } } public class ExportDefaultFunctions { [Export("FunctionWith0Args")] public int MyFunction0() { return 0; } [Export("FunctionWith1Arg")] public int MyFunction1(int i1) { return i1; } [Export("FunctionWith2Args")] public int MyFunction2(int i1, int i2) { return i1 + i2; } [Export("FunctionWith3Args")] public int MyFunction3(int i1, int i2, int i3) { return i1 + i2 + i3; } [Export("FunctionWith4Args")] public int MyFunction4(int i1, int i2, int i3, int i4) { return i1 + i2 + i3 + i4; } [Export("ActionWith0Args")] public void MyAction0() { } [Export("ActionWith1Arg")] public void MyAction1(int i1) { Assert.AreEqual(i1, 1); } [Export("ActionWith2Args")] public void MyAction2(int i1, int i2) { Assert.AreEqual(i1, 1); Assert.AreEqual(i2, 2); } [Export("ActionWith3Args")] public void MyAction3(int i1, int i2, int i3) { Assert.AreEqual(i1, 1); Assert.AreEqual(i2, 2); Assert.AreEqual(i3, 3); } [Export("ActionWith4Args")] public void MyAction4(int i1, int i2, int i3, int i4) { Assert.AreEqual(i1, 1); Assert.AreEqual(i2, 2); Assert.AreEqual(i3, 3); Assert.AreEqual(i4, 4); } } [Export] public class CatalogComponentTest { } [Export] [PartNotDiscoverable] public class CatalogComponentTestNonComponentPart { } public interface ICatalogComponentTest { } [Export(typeof(ICatalogComponentTest))] public class CatalogComponentInterfaceTest1 : ICatalogComponentTest { } public class CatalogComponentInterfaceTest2 { [Export] public ICatalogComponentTest ExportedInterface { get { return new CatalogComponentInterfaceTest1(); } } } public static class StaticExportClass { [Export("StaticString")] public static string StaticString { get { return "StaticString"; } } } [Export] public class DisposableExportClass : IDisposable { public bool IsDisposed { get; set; } public void Dispose() { Assert.IsFalse(IsDisposed); IsDisposed = true; } } public interface IServiceView { int GetSomeInt(); } [Export("service1")] public class Service { public int GetSomeInt() { return 5; } } public class Client { private IServiceView mySerivce; [Import("service1")] public IServiceView MyService { get { return mySerivce; } set { mySerivce = value; } } public int GetSomeValue() { return MyService.GetSomeInt() * 2; } } [Export] public class TrivialExporter { public bool done = false; } [Export] public class TrivialImporter : IPartImportsSatisfiedNotification { [Import] public TrivialExporter checker; public void OnImportsSatisfied() { checker.done = true; } } [Export] public class UnnamedImportAndExport { [Import] public IUnnamedExport ImportedValue; } [Export] public class StaticExport { } [Export] [PartCreationPolicy(CreationPolicy.NonShared)] public class NonStaticExport { } public interface IUnnamedExport { } [Export(typeof(IUnnamedExport))] public class UnnamedExport : IUnnamedExport { } public interface IExportableTest { string Var1 { get; } } [AttributeUsage(AttributeTargets.All)] [MetadataAttribute] public class ExportableTestAttribute : Attribute { private string var1; public string Var1 { get { return var1; } set { var1 = value; } } } [AttributeUsage(AttributeTargets.All)] [MetadataAttribute] [CLSCompliant(false)] public class MetadataWithCollectionPropertyAttribute : Attribute { private string[] values; public string[] Values { get { return values; } } public MetadataWithCollectionPropertyAttribute(params string[] values) { this.values = values; } } [Export] [MetadataWithCollectionProperty("One", "two", "3")] [CLSCompliant(false)] public class ComponentWithCollectionProperty { } public interface ICollectionOfStrings { IEnumerable Values { get; } } public class SubtractProvider { [Export("One")] public int One = 1; [Export("Two")] public int Two { get { return 2; } } [Export("Add")] [ExportableTest(Var1 = "sub")] public Func Subtract = (x, y) => x - y; } public class RealAddProvider { [Export("One")] public int One = 1; [Export("Two")] public int Two { get { return 2; } } [Export("Add")] [ExportMetadata("Var1", "add")] public int Add(int x, int y) { return x + y; } } public class Consumer { [Import("One")] public int a; [Import("Two")] public int b; [Import("Add")] public Func op; [Import("Add", AllowDefault = true)] public Lazy> opInfo; } public class ConsumerOfMultiple { [ImportMany("Add")] public IEnumerable, IDictionary>> opInfo; } public interface IStrongValueMetadata { int value { get; set; } } public class UntypedExportImporter { [Import("untyped")] public Lazy Export; } public class UntypedExportsImporter { [ImportMany("untyped")] public IEnumerable> Exports; } public class DerivedExport : Export { } public class DerivedExportImporter { [Import("derived")] public DerivedExport Export; } public class DerivedExportsImporter { [ImportMany("derived")] public IEnumerable Exports; } [Export] public class NotSoUniqueName { public int MyIntProperty { get { return 23; } } } public class NotSoUniqueName2 { [Export] public class NotSoUniqueName { public virtual string MyStringProperty { get { return "MyStringProperty"; } } } } [Export] public class MyExport { } [Export] public class MySharedPartExport { [Import("Value", AllowRecomposition = true)] public int Value { get; set; } } [Export] [PartCreationPolicy(CreationPolicy.NonShared)] public class MyNonSharedPartExport { [Import("Value")] public int Value { get; set; } } public class ExportThatCantBeActivated { [Export("ExportMyString")] public string MyString { get { return "MyString"; } } [Import("ContractThatShouldNotexist")] public string MissingImport { get; set; } } public class GenericContract1 { public class GenericContract2 { public class GenericContract3 { } } } public class GenericContract4 { public class GenericContract5 { public class GenericContract6 { } } } public class OuterClassWithGenericNested { public class GenericNested { } } public class GenericContract7 : GenericContract4.GenericContract5.GenericContract6 { } public class GenericContract8 : GenericContract1.GenericContract2.GenericContract3 { } public class NestedParent { public class NestedChild { } } [Export] [PartCreationPolicy(CreationPolicy.NonShared)] public class DirectCycleNonSharedPart { [Import] public DirectCycleNonSharedPart NonSharedPart { get; set; } } [Export] [PartCreationPolicy(CreationPolicy.NonShared)] public class CycleNonSharedPart1 { [Import] public CycleNonSharedPart2 NonSharedPart2 { get; set; } } [Export] [PartCreationPolicy(CreationPolicy.NonShared)] public class CycleNonSharedPart2 { [Import] public CycleNonSharedPart1 NonSharedPart1 { get; set; } } [Export] public class CycleNonSharedPart { [Import] public CycleNonSharedPart1 NonSharedPart1 { get; set; } } [Export] public class CycleSharedPart1 { [Import] public CycleSharedPart2 SharedPart2 { get; set; } } [Export] public class CycleSharedPart2 { [Import] public CycleSharedPart1 SharedPart2 { get; set; } } [Export] public class CycleSharedPart { [Import] public CycleSharedPart1 SharedPart1 { get; set; } [Import] public CycleSharedPart2 SharedPart2 { get; set; } } [Export] [PartCreationPolicy(CreationPolicy.NonShared)] public class NoCycleNonSharedPart { [Import] public SharedPartWithNoCycleNonSharedPart SharedPart { get; set; } } [Export] public class SharedPartWithNoCycleNonSharedPart { [Import] public NoCycleNonSharedPart NonSharedPart { get; set; } } [Export] [PartCreationPolicy(CreationPolicy.NonShared)] public class CycleWithSharedPartAndNonSharedPart { [Import] public SharedPartWithNoCycleNonSharedPart BeforeNonSharedPart { get; set; } [Import] public CycleWithNonSharedPartOnly NonSharedPart { get; set; } [Import] public SharedPartWithNoCycleNonSharedPart SharedPart { get; set; } } [Export] [PartCreationPolicy(CreationPolicy.NonShared)] public class CycleWithNonSharedPartOnly { [Import] public CycleWithSharedPartAndNonSharedPart NonSharedPart { get; set; } } [InheritedExport] public class ExportWithGenericParameter { } public class ExportWithGenericParameterOfInt { [Export] public ExportWithGenericParameter GenericExport { get { return new ExportWithGenericParameter(); } } } [Export] public static class StaticExportWithGenericParameter { } [Export] public class ExportWhichInheritsFromGeneric : ExportWithGenericParameter { } [Export] public class ExportWithExceptionDuringConstruction { public ExportWithExceptionDuringConstruction() { throw new NotImplementedException(); } } [Export] public class SimpleConstructorInjectedObject { [ImportingConstructor] public SimpleConstructorInjectedObject([Import("CISimpleValue")]int value) { CISimpleValue = value; } public int CISimpleValue { get; private set; } } [Export] public class ClassWithNoMarkedOrDefaultConstructor { public ClassWithNoMarkedOrDefaultConstructor(int blah) { } } public class ClassWhichOnlyHasImportingConstructorWithOneArgument { [ImportingConstructor] public ClassWhichOnlyHasImportingConstructorWithOneArgument(int blah) { } } public class ClassWhichOnlyHasImportingConstructor { [ImportingConstructor] public ClassWhichOnlyHasImportingConstructor() { } } public class ClassWhichOnlyHasDefaultConstructor { public ClassWhichOnlyHasDefaultConstructor() { } } [Export] public class BaseExportForImportingConstructors { } [Export] public class ClassWithOnlyHasImportingConstructorButInherits : BaseExportForImportingConstructors { [ImportingConstructor] public ClassWithOnlyHasImportingConstructorButInherits(int blah) { } } [Export] public class ClassWithOnlyHasMultipleImportingConstructorButInherits : BaseExportForImportingConstructors { [ImportingConstructor] public ClassWithOnlyHasMultipleImportingConstructorButInherits(int blah) { } [ImportingConstructor] public ClassWithOnlyHasMultipleImportingConstructorButInherits(string blah) { } } [Export] public class ClassWithMultipleMarkedConstructors { [ImportingConstructor] public ClassWithMultipleMarkedConstructors(int i) { } [ImportingConstructor] public ClassWithMultipleMarkedConstructors(string s) { } public ClassWithMultipleMarkedConstructors() { } } [Export] public class ClassWithOneMarkedAndOneDefaultConstructor { [ImportingConstructor] public ClassWithOneMarkedAndOneDefaultConstructor(int i) { } public ClassWithOneMarkedAndOneDefaultConstructor() { } } [Export] public class ClassWithTwoZeroParameterConstructors { public ClassWithTwoZeroParameterConstructors() { } static ClassWithTwoZeroParameterConstructors() { } } [Export] public class ExceptionDuringINotifyImport : IPartImportsSatisfiedNotification { [ImportMany("Value")] public IEnumerable ValuesJustUsedToGetImportCompletedCalled { get; set; } public void OnImportsSatisfied() { throw new NotImplementedException(); } } [Export] public class ClassWithOptionalPostImport { [Import(AllowDefault = true)] public IFormattable Formatter { get; set; } } [Export] public class ClassWithOptionalPreImport { [ImportingConstructor] public ClassWithOptionalPreImport([Import(AllowDefault = true)] IFormattable formatter) { this.Formatter = formatter; } public IFormattable Formatter { get; private set; } } [MetadataAttribute] public class ThisIsMyMetadataMetadataAttribute : Attribute { public string Argument1 { get; set; } public int Argument2 { get; set; } public double Argument3 { get; set; } public string Argument4 { get; set; } public ThisIsMyMetadataMetadataAttribute() { } public ThisIsMyMetadataMetadataAttribute(string Argument1, int Argument2) { this.Argument1 = Argument1; this.Argument2 = Argument2; } } [Export] [ThisIsMyMetadataMetadataAttribute("One", 2, Argument3 = 3.0)] public class ExportedTypeWithConcreteMetadata { } }