Struct Module

pub struct Module { /* private fields */ }

Represents a loaded .net module.

let module = Module::from_file(r#"Example.Net.dll"#);

for ty in module.types().values() {
   for method in ty.methods().values() {
       println!("{}", method.name());
   }
}

Implementations

impl Module

pub fn from_path(path: impl AsRef<Path>) -> Result<Self>

Load a .net assembly from the given path and resolve its dependancies with the default PathAssemblyResolver resolver.

let module = Module::from_path(r#"Example.Net.dll"#)?;

Examples found in repository

examples/load_module.rs (line 4)

fn main() {
    let module = Module::from_path(r#"C:\re\dnspy\bin\dnlib.dll"#).unwrap();
    println!("loaded {}", module.module().value().name());
}

examples/simple.rs (line 4)

fn main() {
    let module = Module::from_path(r#"C:\re\dnspy\bin\dnlib.dll"#).unwrap();
    println!("loaded");

    for ty in module.types().values() {
        println!("{} {{", ty);
        if ty.is_enum() {
            for field in ty
                .fields()
                .values()
                .filter(|x| !x.flags().contains(FieldFlags::SpecialName))
            {
                println!("\t{},", field.name());
            }
        } else {
            for field in ty.fields().values() {
                println!("\t{};", field);
            }
        }

        println!("\n");

        for method in ty.methods().values() {
            println!("\t{};", method);
        }

        println!("}}");
    }
}

pub fn from_path_no_resolve(path: impl AsRef<Path>) -> Result<Self>

Load a .net assembly from the given path but do not reolve its dependancies.

let module = Module::from_path_no_resolve(r#"Example.Net.dll"#)?;

pub fn from_metadata(metadada: &Metadata<'_>) -> Result<Self>

Load a .net assembly from metadata. This will not resolve the modules dependancies.

let data = std::fs::read("Example.Net.dll").unwrap();
let md = Metadata::parse(&data).unwrap();
let loaded_module = Module::from_metadata(&md).unwrap();

pub fn load_dependancies( &self, resolver: &mut impl AssemblyResolver, ) -> Result<()>

Attempts to load the refrenced assemblies using the given resolver. This will panic if there is a refrence holding any of the AssemblyRef in this module.

pub fn module(&self) -> EntryView<'_, ModuleDef>

Returns the module infomation of the current module as a EntryView.

Examples found in repository

examples/load_module.rs (line 5)

fn main() {
    let module = Module::from_path(r#"C:\re\dnspy\bin\dnlib.dll"#).unwrap();
    println!("loaded {}", module.module().value().name());
}

pub fn type_refs(&self) -> EntryCollection<'_, TypeRef>

Returns an EntryCollection of TypeRef with all the type refrences inside the current module.

pub fn types(&self) -> EntryCollection<'_, TypeDef>

Returns all the type refrences inside the current module.

let module = Module::default();

for ty in module.types().values() {
    println!("{}", ty);
}

Examples found in repository

examples/simple.rs (line 7)

fn main() {
    let module = Module::from_path(r#"C:\re\dnspy\bin\dnlib.dll"#).unwrap();
    println!("loaded");

    for ty in module.types().values() {
        println!("{} {{", ty);
        if ty.is_enum() {
            for field in ty
                .fields()
                .values()
                .filter(|x| !x.flags().contains(FieldFlags::SpecialName))
            {
                println!("\t{},", field.name());
            }
        } else {
            for field in ty.fields().values() {
                println!("\t{};", field);
            }
        }

        println!("\n");

        for method in ty.methods().values() {
            println!("\t{};", method);
        }

        println!("}}");
    }
}

pub fn all_fields(&self) -> EntryCollection<'_, Field>

Returns all the fields defined in the module regardless of the parent type.

If you want the associated type, use TypeDef::fields.

let module = Module::default();

for field in module.all_fields().values() {
    println!("{} {}", field.signature(), field.name());
}

pub fn all_methods(&self) -> EntryCollection<'_, Method>

Returns all the methods defined in the module regardless of the parent type.

If you want the associated type, use TypeDef::methods.

let module = Module::default();

for method in module.all_methods().values() {
   println!("{}", method.name());
}

pub fn all_params(&self) -> EntryCollection<'_, Param>

Returns all the parameters defined in the module regardless of the parent method.

If you want the associated method, use Method::params.

let module = Module::default();

for param in module.all_params().values() {
    println!("{}", param.name());
}

pub fn all_type_specs(&self) -> EntryCollection<'_, TypeSpec>

Returns all the type specs defined in the module.

pub fn module_ref(&self) -> EntryCollection<'_, ModuleRef>

Returns all the modules refrenced in the module.

pub fn assembly_ref(&self) -> EntryCollection<'_, AssemblyRef>

Returns all the assemblies refrenced in the module.

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Module

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

Formats the value using the given formatter.

impl Default for Module

fn default() -> Module

Returns the “default value” for a type.