Struct Resolution 

pub struct Resolution<'a> {
    pub assembly: Option<Assembly<'a>>,
    pub assembly_references: Vec<ExternalAssemblyReference<'a>>,
    pub entry_point: Option<EntryPoint>,
    pub exported_types: Vec<ExportedType<'a>>,
    pub field_references: Vec<ExternalFieldReference<'a>>,
    pub files: Vec<File<'a>>,
    pub manifest_resources: Vec<ManifestResource<'a>>,
    pub method_references: Vec<ExternalMethodReference<'a>>,
    pub module: Module<'a>,
    pub module_references: Vec<ExternalModuleReference<'a>>,
    pub type_definitions: Vec<TypeDefinition<'a>>,
    pub type_references: Vec<ExternalTypeReference<'a>>,
}

A structured representation of a .NET DLL file’s metadata, according to the ECMA-335 standard.

Resolution is the top-level data structure of dotnetdll. By working with a Resolution instance, you can access all the details of the assembly, modules, types, and other members defined or referenced in a DLL.

Fields

assembly: Option<Assembly<'a>>

Assembly metadata, if the DLL defines an assembly.

assembly_references: Vec<ExternalAssemblyReference<'a>>

All external assemblies referenced by the DLL.

entry_point: Option<EntryPoint>

Entry point for the DLL, if one is defined.

exported_types: Vec<ExportedType<'a>>

Types that this assembly exports, but are not defined in the assembly’s main module.

field_references: Vec<ExternalFieldReference<'a>>

References to fields defined in external assemblies.

files: Vec<File<'a>>

File resources that the DLL references or contains.

manifest_resources: Vec<ManifestResource<'a>>

Resources embedded within the DLL.

method_references: Vec<ExternalMethodReference<'a>>

References to methods defined in external assemblies.

module: Module<'a>

The module defined by the DLL. Note that this is a distinct object from an assembly.

module_references: Vec<ExternalModuleReference<'a>>

References to modules defined in external assemblies.

type_definitions: Vec<TypeDefinition<'a>>

Types defined within the DLL.

type_references: Vec<ExternalTypeReference<'a>>

References to types defined in external assemblies.

Implementations

impl<'a> Resolution<'a>

pub fn new(module: Module<'a>) -> Self

Creates a new Resolution with a single module.

Every .NET DLL contains exactly one module (ECMA-335, II.22.30).

By default, a special <Module> type is created, as required by the ECMA-335 standard (II.22.37).

pub fn parse(bytes: &'a [u8], opts: ReadOptions) -> Result<Self>

Parses a .NET DLL from a byte slice.

This method first parses the PE (Portable Executable) file structure, then resolves the CLI metadata into a high-level Resolution struct.

pub fn write(&self, opts: WriteOptions) -> Result<Vec<u8>>

Writes the Resolution to a byte vector in the .NET PE format.

pub fn set_entry_point(&mut self, entry_point: impl Into<EntryPoint>)

Sets the entry point for the DLL.

impl<'a> Resolution<'a>

pub fn push_assembly_reference( &mut self, val: ExternalAssemblyReference<'a>, ) -> AssemblyRefIndex

Adds a new item to Resolution::assembly_references and returns its index.

pub fn assembly_reference_index(&self, index: usize) -> Option<AssemblyRefIndex>

Returns the index corresponding to the raw index in Resolution::assembly_references, if it exists.

pub fn enumerate_assembly_references( &self, ) -> impl Iterator<Item = (AssemblyRefIndex, &ExternalAssemblyReference<'a>)>

Iterates through all items in Resolution::assembly_references with their corresponding typed indices.

impl<'a> Resolution<'a>

pub fn push_exported_type(&mut self, val: ExportedType<'a>) -> ExportedTypeIndex

Adds a new item to Resolution::exported_types and returns its index.

pub fn exported_type_index(&self, index: usize) -> Option<ExportedTypeIndex>

Returns the index corresponding to the raw index in Resolution::exported_types, if it exists.

pub fn enumerate_exported_types( &self, ) -> impl Iterator<Item = (ExportedTypeIndex, &ExportedType<'a>)>

Iterates through all items in Resolution::exported_types with their corresponding typed indices.

impl<'a> Resolution<'a>

pub fn push_field_reference( &mut self, val: ExternalFieldReference<'a>, ) -> FieldRefIndex

Adds a new item to Resolution::field_references and returns its index.

pub fn field_reference_index(&self, index: usize) -> Option<FieldRefIndex>

Returns the index corresponding to the raw index in Resolution::field_references, if it exists.

pub fn enumerate_field_references( &self, ) -> impl Iterator<Item = (FieldRefIndex, &ExternalFieldReference<'a>)>

Iterates through all items in Resolution::field_references with their corresponding typed indices.

impl<'a> Resolution<'a>

pub fn push_file(&mut self, val: File<'a>) -> FileIndex

Adds a new item to Resolution::files and returns its index.

pub fn file_index(&self, index: usize) -> Option<FileIndex>

Returns the index corresponding to the raw index in Resolution::files, if it exists.

pub fn enumerate_files(&self) -> impl Iterator<Item = (FileIndex, &File<'a>)>

Iterates through all items in Resolution::files with their corresponding typed indices.

impl<'a> Resolution<'a>

pub fn push_method_reference( &mut self, val: ExternalMethodReference<'a>, ) -> MethodRefIndex

Adds a new item to Resolution::method_references and returns its index.

pub fn method_reference_index(&self, index: usize) -> Option<MethodRefIndex>

Returns the index corresponding to the raw index in Resolution::method_references, if it exists.

pub fn enumerate_method_references( &self, ) -> impl Iterator<Item = (MethodRefIndex, &ExternalMethodReference<'a>)>

Iterates through all items in Resolution::method_references with their corresponding typed indices.

impl<'a> Resolution<'a>

pub fn push_module_reference( &mut self, val: ExternalModuleReference<'a>, ) -> ModuleRefIndex

Adds a new item to Resolution::module_references and returns its index.

pub fn module_reference_index(&self, index: usize) -> Option<ModuleRefIndex>

Returns the index corresponding to the raw index in Resolution::module_references, if it exists.

pub fn enumerate_module_references( &self, ) -> impl Iterator<Item = (ModuleRefIndex, &ExternalModuleReference<'a>)>

Iterates through all items in Resolution::module_references with their corresponding typed indices.

impl<'a> Resolution<'a>

pub fn push_type_definition(&mut self, val: TypeDefinition<'a>) -> TypeIndex

Adds a new item to Resolution::type_definitions and returns its index.

pub fn type_definition_index(&self, index: usize) -> Option<TypeIndex>

Returns the index corresponding to the raw index in Resolution::type_definitions, if it exists.

pub fn enumerate_type_definitions( &self, ) -> impl Iterator<Item = (TypeIndex, &TypeDefinition<'a>)>

Iterates through all items in Resolution::type_definitions with their corresponding typed indices.

impl<'a> Resolution<'a>

pub fn push_type_reference( &mut self, val: ExternalTypeReference<'a>, ) -> TypeRefIndex

Adds a new item to Resolution::type_references and returns its index.

pub fn type_reference_index(&self, index: usize) -> Option<TypeRefIndex>

Returns the index corresponding to the raw index in Resolution::type_references, if it exists.

pub fn enumerate_type_references( &self, ) -> impl Iterator<Item = (TypeRefIndex, &ExternalTypeReference<'a>)>

Iterates through all items in Resolution::type_references with their corresponding typed indices.

impl<'a> Resolution<'a>

pub fn push_field(&mut self, parent: TypeIndex, field: Field<'a>) -> FieldIndex

Adds a new item to the fields of the TypeDefinition at parent and returns its index.

pub fn field_index(&self, parent: TypeIndex, index: usize) -> Option<FieldIndex>

Returns the index corresponding to the raw index in the parent TypeDefinition’s fields, if it exists.

pub fn enumerate_fields( &self, parent: TypeIndex, ) -> impl Iterator<Item = (FieldIndex, &Field<'a>)>

Enumerates all items in the fields of the TypeDefinition at parent with their indices.

impl<'a> Resolution<'a>

pub fn push_property( &mut self, parent: TypeIndex, property: Property<'a>, ) -> PropertyIndex

Adds a new item to the properties of the TypeDefinition at parent and returns its index.

pub fn property_index( &self, parent: TypeIndex, index: usize, ) -> Option<PropertyIndex>

Returns the index corresponding to the raw index in the parent TypeDefinition’s properties, if it exists.

pub fn enumerate_properties( &self, parent: TypeIndex, ) -> impl Iterator<Item = (PropertyIndex, &Property<'a>)>

Enumerates all items in the properties of the TypeDefinition at parent with their indices.

impl<'a> Resolution<'a>

pub fn push_event(&mut self, parent: TypeIndex, event: Event<'a>) -> EventIndex

Adds a new item to the events of the TypeDefinition at parent and returns its index.

pub fn event_index(&self, parent: TypeIndex, index: usize) -> Option<EventIndex>

Returns the index corresponding to the raw index in the parent TypeDefinition’s events, if it exists.

pub fn enumerate_events( &self, parent: TypeIndex, ) -> impl Iterator<Item = (EventIndex, &Event<'a>)>

Enumerates all items in the events of the TypeDefinition at parent with their indices.

impl<'a> Resolution<'a>

pub fn push_method( &mut self, parent: TypeIndex, method: Method<'a>, ) -> MethodIndex

Adds a new method to a type and returns its index.

pub fn method_index( &self, parent: TypeIndex, index: usize, ) -> Option<MethodIndex>

Returns the index corresponding to the raw index of a method in a type’s methods list, if it exists.

pub fn enumerate_methods( &self, parent: TypeIndex, ) -> impl Iterator<Item = (MethodIndex, &Method<'a>)>

Iterates through all methods defined directly on a type with their corresponding typed indices.

pub fn set_property_getter( &mut self, property: PropertyIndex, method: Method<'a>, ) -> MethodIndex

Sets the getter method of a property.

pub fn property_getter_index( &self, property: PropertyIndex, ) -> Option<MethodIndex>

Returns the index of a property’s getter method, if it exists.

pub fn set_property_setter( &mut self, property: PropertyIndex, method: Method<'a>, ) -> MethodIndex

Sets the setter method of a property.

pub fn property_setter_index( &self, property: PropertyIndex, ) -> Option<MethodIndex>

Returns the index of a property’s setter method, if it exists.

pub fn push_property_other( &mut self, property: PropertyIndex, method: Method<'a>, ) -> MethodIndex

Adds an “other” method to a property and returns its index.

pub fn property_other_index( &self, property: PropertyIndex, index: usize, ) -> Option<MethodIndex>

Returns the index of an “other” method of a property, if it exists.

pub fn event_add_index(&self, event: EventIndex) -> MethodIndex

Returns the index of an event’s add listener method.

pub fn event_remove_index(&self, event: EventIndex) -> MethodIndex

Returns the index of an event’s remove listener method.

pub fn set_event_raise( &mut self, event: EventIndex, method: Method<'a>, ) -> MethodIndex

Sets the raise method of an event.

pub fn event_raise_index(&self, event: EventIndex) -> Option<MethodIndex>

Returns the index of an event’s raise method, if it exists.

pub fn push_event_other( &mut self, event: EventIndex, method: Method<'a>, ) -> MethodIndex

Adds an “other” method to an event and returns its index.

pub fn event_other_index( &self, event: EventIndex, index: usize, ) -> Option<MethodIndex>

Returns the index of an “other” method of an event, if it exists.

Trait Implementations

impl<'a> Clone for Resolution<'a>

fn clone(&self) -> Resolution<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Resolution<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Index<AssemblyRefIndex> for Resolution<'a>

type Output = ExternalAssemblyReference<'a>

The returned type after indexing.

fn index(&self, index: AssemblyRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<EventIndex> for Resolution<'a>

type Output = Event<'a>

The returned type after indexing.

fn index(&self, index: EventIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<ExportedTypeIndex> for Resolution<'a>

type Output = ExportedType<'a>

The returned type after indexing.

fn index(&self, index: ExportedTypeIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<FieldIndex> for Resolution<'a>

type Output = Field<'a>

The returned type after indexing.

fn index(&self, index: FieldIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<FieldRefIndex> for Resolution<'a>

type Output = ExternalFieldReference<'a>

The returned type after indexing.

fn index(&self, index: FieldRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<FileIndex> for Resolution<'a>

type Output = File<'a>

The returned type after indexing.

fn index(&self, index: FileIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<MethodIndex> for Resolution<'a>

type Output = Method<'a>

The returned type after indexing.

fn index(&self, index: MethodIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<MethodRefIndex> for Resolution<'a>

type Output = ExternalMethodReference<'a>

The returned type after indexing.

fn index(&self, index: MethodRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<ModuleRefIndex> for Resolution<'a>

type Output = ExternalModuleReference<'a>

The returned type after indexing.

fn index(&self, index: ModuleRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<PropertyIndex> for Resolution<'a>

type Output = Property<'a>

The returned type after indexing.

fn index(&self, index: PropertyIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<TypeIndex> for Resolution<'a>

type Output = TypeDefinition<'a>

The returned type after indexing.

fn index(&self, index: TypeIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> Index<TypeRefIndex> for Resolution<'a>

type Output = ExternalTypeReference<'a>

The returned type after indexing.

fn index(&self, index: TypeRefIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> IndexMut<AssemblyRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: AssemblyRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<EventIndex> for Resolution<'a>

fn index_mut(&mut self, index: EventIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<ExportedTypeIndex> for Resolution<'a>

fn index_mut(&mut self, index: ExportedTypeIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<FieldIndex> for Resolution<'a>

fn index_mut(&mut self, index: FieldIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<FieldRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: FieldRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<FileIndex> for Resolution<'a>

fn index_mut(&mut self, index: FileIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<MethodIndex> for Resolution<'_>

fn index_mut(&mut self, index: MethodIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<MethodRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: MethodRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<ModuleRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: ModuleRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<PropertyIndex> for Resolution<'a>

fn index_mut(&mut self, index: PropertyIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<TypeIndex> for Resolution<'a>

fn index_mut(&mut self, index: TypeIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<TypeRefIndex> for Resolution<'a>

fn index_mut(&mut self, index: TypeRefIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.