From 1333392fec90601754c4d0873ba41a272942cf21 Mon Sep 17 00:00:00 2001 From: Matt Thalman Date: Wed, 30 Aug 2023 09:59:12 -0500 Subject: [PATCH] Add System.ComponentModel.Composition.4.5.0 --- eng/Build.props | 2 + ...em.ComponentModel.Composition.4.5.0.csproj | 10 + .../System.ComponentModel.Composition.cs | 1046 +++++++++++++++++ .../system.componentmodel.composition.nuspec | 41 + 4 files changed, 1099 insertions(+) create mode 100644 src/referencePackages/src/system.componentmodel.composition/4.5.0/System.ComponentModel.Composition.4.5.0.csproj create mode 100644 src/referencePackages/src/system.componentmodel.composition/4.5.0/ref/netstandard2.0/System.ComponentModel.Composition.cs create mode 100644 src/referencePackages/src/system.componentmodel.composition/4.5.0/system.componentmodel.composition.nuspec diff --git a/eng/Build.props b/eng/Build.props index 6ef888e48..b0afd7299 100644 --- a/eng/Build.props +++ b/eng/Build.props @@ -27,6 +27,8 @@ + + diff --git a/src/referencePackages/src/system.componentmodel.composition/4.5.0/System.ComponentModel.Composition.4.5.0.csproj b/src/referencePackages/src/system.componentmodel.composition/4.5.0/System.ComponentModel.Composition.4.5.0.csproj new file mode 100644 index 000000000..99ac9c484 --- /dev/null +++ b/src/referencePackages/src/system.componentmodel.composition/4.5.0/System.ComponentModel.Composition.4.5.0.csproj @@ -0,0 +1,10 @@ + + + + netstandard2.0 + System.ComponentModel.Composition + 2 + ECMA + + + diff --git a/src/referencePackages/src/system.componentmodel.composition/4.5.0/ref/netstandard2.0/System.ComponentModel.Composition.cs b/src/referencePackages/src/system.componentmodel.composition/4.5.0/ref/netstandard2.0/System.ComponentModel.Composition.cs new file mode 100644 index 000000000..0b0c46674 --- /dev/null +++ b/src/referencePackages/src/system.componentmodel.composition/4.5.0/ref/netstandard2.0/System.ComponentModel.Composition.cs @@ -0,0 +1,1046 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Security.AllowPartiallyTrustedCallers] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyTitle("System.ComponentModel.Composition")] +[assembly: System.Reflection.AssemblyDescription("System.ComponentModel.Composition")] +[assembly: System.Reflection.AssemblyDefaultAlias("System.ComponentModel.Composition")] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET Framework")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyFileVersion("4.6.26515.06")] +[assembly: System.Reflection.AssemblyInformationalVersion("4.6.26515.06 @BuiltBy: dlab-DDVSOWINAGE059 @Branch: release/2.1 @SrcCode: https://github.com/dotnet/corefx/tree/30ab651fcb4354552bd4891619a0bdd81e0ebdbf")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyMetadata(".NETFrameworkAssembly", "")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("4.0.0.0")] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Lazy<,>))] +namespace System.ComponentModel.Composition +{ + public static partial class AdaptationConstants + { + public const string AdapterContractName = "System.ComponentModel.Composition.AdapterContract"; + public const string AdapterFromContractMetadataName = "FromContract"; + public const string AdapterToContractMetadataName = "ToContract"; + } + + public static partial class AttributedModelServices + { + public static Primitives.ComposablePart AddExportedValue(this Hosting.CompositionBatch batch, T exportedValue) { throw null; } + + public static Primitives.ComposablePart AddExportedValue(this Hosting.CompositionBatch batch, string contractName, T exportedValue) { throw null; } + + public static Primitives.ComposablePart AddPart(this Hosting.CompositionBatch batch, object attributedPart) { throw null; } + + public static void ComposeExportedValue(this Hosting.CompositionContainer container, T exportedValue) { } + + public static void ComposeExportedValue(this Hosting.CompositionContainer container, string contractName, T exportedValue) { } + + public static void ComposeParts(this Hosting.CompositionContainer container, params object[] attributedParts) { } + + public static Primitives.ComposablePart CreatePart(Primitives.ComposablePartDefinition partDefinition, object attributedPart) { throw null; } + + public static Primitives.ComposablePart CreatePart(object attributedPart, Reflection.ReflectionContext reflectionContext) { throw null; } + + public static Primitives.ComposablePart CreatePart(object attributedPart) { throw null; } + + public static Primitives.ComposablePartDefinition CreatePartDefinition(Type type, Primitives.ICompositionElement origin, bool ensureIsDiscoverable) { throw null; } + + public static Primitives.ComposablePartDefinition CreatePartDefinition(Type type, Primitives.ICompositionElement origin) { throw null; } + + public static bool Exports(this Primitives.ComposablePartDefinition part, Type contractType) { throw null; } + + public static bool Exports(this Primitives.ComposablePartDefinition part) { throw null; } + + public static string GetContractName(Type type) { throw null; } + + public static TMetadataView GetMetadataView(Collections.Generic.IDictionary metadata) { throw null; } + + public static string GetTypeIdentity(Reflection.MethodInfo method) { throw null; } + + public static string GetTypeIdentity(Type type) { throw null; } + + public static bool Imports(this Primitives.ComposablePartDefinition part, Type contractType, Primitives.ImportCardinality importCardinality) { throw null; } + + public static bool Imports(this Primitives.ComposablePartDefinition part, Type contractType) { throw null; } + + public static bool Imports(this Primitives.ComposablePartDefinition part, Primitives.ImportCardinality importCardinality) { throw null; } + + public static bool Imports(this Primitives.ComposablePartDefinition part) { throw null; } + + public static Primitives.ComposablePart SatisfyImportsOnce(this ICompositionService compositionService, object attributedPart, Reflection.ReflectionContext reflectionContext) { throw null; } + + public static Primitives.ComposablePart SatisfyImportsOnce(this ICompositionService compositionService, object attributedPart) { throw null; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = true)] + public partial class CatalogReflectionContextAttribute : Attribute + { + public CatalogReflectionContextAttribute(Type reflectionContextType) { } + + public Reflection.ReflectionContext CreateReflectionContext() { throw null; } + } + + public partial class ChangeRejectedException : CompositionException + { + public ChangeRejectedException() { } + + public ChangeRejectedException(Collections.Generic.IEnumerable errors) { } + + public ChangeRejectedException(string message, Exception innerException) { } + + public ChangeRejectedException(string message) { } + + public override string Message { get { throw null; } } + } + + public partial class CompositionContractMismatchException : Exception + { + public CompositionContractMismatchException() { } + + protected CompositionContractMismatchException(Runtime.Serialization.SerializationInfo info, Runtime.Serialization.StreamingContext context) { } + + public CompositionContractMismatchException(string message, Exception innerException) { } + + public CompositionContractMismatchException(string message) { } + } + + public partial class CompositionError + { + public CompositionError(string message, Primitives.ICompositionElement element, Exception exception) { } + + public CompositionError(string message, Primitives.ICompositionElement element) { } + + public CompositionError(string message, Exception exception) { } + + public CompositionError(string message) { } + + public string Description { get { throw null; } } + + public Primitives.ICompositionElement Element { get { throw null; } } + + public Exception Exception { get { throw null; } } + + public override string ToString() { throw null; } + } + + public partial class CompositionException : Exception + { + public CompositionException() { } + + public CompositionException(Collections.Generic.IEnumerable errors) { } + + public CompositionException(string message, Exception innerException) { } + + public CompositionException(string message) { } + + public Collections.ObjectModel.ReadOnlyCollection Errors { get { throw null; } } + + public override string Message { get { throw null; } } + + public Collections.ObjectModel.ReadOnlyCollection RootCauses { get { throw null; } } + } + + public enum CreationPolicy + { + Any = 0, + Shared = 1, + NonShared = 2 + } + + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)] + public partial class ExportAttribute : Attribute + { + public ExportAttribute() { } + + public ExportAttribute(string contractName, Type contractType) { } + + public ExportAttribute(string contractName) { } + + public ExportAttribute(Type contractType) { } + + public string ContractName { get { throw null; } } + + public Type ContractType { get { throw null; } } + } + + public partial class ExportFactory + { + public ExportFactory(Func> exportLifetimeContextCreator) { } + + public ExportLifetimeContext CreateExport() { throw null; } + } + + public partial class ExportFactory : ExportFactory + { + public ExportFactory(Func> exportLifetimeContextCreator, TMetadata metadata) : base(default!) { } + + public TMetadata Metadata { get { throw null; } } + } + + public sealed partial class ExportLifetimeContext : IDisposable + { + public ExportLifetimeContext(T value, Action disposeAction) { } + + public T Value { get { throw null; } } + + public void Dispose() { } + } + + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)] + public sealed partial class ExportMetadataAttribute : Attribute + { + public ExportMetadataAttribute(string name, object value) { } + + public bool IsMultiple { get { throw null; } set { } } + + public string Name { get { throw null; } } + + public object Value { get { throw null; } } + } + + public partial interface ICompositionService + { + void SatisfyImportsOnce(Primitives.ComposablePart part); + } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] + public partial class ImportAttribute : Attribute + { + public ImportAttribute() { } + + public ImportAttribute(string contractName, Type contractType) { } + + public ImportAttribute(string contractName) { } + + public ImportAttribute(Type contractType) { } + + public bool AllowDefault { get { throw null; } set { } } + + public bool AllowRecomposition { get { throw null; } set { } } + + public string ContractName { get { throw null; } } + + public Type ContractType { get { throw null; } } + + public CreationPolicy RequiredCreationPolicy { get { throw null; } set { } } + + public ImportSource Source { get { throw null; } set { } } + } + + public partial class ImportCardinalityMismatchException : Exception + { + public ImportCardinalityMismatchException() { } + + protected ImportCardinalityMismatchException(Runtime.Serialization.SerializationInfo info, Runtime.Serialization.StreamingContext context) { } + + public ImportCardinalityMismatchException(string message, Exception innerException) { } + + public ImportCardinalityMismatchException(string message) { } + } + + [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)] + public partial class ImportingConstructorAttribute : Attribute + { + } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] + public partial class ImportManyAttribute : Attribute + { + public ImportManyAttribute() { } + + public ImportManyAttribute(string contractName, Type contractType) { } + + public ImportManyAttribute(string contractName) { } + + public ImportManyAttribute(Type contractType) { } + + public bool AllowRecomposition { get { throw null; } set { } } + + public string ContractName { get { throw null; } } + + public Type ContractType { get { throw null; } } + + public CreationPolicy RequiredCreationPolicy { get { throw null; } set { } } + + public ImportSource Source { get { throw null; } set { } } + } + + public enum ImportSource + { + Any = 0, + Local = 1, + NonLocal = 2 + } + + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = true, Inherited = true)] + public partial class InheritedExportAttribute : ExportAttribute + { + public InheritedExportAttribute() { } + + public InheritedExportAttribute(string contractName, Type contractType) { } + + public InheritedExportAttribute(string contractName) { } + + public InheritedExportAttribute(Type contractType) { } + } + + public partial interface IPartImportsSatisfiedNotification + { + void OnImportsSatisfied(); + } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)] + public sealed partial class MetadataAttributeAttribute : Attribute + { + } + + [AttributeUsage(AttributeTargets.Interface, AllowMultiple = false, Inherited = false)] + public sealed partial class MetadataViewImplementationAttribute : Attribute + { + public MetadataViewImplementationAttribute(Type implementationType) { } + + public Type ImplementationType { get { throw null; } } + } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)] + public sealed partial class PartCreationPolicyAttribute : Attribute + { + public PartCreationPolicyAttribute(CreationPolicy creationPolicy) { } + + public CreationPolicy CreationPolicy { get { throw null; } } + } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)] + public sealed partial class PartMetadataAttribute : Attribute + { + public PartMetadataAttribute(string name, object value) { } + + public string Name { get { throw null; } } + + public object Value { get { throw null; } } + } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)] + public sealed partial class PartNotDiscoverableAttribute : Attribute + { + } +} + +namespace System.ComponentModel.Composition.Hosting +{ + public partial class AggregateCatalog : Primitives.ComposablePartCatalog, INotifyComposablePartCatalogChanged + { + public AggregateCatalog() { } + + public AggregateCatalog(Collections.Generic.IEnumerable catalogs) { } + + public AggregateCatalog(params Primitives.ComposablePartCatalog[] catalogs) { } + + public Collections.Generic.ICollection Catalogs { get { throw null; } } + + public event EventHandler Changed { add { } remove { } } + + public event EventHandler Changing { add { } remove { } } + + protected override void Dispose(bool disposing) { } + + public override Collections.Generic.IEnumerator GetEnumerator() { throw null; } + + public override Collections.Generic.IEnumerable> GetExports(Primitives.ImportDefinition definition) { throw null; } + + protected virtual void OnChanged(ComposablePartCatalogChangeEventArgs e) { } + + protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e) { } + } + + public partial class AggregateExportProvider : ExportProvider, IDisposable + { + public AggregateExportProvider(Collections.Generic.IEnumerable providers) { } + + public AggregateExportProvider(params ExportProvider[] providers) { } + + public Collections.ObjectModel.ReadOnlyCollection Providers { get { throw null; } } + + public void Dispose() { } + + protected virtual void Dispose(bool disposing) { } + + protected override Collections.Generic.IEnumerable GetExportsCore(Primitives.ImportDefinition definition, AtomicComposition atomicComposition) { throw null; } + } + + public partial class ApplicationCatalog : Primitives.ComposablePartCatalog, Primitives.ICompositionElement + { + public ApplicationCatalog() { } + + public ApplicationCatalog(Primitives.ICompositionElement definitionOrigin) { } + + public ApplicationCatalog(Reflection.ReflectionContext reflectionContext, Primitives.ICompositionElement definitionOrigin) { } + + public ApplicationCatalog(Reflection.ReflectionContext reflectionContext) { } + + string Primitives.ICompositionElement.DisplayName { get { throw null; } } + + Primitives.ICompositionElement Primitives.ICompositionElement.Origin { get { throw null; } } + + protected override void Dispose(bool disposing) { } + + public override Collections.Generic.IEnumerator GetEnumerator() { throw null; } + + public override Collections.Generic.IEnumerable> GetExports(Primitives.ImportDefinition definition) { throw null; } + + public override string ToString() { throw null; } + } + + public partial class AssemblyCatalog : Primitives.ComposablePartCatalog, Primitives.ICompositionElement + { + public AssemblyCatalog(Reflection.Assembly assembly, Primitives.ICompositionElement definitionOrigin) { } + + public AssemblyCatalog(Reflection.Assembly assembly, Reflection.ReflectionContext reflectionContext, Primitives.ICompositionElement definitionOrigin) { } + + public AssemblyCatalog(Reflection.Assembly assembly, Reflection.ReflectionContext reflectionContext) { } + + public AssemblyCatalog(Reflection.Assembly assembly) { } + + public AssemblyCatalog(string codeBase, Primitives.ICompositionElement definitionOrigin) { } + + public AssemblyCatalog(string codeBase, Reflection.ReflectionContext reflectionContext, Primitives.ICompositionElement definitionOrigin) { } + + public AssemblyCatalog(string codeBase, Reflection.ReflectionContext reflectionContext) { } + + public AssemblyCatalog(string codeBase) { } + + public Reflection.Assembly Assembly { get { throw null; } } + + string Primitives.ICompositionElement.DisplayName { get { throw null; } } + + Primitives.ICompositionElement Primitives.ICompositionElement.Origin { get { throw null; } } + + protected override void Dispose(bool disposing) { } + + public override Collections.Generic.IEnumerator GetEnumerator() { throw null; } + + public override Collections.Generic.IEnumerable> GetExports(Primitives.ImportDefinition definition) { throw null; } + + public override string ToString() { throw null; } + } + + public partial class AtomicComposition : IDisposable + { + public AtomicComposition() { } + + public AtomicComposition(AtomicComposition outerAtomicComposition) { } + + public void AddCompleteAction(Action completeAction) { } + + public void AddRevertAction(Action revertAction) { } + + public void Complete() { } + + public void Dispose() { } + + protected virtual void Dispose(bool disposing) { } + + public void SetValue(object key, object value) { } + + public bool TryGetValue(object key, out T value) { throw null; } + + public bool TryGetValue(object key, bool localAtomicCompositionOnly, out T value) { throw null; } + } + + public partial class CatalogExportProvider : ExportProvider, IDisposable + { + public CatalogExportProvider(Primitives.ComposablePartCatalog catalog, bool isThreadSafe) { } + + public CatalogExportProvider(Primitives.ComposablePartCatalog catalog, CompositionOptions compositionOptions) { } + + public CatalogExportProvider(Primitives.ComposablePartCatalog catalog) { } + + public Primitives.ComposablePartCatalog Catalog { get { throw null; } } + + public ExportProvider SourceProvider { get { throw null; } set { } } + + public void Dispose() { } + + protected virtual void Dispose(bool disposing) { } + + protected override Collections.Generic.IEnumerable GetExportsCore(Primitives.ImportDefinition definition, AtomicComposition atomicComposition) { throw null; } + } + + public static partial class CatalogExtensions + { + public static CompositionService CreateCompositionService(this Primitives.ComposablePartCatalog composablePartCatalog) { throw null; } + } + + public partial class ComposablePartCatalogChangeEventArgs : EventArgs + { + public ComposablePartCatalogChangeEventArgs(Collections.Generic.IEnumerable addedDefinitions, Collections.Generic.IEnumerable removedDefinitions, AtomicComposition atomicComposition) { } + + public Collections.Generic.IEnumerable AddedDefinitions { get { throw null; } } + + public AtomicComposition AtomicComposition { get { throw null; } } + + public Collections.Generic.IEnumerable RemovedDefinitions { get { throw null; } } + } + + public partial class ComposablePartExportProvider : ExportProvider, IDisposable + { + public ComposablePartExportProvider() { } + + public ComposablePartExportProvider(bool isThreadSafe) { } + + public ComposablePartExportProvider(CompositionOptions compositionOptions) { } + + public ExportProvider SourceProvider { get { throw null; } set { } } + + public void Compose(CompositionBatch batch) { } + + public void Dispose() { } + + protected virtual void Dispose(bool disposing) { } + + protected override Collections.Generic.IEnumerable GetExportsCore(Primitives.ImportDefinition definition, AtomicComposition atomicComposition) { throw null; } + } + + public partial class CompositionBatch + { + public CompositionBatch() { } + + public CompositionBatch(Collections.Generic.IEnumerable partsToAdd, Collections.Generic.IEnumerable partsToRemove) { } + + public Collections.ObjectModel.ReadOnlyCollection PartsToAdd { get { throw null; } } + + public Collections.ObjectModel.ReadOnlyCollection PartsToRemove { get { throw null; } } + + public Primitives.ComposablePart AddExport(Primitives.Export export) { throw null; } + + public void AddPart(Primitives.ComposablePart part) { } + + public void RemovePart(Primitives.ComposablePart part) { } + } + + public static partial class CompositionConstants + { + public const string ExportTypeIdentityMetadataName = "ExportTypeIdentity"; + public const string GenericContractMetadataName = "System.ComponentModel.Composition.GenericContractName"; + public const string GenericParametersMetadataName = "System.ComponentModel.Composition.GenericParameters"; + public const string ImportSourceMetadataName = "System.ComponentModel.Composition.ImportSource"; + public const string IsGenericPartMetadataName = "System.ComponentModel.Composition.IsGenericPart"; + public const string PartCreationPolicyMetadataName = "System.ComponentModel.Composition.CreationPolicy"; + } + + public partial class CompositionContainer : ExportProvider, ICompositionService, IDisposable + { + public CompositionContainer() { } + + public CompositionContainer(CompositionOptions compositionOptions, params ExportProvider[] providers) { } + + public CompositionContainer(params ExportProvider[] providers) { } + + public CompositionContainer(Primitives.ComposablePartCatalog catalog, bool isThreadSafe, params ExportProvider[] providers) { } + + public CompositionContainer(Primitives.ComposablePartCatalog catalog, CompositionOptions compositionOptions, params ExportProvider[] providers) { } + + public CompositionContainer(Primitives.ComposablePartCatalog catalog, params ExportProvider[] providers) { } + + public Primitives.ComposablePartCatalog Catalog { get { throw null; } } + + public Collections.ObjectModel.ReadOnlyCollection Providers { get { throw null; } } + + public void Compose(CompositionBatch batch) { } + + public void Dispose() { } + + protected virtual void Dispose(bool disposing) { } + + protected override Collections.Generic.IEnumerable GetExportsCore(Primitives.ImportDefinition definition, AtomicComposition atomicComposition) { throw null; } + + public void ReleaseExport(Primitives.Export export) { } + + public void ReleaseExport(Lazy export) { } + + public void ReleaseExports(Collections.Generic.IEnumerable exports) { } + + public void ReleaseExports(Collections.Generic.IEnumerable> exports) { } + + public void ReleaseExports(Collections.Generic.IEnumerable> exports) { } + + public void SatisfyImportsOnce(Primitives.ComposablePart part) { } + } + + [Flags] + public enum CompositionOptions + { + Default = 0, + DisableSilentRejection = 1, + IsThreadSafe = 2, + ExportCompositionService = 4 + } + + public partial class CompositionScopeDefinition : Primitives.ComposablePartCatalog, INotifyComposablePartCatalogChanged + { + protected CompositionScopeDefinition() { } + + public CompositionScopeDefinition(Primitives.ComposablePartCatalog catalog, Collections.Generic.IEnumerable children, Collections.Generic.IEnumerable publicSurface) { } + + public CompositionScopeDefinition(Primitives.ComposablePartCatalog catalog, Collections.Generic.IEnumerable children) { } + + public virtual Collections.Generic.IEnumerable Children { get { throw null; } } + + public virtual Collections.Generic.IEnumerable PublicSurface { get { throw null; } } + + public event EventHandler Changed { add { } remove { } } + + public event EventHandler Changing { add { } remove { } } + + protected override void Dispose(bool disposing) { } + + public override Collections.Generic.IEnumerator GetEnumerator() { throw null; } + + public override Collections.Generic.IEnumerable> GetExports(Primitives.ImportDefinition definition) { throw null; } + + protected virtual void OnChanged(ComposablePartCatalogChangeEventArgs e) { } + + protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e) { } + } + + public partial class CompositionService : ICompositionService, IDisposable + { + internal CompositionService() { } + + public void Dispose() { } + + public void SatisfyImportsOnce(Primitives.ComposablePart part) { } + } + + public partial class DirectoryCatalog : Primitives.ComposablePartCatalog, INotifyComposablePartCatalogChanged, Primitives.ICompositionElement + { + public DirectoryCatalog(string path, Primitives.ICompositionElement definitionOrigin) { } + + public DirectoryCatalog(string path, Reflection.ReflectionContext reflectionContext, Primitives.ICompositionElement definitionOrigin) { } + + public DirectoryCatalog(string path, Reflection.ReflectionContext reflectionContext) { } + + public DirectoryCatalog(string path, string searchPattern, Primitives.ICompositionElement definitionOrigin) { } + + public DirectoryCatalog(string path, string searchPattern, Reflection.ReflectionContext reflectionContext, Primitives.ICompositionElement definitionOrigin) { } + + public DirectoryCatalog(string path, string searchPattern, Reflection.ReflectionContext reflectionContext) { } + + public DirectoryCatalog(string path, string searchPattern) { } + + public DirectoryCatalog(string path) { } + + public string FullPath { get { throw null; } } + + public Collections.ObjectModel.ReadOnlyCollection LoadedFiles { get { throw null; } } + + public string Path { get { throw null; } } + + public string SearchPattern { get { throw null; } } + + string Primitives.ICompositionElement.DisplayName { get { throw null; } } + + Primitives.ICompositionElement Primitives.ICompositionElement.Origin { get { throw null; } } + + public event EventHandler Changed { add { } remove { } } + + public event EventHandler Changing { add { } remove { } } + + protected override void Dispose(bool disposing) { } + + public override Collections.Generic.IEnumerator GetEnumerator() { throw null; } + + public override Collections.Generic.IEnumerable> GetExports(Primitives.ImportDefinition definition) { throw null; } + + protected virtual void OnChanged(ComposablePartCatalogChangeEventArgs e) { } + + protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e) { } + + public void Refresh() { } + + public override string ToString() { throw null; } + } + + public abstract partial class ExportProvider + { + public event EventHandler ExportsChanged { add { } remove { } } + + public event EventHandler ExportsChanging { add { } remove { } } + + public Lazy GetExport() { throw null; } + + public Lazy GetExport(string contractName) { throw null; } + + public Lazy GetExport() { throw null; } + + public Lazy GetExport(string contractName) { throw null; } + + public T GetExportedValue() { throw null; } + + public T GetExportedValue(string contractName) { throw null; } + + public T GetExportedValueOrDefault() { throw null; } + + public T GetExportedValueOrDefault(string contractName) { throw null; } + + public Collections.Generic.IEnumerable GetExportedValues() { throw null; } + + public Collections.Generic.IEnumerable GetExportedValues(string contractName) { throw null; } + + public Collections.Generic.IEnumerable GetExports(Primitives.ImportDefinition definition, AtomicComposition atomicComposition) { throw null; } + + public Collections.Generic.IEnumerable GetExports(Primitives.ImportDefinition definition) { throw null; } + + public Collections.Generic.IEnumerable> GetExports(Type type, Type metadataViewType, string contractName) { throw null; } + + public Collections.Generic.IEnumerable> GetExports() { throw null; } + + public Collections.Generic.IEnumerable> GetExports(string contractName) { throw null; } + + public Collections.Generic.IEnumerable> GetExports() { throw null; } + + public Collections.Generic.IEnumerable> GetExports(string contractName) { throw null; } + + protected abstract Collections.Generic.IEnumerable GetExportsCore(Primitives.ImportDefinition definition, AtomicComposition atomicComposition); + protected virtual void OnExportsChanged(ExportsChangeEventArgs e) { } + + protected virtual void OnExportsChanging(ExportsChangeEventArgs e) { } + + public bool TryGetExports(Primitives.ImportDefinition definition, AtomicComposition atomicComposition, out Collections.Generic.IEnumerable exports) { throw null; } + } + + public partial class ExportsChangeEventArgs : EventArgs + { + public ExportsChangeEventArgs(Collections.Generic.IEnumerable addedExports, Collections.Generic.IEnumerable removedExports, AtomicComposition atomicComposition) { } + + public Collections.Generic.IEnumerable AddedExports { get { throw null; } } + + public AtomicComposition AtomicComposition { get { throw null; } } + + public Collections.Generic.IEnumerable ChangedContractNames { get { throw null; } } + + public Collections.Generic.IEnumerable RemovedExports { get { throw null; } } + } + + public partial class FilteredCatalog : Primitives.ComposablePartCatalog, INotifyComposablePartCatalogChanged + { + public FilteredCatalog(Primitives.ComposablePartCatalog catalog, Func filter) { } + + public FilteredCatalog Complement { get { throw null; } } + + public event EventHandler Changed { add { } remove { } } + + public event EventHandler Changing { add { } remove { } } + + protected override void Dispose(bool disposing) { } + + public override Collections.Generic.IEnumerator GetEnumerator() { throw null; } + + public override Collections.Generic.IEnumerable> GetExports(Primitives.ImportDefinition definition) { throw null; } + + public FilteredCatalog IncludeDependencies() { throw null; } + + public FilteredCatalog IncludeDependencies(Func importFilter) { throw null; } + + public FilteredCatalog IncludeDependents() { throw null; } + + public FilteredCatalog IncludeDependents(Func importFilter) { throw null; } + + protected virtual void OnChanged(ComposablePartCatalogChangeEventArgs e) { } + + protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e) { } + } + + public partial class ImportEngine : ICompositionService, IDisposable + { + public ImportEngine(ExportProvider sourceProvider, bool isThreadSafe) { } + + public ImportEngine(ExportProvider sourceProvider, CompositionOptions compositionOptions) { } + + public ImportEngine(ExportProvider sourceProvider) { } + + public void Dispose() { } + + protected virtual void Dispose(bool disposing) { } + + public void PreviewImports(Primitives.ComposablePart part, AtomicComposition atomicComposition) { } + + public void ReleaseImports(Primitives.ComposablePart part, AtomicComposition atomicComposition) { } + + public void SatisfyImports(Primitives.ComposablePart part) { } + + public void SatisfyImportsOnce(Primitives.ComposablePart part) { } + } + + public partial interface INotifyComposablePartCatalogChanged + { + event EventHandler Changed; + event EventHandler Changing; + } + + public static partial class ScopingExtensions + { + public static bool ContainsPartMetadata(this Primitives.ComposablePartDefinition part, string key, T value) { throw null; } + + public static bool ContainsPartMetadataWithKey(this Primitives.ComposablePartDefinition part, string key) { throw null; } + + public static bool Exports(this Primitives.ComposablePartDefinition part, string contractName) { throw null; } + + public static FilteredCatalog Filter(this Primitives.ComposablePartCatalog catalog, Func filter) { throw null; } + + public static bool Imports(this Primitives.ComposablePartDefinition part, string contractName, Primitives.ImportCardinality importCardinality) { throw null; } + + public static bool Imports(this Primitives.ComposablePartDefinition part, string contractName) { throw null; } + } + + public partial class TypeCatalog : Primitives.ComposablePartCatalog, Primitives.ICompositionElement + { + public TypeCatalog(Collections.Generic.IEnumerable types, Primitives.ICompositionElement definitionOrigin) { } + + public TypeCatalog(Collections.Generic.IEnumerable types, Reflection.ReflectionContext reflectionContext, Primitives.ICompositionElement definitionOrigin) { } + + public TypeCatalog(Collections.Generic.IEnumerable types, Reflection.ReflectionContext reflectionContext) { } + + public TypeCatalog(Collections.Generic.IEnumerable types) { } + + public TypeCatalog(params Type[] types) { } + + string Primitives.ICompositionElement.DisplayName { get { throw null; } } + + Primitives.ICompositionElement Primitives.ICompositionElement.Origin { get { throw null; } } + + protected override void Dispose(bool disposing) { } + + public override Collections.Generic.IEnumerator GetEnumerator() { throw null; } + + public override string ToString() { throw null; } + } +} + +namespace System.ComponentModel.Composition.Primitives +{ + public abstract partial class ComposablePart + { + public abstract Collections.Generic.IEnumerable ExportDefinitions { get; } + public abstract Collections.Generic.IEnumerable ImportDefinitions { get; } + + public virtual Collections.Generic.IDictionary Metadata { get { throw null; } } + + public virtual void Activate() { } + + public abstract object GetExportedValue(ExportDefinition definition); + public abstract void SetImport(ImportDefinition definition, Collections.Generic.IEnumerable exports); + } + + public abstract partial class ComposablePartCatalog : Collections.Generic.IEnumerable, Collections.IEnumerable, IDisposable + { + public virtual Linq.IQueryable Parts { get { throw null; } } + + public void Dispose() { } + + protected virtual void Dispose(bool disposing) { } + + public virtual Collections.Generic.IEnumerator GetEnumerator() { throw null; } + + public virtual Collections.Generic.IEnumerable> GetExports(ImportDefinition definition) { throw null; } + + Collections.IEnumerator Collections.IEnumerable.GetEnumerator() { throw null; } + } + + public abstract partial class ComposablePartDefinition + { + public abstract Collections.Generic.IEnumerable ExportDefinitions { get; } + public abstract Collections.Generic.IEnumerable ImportDefinitions { get; } + + public virtual Collections.Generic.IDictionary Metadata { get { throw null; } } + + public abstract ComposablePart CreatePart(); + } + + public partial class ComposablePartException : Exception + { + public ComposablePartException() { } + + public ComposablePartException(string message, ICompositionElement element, Exception innerException) { } + + public ComposablePartException(string message, ICompositionElement element) { } + + public ComposablePartException(string message, Exception innerException) { } + + public ComposablePartException(string message) { } + + public ICompositionElement Element { get { throw null; } } + } + + public partial class ContractBasedImportDefinition : ImportDefinition + { + protected ContractBasedImportDefinition() { } + + public ContractBasedImportDefinition(string contractName, string requiredTypeIdentity, Collections.Generic.IEnumerable> requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, CreationPolicy requiredCreationPolicy, Collections.Generic.IDictionary metadata) { } + + public ContractBasedImportDefinition(string contractName, string requiredTypeIdentity, Collections.Generic.IEnumerable> requiredMetadata, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, CreationPolicy requiredCreationPolicy) { } + + public override Linq.Expressions.Expression> Constraint { get { throw null; } } + + public virtual CreationPolicy RequiredCreationPolicy { get { throw null; } } + + public virtual Collections.Generic.IEnumerable> RequiredMetadata { get { throw null; } } + + public virtual string RequiredTypeIdentity { get { throw null; } } + + public override bool IsConstraintSatisfiedBy(ExportDefinition exportDefinition) { throw null; } + + public override string ToString() { throw null; } + } + + public partial class Export + { + protected Export() { } + + public Export(ExportDefinition definition, Func exportedValueGetter) { } + + public Export(string contractName, Collections.Generic.IDictionary metadata, Func exportedValueGetter) { } + + public Export(string contractName, Func exportedValueGetter) { } + + public virtual ExportDefinition Definition { get { throw null; } } + + public Collections.Generic.IDictionary Metadata { get { throw null; } } + + public object Value { get { throw null; } } + + protected virtual object GetExportedValueCore() { throw null; } + } + + public partial class ExportDefinition + { + protected ExportDefinition() { } + + public ExportDefinition(string contractName, Collections.Generic.IDictionary metadata) { } + + public virtual string ContractName { get { throw null; } } + + public virtual Collections.Generic.IDictionary Metadata { get { throw null; } } + + public override string ToString() { throw null; } + } + + public partial class ExportedDelegate + { + protected ExportedDelegate() { } + + public ExportedDelegate(object instance, Reflection.MethodInfo method) { } + + public virtual Delegate CreateDelegate(Type delegateType) { throw null; } + } + + public partial interface ICompositionElement + { + string DisplayName { get; } + + ICompositionElement Origin { get; } + } + + public enum ImportCardinality + { + ZeroOrOne = 0, + ExactlyOne = 1, + ZeroOrMore = 2 + } + + public partial class ImportDefinition + { + protected ImportDefinition() { } + + public ImportDefinition(Linq.Expressions.Expression> constraint, string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, Collections.Generic.IDictionary metadata) { } + + public ImportDefinition(Linq.Expressions.Expression> constraint, string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite) { } + + public virtual ImportCardinality Cardinality { get { throw null; } } + + public virtual Linq.Expressions.Expression> Constraint { get { throw null; } } + + public virtual string ContractName { get { throw null; } } + + public virtual bool IsPrerequisite { get { throw null; } } + + public virtual bool IsRecomposable { get { throw null; } } + + public virtual Collections.Generic.IDictionary Metadata { get { throw null; } } + + public virtual bool IsConstraintSatisfiedBy(ExportDefinition exportDefinition) { throw null; } + + public override string ToString() { throw null; } + } +} + +namespace System.ComponentModel.Composition.ReflectionModel +{ + public partial struct LazyMemberInfo + { + private object _dummy; + private int _dummyPrimitive; + public LazyMemberInfo(Reflection.MemberInfo member) { } + + public LazyMemberInfo(Reflection.MemberTypes memberType, Func accessorsCreator) { } + + public LazyMemberInfo(Reflection.MemberTypes memberType, params Reflection.MemberInfo[] accessors) { } + + public Reflection.MemberTypes MemberType { get { throw null; } } + + public override bool Equals(object obj) { throw null; } + + public Reflection.MemberInfo[] GetAccessors() { throw null; } + + public override int GetHashCode() { throw null; } + + public static bool operator ==(LazyMemberInfo left, LazyMemberInfo right) { throw null; } + + public static bool operator !=(LazyMemberInfo left, LazyMemberInfo right) { throw null; } + } + + public static partial class ReflectionModelServices + { + public static Primitives.ExportDefinition CreateExportDefinition(LazyMemberInfo exportingMember, string contractName, Lazy> metadata, Primitives.ICompositionElement origin) { throw null; } + + public static Primitives.ContractBasedImportDefinition CreateImportDefinition(LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, Collections.Generic.IEnumerable> requiredMetadata, Primitives.ImportCardinality cardinality, bool isRecomposable, bool isPreRequisite, CreationPolicy requiredCreationPolicy, Collections.Generic.IDictionary metadata, bool isExportFactory, Primitives.ICompositionElement origin) { throw null; } + + public static Primitives.ContractBasedImportDefinition CreateImportDefinition(LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, Collections.Generic.IEnumerable> requiredMetadata, Primitives.ImportCardinality cardinality, bool isRecomposable, CreationPolicy requiredCreationPolicy, Collections.Generic.IDictionary metadata, bool isExportFactory, Primitives.ICompositionElement origin) { throw null; } + + public static Primitives.ContractBasedImportDefinition CreateImportDefinition(LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, Collections.Generic.IEnumerable> requiredMetadata, Primitives.ImportCardinality cardinality, bool isRecomposable, CreationPolicy requiredCreationPolicy, Primitives.ICompositionElement origin) { throw null; } + + public static Primitives.ContractBasedImportDefinition CreateImportDefinition(Lazy parameter, string contractName, string requiredTypeIdentity, Collections.Generic.IEnumerable> requiredMetadata, Primitives.ImportCardinality cardinality, CreationPolicy requiredCreationPolicy, Collections.Generic.IDictionary metadata, bool isExportFactory, Primitives.ICompositionElement origin) { throw null; } + + public static Primitives.ContractBasedImportDefinition CreateImportDefinition(Lazy parameter, string contractName, string requiredTypeIdentity, Collections.Generic.IEnumerable> requiredMetadata, Primitives.ImportCardinality cardinality, CreationPolicy requiredCreationPolicy, Primitives.ICompositionElement origin) { throw null; } + + public static Primitives.ComposablePartDefinition CreatePartDefinition(Lazy partType, bool isDisposalRequired, Lazy> imports, Lazy> exports, Lazy> metadata, Primitives.ICompositionElement origin) { throw null; } + + public static Primitives.ContractBasedImportDefinition GetExportFactoryProductImportDefinition(Primitives.ImportDefinition importDefinition) { throw null; } + + public static LazyMemberInfo GetExportingMember(Primitives.ExportDefinition exportDefinition) { throw null; } + + public static LazyMemberInfo GetImportingMember(Primitives.ImportDefinition importDefinition) { throw null; } + + public static Lazy GetImportingParameter(Primitives.ImportDefinition importDefinition) { throw null; } + + public static Lazy GetPartType(Primitives.ComposablePartDefinition partDefinition) { throw null; } + + public static bool IsDisposalRequired(Primitives.ComposablePartDefinition partDefinition) { throw null; } + + public static bool IsExportFactoryImportDefinition(Primitives.ImportDefinition importDefinition) { throw null; } + + public static bool IsImportingParameter(Primitives.ImportDefinition importDefinition) { throw null; } + + public static bool TryMakeGenericPartDefinition(Primitives.ComposablePartDefinition partDefinition, Collections.Generic.IEnumerable genericParameters, out Primitives.ComposablePartDefinition specialization) { throw null; } + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.componentmodel.composition/4.5.0/system.componentmodel.composition.nuspec b/src/referencePackages/src/system.componentmodel.composition/4.5.0/system.componentmodel.composition.nuspec new file mode 100644 index 000000000..c76ed2cd6 --- /dev/null +++ b/src/referencePackages/src/system.componentmodel.composition/4.5.0/system.componentmodel.composition.nuspec @@ -0,0 +1,41 @@ + + + + System.ComponentModel.Composition + 4.5.0 + System.ComponentModel.Composition + Microsoft + microsoft,dotnetframework + false + https://github.com/dotnet/corefx/blob/master/LICENSE.TXT + https://dot.net/ + http://go.microsoft.com/fwlink/?LinkID=288859 + This namespace provides classes that constitute the core of the Managed Extensibility Framework, or MEF. + +Commonly Used Types: +System.ComponentModel.Composition.ChangeRejectedException +System.ComponentModel.Composition.CompositionContractMismatchException +System.ComponentModel.Composition.CompositionError +System.ComponentModel.Composition.CompositionException +System.ComponentModel.Composition.ExportAttribute +System.ComponentModel.Composition.ImportAttribute +System.ComponentModel.Composition.ImportCardinalityMismatchException +System.ComponentModel.Composition.Hosting.AggregateCatalog +System.ComponentModel.Composition.Hosting.ApplicationCatalog +System.ComponentModel.Composition.Hosting.AssemblyCatalog +System.ComponentModel.Composition.Hosting.CompositionContainer +System.ComponentModel.Composition.Primitives.ComposablePartException +System.ComponentModel.Composition.Primitives.ExportDefinition +System.ComponentModel.Composition.Primitives.ImportDefinition +System.ComponentModel.Composition.ReflectionModel.ReflectionModelServices + +30ab651fcb4354552bd4891619a0bdd81e0ebdbf +When using NuGet 3.x this package requires at least version 3.4. + https://go.microsoft.com/fwlink/?LinkID=799421 + © Microsoft Corporation. All rights reserved. + true + + + + + \ No newline at end of file