Microsoft.VisualStudio.Composition
The parts in the catalog.
The exports from parts in this catalog, indexed by contract name.
The types that are represented in this catalog.
Gets the set of parts that belong to the catalog.
Gets the parts that were added to the catalog via a class.
Merges this catalog with another one, including parts, discovery details and errors.
The catalog to be merged with this one.
The merged version of the catalog.
Merges this catalog with others, including parts, discovery details and errors.
The catalogs to be merged with this one.
The merged version of the catalog.
Initializes a new instance of the class.
Type of the part.
The metadata discovered on the part.
The exported types.
The exporting members.
The importing members.
The sharing boundary that this part is shared within.
The method to invoke after satisfying imports, if any.
The constructor to invoke to construct the part.
The importing arguments taken by the importing constructor. if the part cannot be instantiated.
The creation policy for this part.
A value indicating whether the part does not have an explicit sharing boundary, and therefore can obtain its sharing boundary based on its imports.
A sequence of extra assemblies to be added to the set for .
Gets a value indicating whether the sharing boundary must be inferred from what is imported.
This is when the part was discovered by MEFv1 attributes, since these attributes do not have
a way to convey a sharing boundary.
This is when the part is discovered by MEFv2 attributes, which have a SharedAttribute(string) that they can use
to specify the value.
When this is , the property is set to .
Gets the metadata for this part.
This metadata has no effect on composition, but may be useful if the host
wishes to filter a catalog based on part metadata prior to creating a composition.
Gets the list of methods to invoke after imports are satisfied.
Gets the types exported on the part itself.
Gets the exports found on members of the part (exporting properties, fields, methods.)
Gets a sequence of all exports found on this part (both the type directly and its members).
Gets the sequence of extra input assemblies that will be added to the
input assemblies for this .
Gets the list of parameters on the importing constructor,
or if the part cannot be instantiated.
Gets a sequence of all imports found on this part (both members and importing constructor).
Gets a map of this part's imports, and the exports which satisfy them.
Gets the set of sharing boundaries that this part must be instantiated within.
Removes satisfying exports coming from the given set of parts from this part's imports.
Find and removes any invalidated parts binded with an from the dictionary.
The parts whose exports should not be imported by this part.
The set of with the encountered errors.
Gets the catalog that backs this configuration.
This may be a smaller catalog than the one passed in to create this configuration
if invalid parts were removed.
Gets the composed parts, with exports satisfied, that make up this configuration.
Gets a map of metadata views and their matching providers.
Gets the compositional errors detected while creating this configuration that led to the removal
of parts from the catalog backing this configuration.
The errors are collected as a stack. The topmost stack element represents the first level of errors detected.
As errors are detected and parts removed to achieve a 'stable composition', each cycle of removing parts
and detecting additional errors gets a deeper element in the stack.
Therefore the 'root cause' of all failures is generally found in the topmost stack element.
Returns the configuration if it is valid, otherwise throws an exception describing any compositional failures.
This configuration.Thrown if is non-empty.
This method returns this so that it may be used in a 'fluent API' expression.
Detects whether a path exists between two nodes.
The type of node.
The node to start the search from.
The node to try to find a path to.
A function that enumerates the allowable steps to take from a given node.
A reusable collection to use as part of the algorithm to avoid allocations for each call.
If a path is found, a non-empty stack describing the path including (as the deepest element)
and excluding .
If a path is not found, an empty stack is returned.
Returns a map of those MEF parts that are missing explicit sharing boundaries, and the sharing boundary that can be inferred.
The part builders to build the map for.
A map of those parts with inferred boundaries where the key is the part and the value is its designated sharing boundary.
Constructs a map of all sharing boundaries and information about the boundaries that create them.
A set of part builders.
A map where the key is the name of a sharing boundary and the value is its metadata.
Gets or sets the part definition tracked by this instance.
Gets the sharing boundaries required to instantiate this part.
This is the union of the part's own explicitly declared sharing boundary
and the boundaries of all parts it imports (transitively).
Gets the set of parts that import this one.
Gets the set of parts imported by this one.
Gets the set of parent boundaries that MAY be present at the construction of this sharing boundary.
Gets the set of parent boundaries that ARE always present at the construction of this sharing boundary.
An exception thrown when failures occur during composition.
Initializes a new instance of the class.
Initializes a new instance of the class.
Initializes a new instance of the class.
Initializes a new instance of the class.
The errors that occurred during composition.
Initializes a new instance of the class.
Gets the compositional errors that occurred.
This collection is not serialized via the interface.
Refer to for a serialized form of these errors.
Gets a string representation of the compositional errors that are described in
(or were, before serialization dropped that data).
Gets a value indicating whether non-public types and members will be explored.
The Microsoft.Composition NuGet package ignores non-publics.
Gets the flags that select just public members or public and non-public as appropriate.
Creates a set of import constraints for an import site.
The importing member or parameter.
A set of import constraints.
Constructs concrete types for metadata view interfaces.
Assume TMetadataView is:
The class to be generated will look approximately like:
metadata;
private readonly IReadOnlyDictionary defaultMetadata;
private __Foo__MetadataViewProxy (IReadOnlyDictionary metadata, IReadOnlyDictionary defaultMetadata)
{
this.metadata = metadata;
this.defaultMetadata = defaultMetadata;
}
// Interface
public string RefTypeProperty
{
get
{
object value;
if (!this.metadata.TryGetValue("RefTypeProperty", out value))
value = this.defaultMetadata["RefTypeProperty"];
return value as string;
}
}
public bool ValueTypeProperty
{
get
{
object value;
if (!this.metadata.TryGetValue("RefTypeProperty", out value))
value = this.defaultMetadata["RefTypeProperty"];
return (bool)value;
}
}
public static object Create(IReadOnlyDictionary metadata, IReadOnlyDictionary defaultMetadata)
{
return new __Foo__MetadataViewProxy(metadata, defaultMetadata);
}
}
]]>
Gets the to use for generating a proxy for the given type.
The type of the interface to generate a proxy for.
The to use.
Creates an instance of a
for purposes of compatibility with the version of MEF found in the .NET Framework.
The to wrap.
A MEF "v1" shim.
Creates a catalog that exports an instance of .
The catalog to add the export to.
A catalog that includes .
Adds parts that allow MEF to work on .NET Framework platforms.
The catalog to add desktop support to.
The catalog that includes desktop support.
Extracts the ImportDefinition for the T in an ExportFactory{T} import, if applicable.
The ImportDefinition which may be an ExportFactory.
The import definition that describes the created part, or if the import definition isn't an ExportFactory.
Gets the resolver to use when deserializing.
Reads the specified number of bytes into a buffer.
This method will not return till exactly the requested number of bytes are read.
The buffer to write to.
The starting position in the buffer to write to.
The number of bytes to read.
Prepares the object for referential sharing in the serialization stream.
The value that may be serialized more than once.
if the object should be serialized; otherwise .
Gets an object that has already been deserialized, if available.
The type of deserialized object to retrieve.
Receives the ID of the object.
Receives the value of the object, if available.
if the caller should deserialize the object; if the object is in .
An equality comparer that provides a bit better recognition of objects for better interning.
Static factory methods for creating .NET Func{T} instances with fewer allocations in some scenarios.
These methods employ a neat trick where we take advantage of the fact that Delegate has a field to store
the instance on which to invoke the method. In general, that field is really just the first
argument to pass to the method. So if the method is static, we can use that field to store
something else as the first parameter.
So provided the valueFactory that the caller gave us is a reusable delegate to a static method
that takes one parameter that is a reference type, it means many Func{T} instances can be
constructed for different parameterized values while only incurring the cost of the Func{T} delegate itself
and no closure.
In most cases this is an insignificant difference. But if you're counting allocations for GC pressure,
this might be just what you need.
Creates a Func{T} from a delegate that takes one parameter
(for the cost of a delegate, but without incurring the cost of a closure).
The type of value to return from the function.
The value to return from the lazy.
The lazy instance.
Creates a delegate that invokes another delegate and casts the result to a given type.
The type to cast the result of to.
The delegate to chain execution to.
A delegate which, when invoked, will invoke .
Creates a delegate for a given delegate.
The function that produces the T value typed as .
The T type argument for the returned function's return type.
An instance of , typed as .
A base class for ExportProviders that wish to intercept queries for exports
to modify the query or the result.
The inner to which queries will be forwarded.
Initializes a new instance of the class.
The instance to forward queries to.
Forwards the exports query to the inner .
A description of the exports desired.
The resulting exports.
Throws .
The namespace that all DGML nodes appear in.
Creates a new DGML Node element.
The ID by which the node can be referenced in links. Used as label if label is null.
The node's caption.
May be empty, "Expanded" or "Collapsed" (for container nodes).
Adds categories to a DGML node or link.
The node or link to add categories to.
The categories to add.
The same node that was passed in. To enable "fluent" syntax.
Returns the discovered parts if no errors occurred, otherwise throws an exception describing any discovery failures.
This discovery result.Thrown if is non-empty.
This method returns this so that it may be used in a 'fluent API' expression.
Gets the metadata on the exported value.
Gets the exported value.
This may incur a value construction cost upon first retrieval.
Gets the member with the ExportAttribute applied. when the export is on the type itself.
Gets the member with the ExportAttribute applied. The return value is
when the export is on the type itself.
Gets a value indicating whether the exporting member is static.
A metadata template used by the generated code.
The metadata view providers available to this ExportProvider.
This field is lazy to avoid a chicken-and-egg problem with initializing it in our constructor.
A map of shared boundary names to their shared instances.
The value is a dictionary of types to their lazily-constructed instances and state.
A map of sharing boundary names to the ExportProvider that owns them.
The disposable objects whose lifetimes are shared and tied to a specific sharing boundary.
The disposable objects whose lifetimes are controlled by this instance.
Access to this collection is guarded by locking the collection instance itself.
The sharing boundaries that this ExportProvider creates new sharing boundaries for.
A cache for the method which has shown up on perf traces.
All access to this dictionary is guarded by a lock on this field.
The several stages of initialization that each MEF part goes through.
The MEF part has not yet been instantiated.
The MEF part's importing constructor is being invoked.
The MEF part has been instantiated.
The MEF part's importing members have been satisfied.
All MEF parts reachable from this one (through non-lazy import paths) have been satisfied.
The MEF part's OnImportsSatisfied method is being invoked.
The MEF part's OnImportsSatisfied method has been invoked (or would have if one was defined).
The OnImportsSatisfied methods on this and all MEF parts reachable from this one (through non-lazy import paths) have been invoked.
This part is ready for exposure to the user.
Gets a lazy that creates an instance of DelegatingExportProvider.
Releases the specified from the .
The export to release.
When non-shared parts implement they are referenced by this
until either the is disposed or the export is released by calling this method.When provided an for a shared part, this method does nothing.
Releases the specified instances from the .
The exports to release.
Gets a value indicating whether an import with the given characteristics must be initially satisfied
with a fully pre-initialized export.
if the import is a Lazy{T} style import; otherwise.
if the import appears in an importing constructor; otherwise.
if the export must have its imports transitively satisfied and OnImportsSatisfied methods invoked
prior to being exposed to the receiver; if the export can be partially initialized when the receiver
first observes it.
When implemented by a derived class, returns an of values that
satisfy the contract name of the specified .
The derived type is *not* expected to filter the exports based on the import definition constraints.
Gets the value from some member of a part.
The instance of the part to extract the value from. May be for static exports.
The member exporting the value. May be for exporting the type/instance itself.
The type of the importing member, with ImportMany collections and Lazy/ExportFactory stripped away.
The contractually exported value type.
The value of the member.
Adds a value to be disposed of when this or a parent ExportProvider is disposed of.
The part to be disposed.
The sharing boundary associated with the part.
May be null for non-shared parts, or the empty string for the default sharing scope.
The values are tracked in a set, so calling this repeatedly with the same value is harmless.
Gets a dictionary of metadata that describes all the default values supplied by a metadata view.
The metadata view type.
A dictionary of default metadata values.
Gets a provider that can create a metadata view of a specified type over a dictionary of metadata.
The type of metadata view required.
A metadata view provider.Thrown if no metadata view provider available is compatible with the type.
Gets the shared parts dictionary with a given sharing boundary name.
The name of the sharing boundary.
The dictionary containing parts and instances. Never null.Thrown if the dictionary for the given sharing boundary isn't found.
Gets a function that returns the exported value.
Gets a value indicating whether will produce a value that must be disposed of if is invoked.
A state machine that tracks an individual instance of a MEF part.
Every single instantiated MEF part (including each individual NonShared instance)
has an associated instance of this class to track its lifecycle from initialization to disposal.
An object that locks when the state machine is transitioning between states.
It is Pulsed after each change.
The sharing boundary that the MEF part this tracker is associated with belongs to.
A value indicating whether this instance has been disposed of.
Backing field for the property.
A lazy-initialized collection of all immediate imports (property and constructor) as they are satisfied
if by an exporting part that has not been fully initialized already.
It is nulled out upon reaching the final stage of initialization.
This collection is populated from the
and stages, each of which
occur on a single thread. It is then enumerated from
which *may* be invoked from multiple threads.
A lazily-initialized collection of all transitive non-shared parts that should be disposed with this non-shared part.
The non-shared part that imported this non-shared part.
The managed thread ID of the thread that is currently executing a particular step.
This is used to avoid deadlocking when we're executing a particular step
then while executing 3rd party code, that code calls us back on the same thread
to ask for an instance of the part.
In these circumstances we return a partially initialized value rather than
deadlock by trying to wait for a fully initialized one.
This matches MEFv1 and MEFv2 behavior.
Stores any exception captured during initialization.
Initializes a new instance of the class.
The ExportProvider that owns the lifetime and sharing boundaries for the part to be instantiated.
The sharing boundary the part belongs to.
Initializes a new instance of the class
that is non-shared and whose lifetime is tied to another non-shared part.
The ExportProvider that owns the lifetime and sharing boundaries for the part to be instantiated.
Gets or sets the instantiated part, if applicable and after it has been created. Otherwise .
Gets the level of initialization the MEF part has already undergone.
Gets the ExportProvider that owns the lifetime and sharing boundaries for the part to be instantiated.
Gets the type behind the part.
Gets the instance of the part after fully initializing it.
In the less common case that this method is called on top of a callstack where this same
part is actually *in progress* of executing any initialization step, this method will
simply return the value as-is rather than deadlock or throw.
This allows certain spec'd MEF behaviors to work.
Gets the instance of the part after instantiating it.
Importing properties may not have been satisfied yet.
Disposes of the MEF part if it is disposable.
Instantiates the MEF part and initializes it only so much as executing its importing constructor.
The instantiated MEF part.
Satisfies importing members on the MEF part itself.
Invokes the OnImportsSatisfied method on the part, if applicable.
If not applicable for this MEF part, this method should simply no-op.
Indicates that a MEF import was satisfied with a value that was not completely initialized
so that it can be initialized later (before this MEF part is allowed to be observed by the MEF client).
The part that has been imported by this part without full initialization.
Throws a indicating the part cannot be instantiated.
Invokes if this part has not already done so
and performs initial processing of the instance.
Invokes if this part has not already done so.
Invokes if this part has not already done so.
Executes the next step in this part's initialization.
The state to transition to. It must be no more than one state beyond the current one.
Checks whether the MEF part's next step in initialization is the specified one.
The step that is expected to be the next appropriate one.
if is one step beyond the current .
if this MEF part has advanced to or beyond that step already.
Thrown if this part is not yet ready for this step because that is a sign of a bug in the caller.
Advances this MEF part to the specified stage of initialization.
The initialization state to advance to.
If the specified state has already been reached, this method simply returns to the caller.
Advances this part and everything it imports (transitively) to the specified state.
The state to advance this and all related parts to.
Used in the recursive call to avoid loops leading to stack overflows.
It also identifies all related parts so they can be "stamped" as being transitively initialized.
This MUST be for non-recursive calls.
Indicates that a new stage of initialization has been reached.
The new state.
if the new state actually represents an advancement over the prior state.
Blocks the calling thread until this Part reaches the required initialization stage.
The stage required by the caller.
Rethrows an exception experienced while initializing this MEF part if there is one.
Throw an if this instance has been disposed of previously.
Records that a failure occurred in initializing this part
and advances this Part to its .
The failure.
Supplies the functionality for loading assemblies.
Implementations MUST be thread-safe and should be very fast for assemblies
that have already been loaded.
Loads an assembly with the specified name and path.
The full name of the assembly, as might be found in the property.
The path to the assembly to load. May be null.
The loaded assembly. Never .May be thrown if the assembly cannot be found or fails to load.
Loads an assembly with the specified name.
The assembly name.
The loaded assembly. Never .May be thrown if the assembly cannot be found or fails to load.
Provides metadata view proxy instances for arbitrary metadata view interfaces.
Gets a value indicating whether this provider can create a metadata proxy for a given type.
The type of the required proxy.
if the provider can create a proxy for this type. Otherwise false.
Creates a metadata view that acts as a strongly-typed accessor
to a metadata dictionary.
The metadata dictionary. Never null.
The metadata dictionary of defaults, to be used when is missing a key. Is never null.
The type of metadata view to create.
The proxy instance.
Initializes a new instance of the class
based on MEF v2 attributes.
Initializes a new instance of the class
based on MEF v1 attributes.
Gets the sharing boundaries created when the export factory is used.
Initializes a new instance of the class
to represent an importing member.
Initializes a new instance of the class
to represent a parameter in an importing constructor.
Gets the definition for this import.
Gets the member this import is found on. Null for importing constructors.
Gets the member this import is found on. Null for importing constructors.
Gets the actual type of the variable or member that will be assigned the result.
This includes any Lazy, ExportFactory or collection wrappers.
Never null.
Gets the actual type of the variable or member that will be assigned the result.
This includes any Lazy, ExportFactory or collection wrappers.
Never null.
Gets the type of the member, with the ImportMany collection and Lazy/ExportFactory stripped off, when present.
Gets the type of the member, with the ImportMany collection and Lazy/ExportFactory stripped off, when present.
Initializes a new instance of the class.
The metadata names and requirements.
A resolver to use when handling objects. Must not be null unless is empty.
Gets the to use.
May be if is empty.
Creates a constraint for the specified metadata type.
The metadata type.
The assembly loader.
A constraint to match the metadata type.
The direction of value translation for this instance.
The underlying metadata, which may be partially translated since value translation may choose
to persist the translated result.
The metadata wrapper will replace instances of Type with TypeRef, and other such serialization substitutions.
The metadata wrapper will reverse the operation, restoring Type where TypeRef is found, etc.
Attempts to get the types of metadata values without loading the associated assemblies.
Medatadata dictionary to retrieve values from.
key for the metadata value.
Type resolver to use.
out param for the TypeRef associated with the given key.
Either a TypeRef representing the type of the underlying value or a TypeRef[] if the underlying value was an array.
Static factory methods for creating .NET Lazy{T} instances.
Gets a value indicating whether a type represents either a
or a (as opposed to not a Lazy type at all).
The type to be tested.
if is some Lazy type; otherwise.
Gets a value indicating whether a type represents either a
or a (as opposed to not a Lazy type at all).
The type to be tested.
if is some Lazy type; otherwise.
Creates a factory that takes a Func{object} and object-typed metadata
and returns a strongly-typed Lazy{T, TMetadata} instance.
The type of values created by the Func{object} value factories. Null is interpreted to be typeof(object).
The type of metadata passed to the lazy factory. Null is interpreted to be typeof(IDictionary{string, object}).
A function that takes a Func{object} value factory and metadata, and produces a Lazy{T, TMetadata} instance.
The bits set on metadata tokens based on type of token.
This can be used in the future to remove these MSBs when serializing the metadata tokens
in order to make them more compressible by virtue of their being significantly smaller
numbers after removing the leading byte.
These come from .
Supports metadata views that are concrete classes with a public default constructor
and properties with set accessors.
Supports metadata views that are concrete classes with a public constructor
that accepts the metadata dictionary as its only parameter.
A nullable boolean value with atomic reads and writes.
The type has two fields which prevent it being initialized or copied atomically as a single "word".
This type has just one field (which it can do since we specialize in storing values), so it is just one word and therefore atomic.
A tri-state backing field for the property. 0 means not computed, -1 means false and 1 means true.
We use a tri-state field to support lock-free atomic writes.
Initializes a new instance of the struct.
The initial value of the boolean.
Wraps a boolean value in a struct.
The boolean value to wrap.
Gets a value indicating whether the boolean value has been computed.
Gets or sets a value indicating whether the boolean value is .
A constraint that may be included in an that only matches
exports whose parts have a compatible .
The constraint to include in the when a shared part is required.
The constraint to include in the when a non-shared part is required.
Gets a dictionary of metadata to include in an to signify the exporting part's CreationPolicy.
The of the exporting .
A dictionary of metadata.
Creates a set of constraints to apply to an import given its required part creation policy.
Creates an aggregate instance that delegates to a series of other part discovery extensions.
The is used.
Creates an aggregate instance that delegates to a series of other part discovery extensions.
The that the aggregate PartDiscovery instance should use.
The discovery extensions to use. In some cases, extensions defined earlier in the list are preferred.
The aggregate instance.
Reflects on a type and returns metadata on its role as a MEF part, if applicable.
The type to reflect over.
A new instance of if
represents a MEF part; otherwise .
Reflects over an assembly and produces MEF parts for every applicable type.
The assembly to search for MEF parts.
The cancellation token.
A set of generated parts.
Reflects over a set of assemblies and produces MEF parts for every applicable type.
The assemblies to search for MEF parts.
An optional way to receive progress updates on how discovery is progressing.
The cancellation token.
A set of generated parts.
Reflects over a set of assemblies and produces MEF parts for every applicable type.
The paths to assemblies to search for MEF parts.
An optional way to receive progress updates on how discovery is progressing.
The cancellation token.
A set of generated parts.
Throws an exception if certain basic rules for an importing member or parameter are violated.
The importing member or importing parameter.
A value indicating whether the import is an ImportMany.
Throws an exception if certain basic rules for an exporting member are violated.
The exporting member (or type).
Creates an array that contains the contents of a prior array (if any) and one additional element.
The previous version of the array. May be . This will not be modified by this method.
The value to add to the array. May be .
The element type for the array, if it is created fresh. May be .
A new array.
Gets the types to consider for MEF parts.
The assembly to read.
A sequence of types.
Reflects on a type and returns metadata on its role as a MEF part, if applicable.
The type to reflect over.
A value indicating whether this type was explicitly requested for inclusion in the catalog.
A new instance of if
represents a MEF part; otherwise .
Checks whether an import many collection is creatable.
Checks whether an import many collection is creatable.
The value from ImportingSiteType.
The value from ImportingSiteTypeWithoutCollection.
if the collection is creatable; otherwise.
Gets the Type of the interface that serves as a metadata view for a given import.
The type of the importing member or parameter, without its ImportMany collection if it had one.
The metadata view, , or if there is none.
An exception that may be thrown during MEF part discovery.
Initializes a new instance of the class.
Initializes a new instance of the class.
Initializes a new instance of the class.
Initializes a new instance of the class.
Gets or sets the path to the assembly involved in the failure.
Gets or sets the type where .NET Reflection failed.
Supports metadata views that are any type that
could be assigned to, including and .
Describes how compatible an export and import site pair are.
Static analysis of the types involved guarantee that assignment will succeed at runtime.
For example, a property typed as string will always export a value assignable to an import of type string.
Static analysis cannot definitively say whether assignment at runtime will succeed.
For example, a property typed as "object" that exports IFoo may return an IFoo object at runtime (success),
or it may return a System.String object (failure).
Static analysis of the types involved guarantee that assignment will fail at runtime.
For example, a property typed as string will never export a value assignable to an import of type int.
Creates a delegate for a given delegate.
The T type argument for the returned function's return type.
The function that produces the T value typed as .
An instance of , typed as .
Produces a sequence of this type, and each of its base types, in order of ascending the type hierarchy.
Returns a type with generic type arguments supplied by a constructed type that is derived from
the supplied generic type definition.
The generic type definition to return a constructed type from.
A constructed type that is, or derives from, .
A constructed type.
Extracts generic type arguments from a constructed type that are necessary to close a generic type definition.
A generic type definition.
A closed type from which may be obtained generic type arguments.
The type argument necessary to construct the closed type.
Gets the string to display in the debugger watch window for this value.
The metadata token for this member if read from a persisted assembly.
We do not store metadata tokens for members in dynamic assemblies because they can change till the Type is closed.
The that this value was instantiated with,
or cached later when a metadata token was resolved.
Initializes a new instance of the class.
Gets a value indicating whether this instance is equivalent to another one,
based only on metadata that describes this member, assuming the declaring types are equal.
The instance to compare with. This may be assumed to always be an instance of the same type.
if the local metadata on the member are equal; otherwise.
Gets the string to display in the debugger watch window for this value.
Gets the string to display in the debugger watch window for this value.
A cache behind the property.
Gets a 0-based index describing which parameter in the method this references.
Gets the string to display in the debugger watch window for this value.
The metadata token for this member if read from a persisted assembly.
We do not store metadata tokens for members in dynamic assemblies because they can change till the Type is closed.
The metadata token for this member if read from a persisted assembly.
We do not store metadata tokens for members in dynamic assemblies because they can change till the Type is closed.
Tests whether we can safely use fast reflection on the assembly that defines the given type.
The reference to a type that needs to be reflected over.
Receives the manifest of the assembly that defines the type. May be when fast reflection must not be used.
if it is safe to use fast reflection; otherwise.
Determines whether the metadata tokens stored in a
can be considered reliable considering the currently loaded assembly manifest.
The that may have been cached, possibly against a different build of the assembly.
The manifest from the assembly that defines the referenced type.
if the currently loaded assembly is the same build as the one that was cached.
Gives a dynamic assembly the ability to skip CLR visibility checks,
allowing the assembly to access private members of another assembly.
The constructor.
The constructor.
The property.
The assembly builder that is constructing the dynamic assembly.
The module builder for the default module of the .
This is where the special attribute will be defined.
The set of assemblies that already have visibility checks skipped for.
The constructor on the special attribute to reference for each skipped assembly.
Initializes a new instance of the class.
The builder for the dynamic assembly.
The builder for the default module defined by .
Gets the set of assemblies that a generated assembly must be granted the ability to skip visiblity checks for
in order to access the specified type.
The type which may be internal.
The set of names of assemblies to skip visibility checks for.
Add attributes to a dynamic assembly so that the CLR will skip visibility checks
for the assemblies with the specified names.
The names of the assemblies to skip visibility checks for.
Add an attribute to a dynamic assembly so that the CLR will skip visibility checks
for the assembly with the specified name.
The name of the assembly to skip visibility checks for.
Gets the constructor to the IgnoresAccessChecksToAttribute, generating the attribute if necessary.
The constructor to the IgnoresAccessChecksToAttribute.
Defines the special IgnoresAccessChecksToAttribute type in the .
The generated attribute type.
Gets the string to display in the debugger watch window for this value.
Backing field for the lazily initialized property.
A lazily initialized cache of the result of calling .
Backing field for .
Backing field for .
Gets the full name of the type represented by this instance.
When representing a generic type, this is the full name of the generic type definition.
Gets a value indicating whether or not this TypeRef is shallow. Shallow TypeRefs do not have a defined list of base types.
Gets the full list of base types and interfaces for this instance.
This list will only be populated if this instance was created with shallow set to false.
The collection is ordered bottom-up for types with the implemented interfaces appended at the end.
Gets the resolved type.
Gets a TypeRef that represents a given Type instance.
The Type to represent. May be to get a result.
The resolver to use to reconstitute or derivatives later.
An instance of TypeRef if is not ; otherwise .
Checks if the type represented by the given TypeRef can be assigned to the type represented by this instance.
The assignability check is done by traversing all the base types and interfaces of the given TypeRef to check
if any of them are equal to this instance. Should that fail, the CLR is asked to check for assignability
which will trigger an assembly load.
TypeRef to compare to.
true if the given TypeRef can be assigned to this instance, false otherwise.
Compares for type equality, ignoring whether or not the TypeRef is shallow.
TypeRef to compare to.
true if the TypeRefs represent the same type, false otherwise.
Flags that describe a type.
No flags.
Identifies an array.
Identifies a value type (as opposed to a reference type).
Metadata about a that is used to determine if
two assemblies are equivalent.
Initializes a new instance of the class.
The assembly name. Cannot be null.
The MVID of the ManifestModule of the assembly.
Gets the assembly's full name.
Gets the MVID for the assembly's manifest module. This is a unique identifier that represents individual
builds of an assembly.
Gets the metadata from an assembly at the specified path.
The path to the assembly to read metadata from.
The assembly name, if already known; otherwise .
The assembly metadata.Thrown if does not refer to an existing file.
Gets the metadata from an assembly.
The assembly to read metadata from.
An optional that may be important for dynamic assemblies to find their CodeBase.
The assembly metadata.
Gets the MVID for an assembly with the specified path.
The assembly to get the MVID from.
The MVID.
A instance that may be used where customizing assembly loading is not necessary.
A cache of TypeRef instances that correspond to Type instances.
This is for efficiency to avoid duplicates where convenient to do so.
It is not intended as a guarantee of reference equality across equivalent TypeRef instances.
A map of assemblies loaded by VS MEF and their metadata.
Gets identity and version metadata for an assembly with the given ,
if that assembly has been loaded with this .
The name of the assembly to look up.
Receives the metadata from the assembly, if it has been loaded by this ; otherwise .
if the metadata was found; otherwise.
Determines the strong identity of an assembly and stores it.
The loaded assembly.
An optional that may be important for dynamic assemblies to find their CodeBase.
The identity determined for this assembly.
Determines the strong identity of an assembly and stores it.
The loaded assembly.
An optional that may be important for dynamic assemblies to find their CodeBase.
The identity determined for this assembly.
An that wraps another, and notifies its creator
whenever an assembly is loaded.
The that created this instance.
The inner to use.
Initializes a new instance of the class.
The that created this instance.
The inner to use.
Gets the importing member. May be empty if the import site is an importing constructor parameter.
Gets the importing parameter. May be empty if the import site is an importing field or property.
Gets the sharing boundaries created when the export factory is used.
Gets the type of the member, with the ImportMany collection and Lazy/ExportFactory stripped off, when present.
BindingFlags that find members declared exactly on the receiving type, whether they be public or not, instance or static.
Gets the constructed type (non generic type definition) for a part.
Gets the type that backs this part.
A typical .NET Framework implementation of the interface.
A cache of assembly names to loaded assemblies.
A strongly-typed resource class, for looking up localized strings, etc.
Returns the cached ResourceManager instance used by this class.
Overrides the current thread's CurrentUICulture property for all
resource lookups using this strongly typed resource class.
Looks up a localized string similar to All values must be non-null..
Looks up a localized string similar to AssemblyName must be set first..
Looks up a localized string similar to Cannot be empty..
Looks up a localized string similar to This instance is an import and cannot be directly disposed..
Looks up a localized string similar to {0}: cannot import exported value from {1} because the exporting part cannot be instantiated. Is it missing an importing constructor?.
Looks up a localized string similar to Collection must be public with a public default constructor when used with an [ImportingConstructor]..
Looks up a localized string similar to Collection type must derive from ICollection<T>..
Looks up a localized string similar to Compilation errors occurred..
Looks up a localized string similar to Instantiated part(s) threw exception(s) from IDisposable.Dispose()..
Looks up a localized string similar to Custom import sources are not yet supported..
Looks up a localized string similar to Member "{0}" contains metadata attributes with an identical property name. Property name: "{1}"..
Looks up a localized string similar to Errors occurred during discovery..
Looks up a localized string similar to Errors exist in the composition..
Looks up a localized string similar to Error occurred while scanning member: "{0}".
Looks up a localized string similar to Import "{0}" could not be satisfied..
Looks up a localized string similar to There should be exactly one entry for every import..
Looks up a localized string similar to An exception was thrown while initializing part "{0}"..
Looks up a localized string similar to {0}: expected exactly 1 export matching constraints:
{1}but found {2}.{3}.
Looks up a localized string similar to {0}: expected 1 or 0 exports matching constraints:
{1}but found {2}.{3}.
Looks up a localized string similar to Value exported from "{0}" cannot be assigned to import site "{1}"..
Looks up a localized string similar to Exporting property "{0}" on part "{1}" has no getter..
Looks up a localized string similar to {0}: Export of ExportProvider is not allowed..
Looks up a localized string similar to Exports on members not allowed when the declaring type is generic..
Looks up a localized string similar to Failed to generate embeddable types..
Looks up a localized string similar to Failed to find a stable composition..
Looks up a localized string similar to Failure while scanning type "{0}"..
Looks up a localized string similar to The import constraint type {0} is not supported..
Looks up a localized string similar to Importing constructor has an unsupported parameter type for an [ImportMany]. Only T[] and IEnumerable<T> are supported..
Looks up a localized string similar to Importing property "{0}" on part "{1}" has no setter..
Looks up a localized string similar to The type {0} does not appear to be a collection as required for ImportManyAttribute..
Looks up a localized string similar to {0}: imports that use generic type parameters are not supported..
Looks up a localized string similar to This instance is empty..
Looks up a localized string similar to {0} is expected only on imports of System.Composition.ExportFactory<T> or System.Composition.ExportFactory<T, TMetadata>, but found {1} instead..
Looks up a localized string similar to IsExportFactory is expected to be true..
Looks up a localized string similar to {0}: is not assignable from exported MEF value {1}..
Looks up a localized string similar to Loop between non-shared parts..
Looks up a localized string similar to Loop involving ImportingConstructor argument and all non-lazy imports..
Looks up a localized string similar to Member "{0}" contains both ImportAttribute and ImportManyAttribute..
Looks up a localized string similar to {0}: metadata type {1} is not supported..
Looks up a localized string similar to No importing constructor..
Looks up a localized string similar to No importing constructor found..
Looks up a localized string similar to No member to satisfy..
Looks up a localized string similar to Not a type spec..
Looks up a localized string similar to Not a closed form of the other..
Looks up a localized string similar to This is not a generic type definition..
Looks up a localized string similar to Not initialized..
Looks up a localized string similar to OnImportsSatisfied method should take no parameters..
Looks up a localized string similar to Only supported on write operations..
Looks up a localized string similar to Inappropriate request for export from part that belongs to another sharing boundary..
Looks up a localized string similar to Part discovery failed at member {0}..
Looks up a localized string similar to This part ({0}) cannot be instantiated..
Looks up a localized string similar to Part is not shared..
Looks up a localized string similar to Readable stream required..
Looks up a localized string similar to Unable to construct MEF part "{0}" due to an unresolvable recursive construction request..
Looks up a localized string similar to ReflectionTypeLoadException while enumerating types in assembly "{0}". Results will be incomplete..
Looks up a localized string similar to {0}: expected exactly 1 export matching constraints:
{1} but the matching part has been invalidated..
Looks up a localized string similar to Scanning MEF assemblies....
Looks up a localized string similar to The type {0} already belongs to the catalog as a different ComposablePartDefinition..
Looks up a localized string similar to Type must be the one that defines memberInfo or a derived type..
Looks up a localized string similar to {0}.{1} (in {2}).
Looks up a localized string similar to The type {0} is an unsupported type of metadata view..
Looks up a localized string similar to Unable to determine the primary sharing boundary for MEF part "{0}"..
Looks up a localized string similar to Unable to enumerate types in assembly "{0}"..
Looks up a localized string similar to Unable to instantiate custom import collection type {0}. Try initializing {1} with a new instance of this type in your importing constructor..
Looks up a localized string similar to Unable to load assembly "{0}" for scanning..
Looks up a localized string similar to Unexpected constraint type: {0}..
Looks up a localized string similar to Unexpected member type {0}..
Looks up a localized string similar to Expected {0} export(s) with contract name "{1}" but found {2} after applying applicable constraints..
Looks up a localized string similar to This shared part is in state {0} but must be in state {1} for this operation..
Looks up a localized string similar to Unresolvable metadata token..
Looks up a localized string similar to Unsupported format: {0}..
Looks up a localized string similar to Writable stream required..
Looks up a localized string similar to Wrong length..
Looks up a localized string similar to Wrong type..
Creates an that is guaranteed to have its property set.
The path to the assembly to get the name for.
An initialized instance.Fwt19K7PW21kPlm3g5U6nUa5c3Vvy7jzz/rbOY2bo1g=RTFArCs42cUC72NJ7McFId7PedJjNsGIJLS+uUwSwH8MKU5VSyd0xSyrDC1qplE6c5/mWo2b9PYeUKCIV3ykjbWap8AeV5JU0rBrDj7+N3o9Nc0M4vqnZYbTEjjjV3hIjvpEfBH9RJxsw0Du+WFAuseXj5PUtmXJtiX7J2q2wzo2kxFgTsHczTR17oy59K7NlwGjUTD0bAPlQOcF3vwYz5QEJqvnnaO3xsfcLOmx1QB9dTfcQq+Any53azxxyBWFWPiUYvS5yPlAJ472U771KwHINwQ7jCi19VpFloHqnxxLcMj7oowKidBrWcmoW6NPzNTjW16g4kLrAstMhhXAyw==3QiojSOiARVrryVJn+lnTiamZiMGLORuwCQ+VG3C+rbAvhATw269+qRRqNW7FKed50chWJ53KDIPBStHfIy5cNJYHsQw6+4InH9szgRVqn7/50i8MyRTT+VtNwxf9daGddq0hahpZvjuOnEY0wxQaTEQmWRnXWZUQY4r28tHiNVYEw9U7wHXwWEHvNn4ZlkJGEf5VpgCvr1v9fmzu4x2sV0zQsSyAVtOxfDwY1HMBcccn23tphweIdS+FNDn2vh1/2kREO0qmGc+fbFzNskjn72MiI56kjvNDRgWs+Q78yBvPCdPgTYTrto5eg33Ko2ELNR/zzEkCCuhO5Vw10qV8w==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