diff options
Diffstat (limited to 'mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/SampleComponents.cs')
| -rw-r--r-- | mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/SampleComponents.cs | 1023 |
1 files changed, 0 insertions, 1023 deletions
diff --git a/mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/SampleComponents.cs b/mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/SampleComponents.cs deleted file mode 100644 index f82d9eabf36..00000000000 --- a/mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/SampleComponents.cs +++ /dev/null @@ -1,1023 +0,0 @@ -// -----------------------------------------------------------------------
-// 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<string> 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<string> 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<string> 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<string> 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<string> 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<string> 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<string> 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<string> 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<string> 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<string> 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<int> MyFunction0;
-
- [Import("FunctionWith1Arg")]
- public Func<int, int> MyFunction1;
-
- [Import("FunctionWith2Args")]
- public Func<int, int, int> MyFunction2;
-
- [Import("FunctionWith3Args")]
- public Func<int, int, int, int> MyFunction3;
-
- [Import("FunctionWith4Args")]
- public Func<int, int, int, int, int> MyFunction4;
-
- [Import("ActionWith0Args")]
- public Action MyAction0;
-
- [Import("ActionWith1Arg")]
- public Action<int> MyAction1;
-
- [Import("ActionWith2Args")]
- public Action<int, int> MyAction2;
-
- [Import("ActionWith3Args")]
- public Action<int, int, int> MyAction3;
-
- [Import("ActionWith4Args")]
- public Action<int, int, int, int> 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<string> 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<int, int, int> 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<int, int, int> op;
- [Import("Add", AllowDefault = true)]
- public Lazy<Func<int, int, int>> opInfo;
- }
-
- public class ConsumerOfMultiple
- {
- [ImportMany("Add")]
- public IEnumerable<Lazy<Func<int, int, int>, IDictionary<string, object>>> opInfo;
- }
-
- public interface IStrongValueMetadata
- {
- int value { get; set; }
- }
-
- public class UntypedExportImporter
- {
- [Import("untyped")]
- public Lazy<object> Export;
- }
-
- public class UntypedExportsImporter
- {
- [ImportMany("untyped")]
- public IEnumerable<Lazy<object>> Exports;
- }
-
- public class DerivedExport : Export
- {
- }
-
- public class DerivedExportImporter
- {
- [Import("derived")]
- public DerivedExport Export;
-
- }
-
- public class DerivedExportsImporter
- {
- [ImportMany("derived")]
- public IEnumerable<DerivedExport> 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<T>
- {
- public class GenericContract2
- {
- public class GenericContract3<N>
- {
- }
- }
- }
-
- public class GenericContract4<T, K>
- {
- public class GenericContract5<A, B>
- {
- public class GenericContract6<N, M>
- {
- }
- }
- }
-
- public class OuterClassWithGenericNested
- {
- public class GenericNested<T>
- {
- }
- }
-
- public class GenericContract7 :
- GenericContract4<string, string>.GenericContract5<int, int>.GenericContract6<double, double> { }
-
- public class GenericContract8<T> : GenericContract1<string>.GenericContract2.GenericContract3<T> { }
-
- 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<T>
- {
- }
-
- public class ExportWithGenericParameterOfInt
- {
- [Export]
- public ExportWithGenericParameter<int> GenericExport { get { return new ExportWithGenericParameter<int>(); } }
- }
-
- [Export]
- public static class StaticExportWithGenericParameter<T>
- {
- }
-
- [Export]
- public class ExportWhichInheritsFromGeneric : ExportWithGenericParameter<string>
- {
-
- }
-
- [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<int> 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
- {
- }
-
-}
\ No newline at end of file |