{

/// <summary>

/// The list containing all injected modules (writable).

/// </summary>

private readonly List<InjectedModule> _internalInjectedModules;

private readonly IProcess _processPlus;

/// <summary>

/// Initializes a new instance of the <see cref="ModuleFactory" /> class.

/// </summary>

/// <param name="processPlus">The reference of the <see cref="IProcess" /> object.</param>

public ModuleFactory(IProcess processPlus)

{

// Save the parameter

_processPlus = processPlus;

// Create a list containing all injected modules

_internalInjectedModules = new List<InjectedModule>();

}

/// <summary>

/// Gets a pointer from the remote process.

/// </summary>

/// <param name="address">The address of the pointer.</param>

/// <returns>A new instance of a <see cref="IPointer" /> class.</returns>

public IPointer this[IntPtr address] => new MemoryPointer(_processPlus, address);

/// <summary>

/// Gets the main module for the remote process.

/// </summary>

public IProcessModule MainModule => FetchModule(_processPlus.Native.MainModule);

/// <summary>

/// Gets the modules that have been loaded in the remote process.

/// </summary>

public IEnumerable<IProcessModule> RemoteModules => NativeModules.Select(FetchModule);

/// <summary>

/// Gets the native modules that have been loaded in the remote process.

/// </summary>

public IEnumerable<ProcessModule> NativeModules => _processPlus.Native.Modules.Cast<ProcessModule>();

/// <summary>

/// Gets the specified module in the remote process.

/// </summary>

/// <param name="moduleName">The name of module (not case sensitive).</param>

/// <returns>A new instance of a <see cref="RemoteModule" /> class.</returns>

public IProcessModule this[string moduleName] => FetchModule(moduleName);

/// <summary>

/// Releases all resources used by the <see cref="ModuleFactory" /> object.

/// </summary>

public virtual void Dispose()

{

try

{

//TODO: This could maybe be simplified perhaps something like this

/*

// Release all injected modules which must be disposed

foreach (var injectedModule in _internalInjectedModules.Where(m => m.MustBeDisposed))

injectedModule.Dispose();

// Clean the cached functions related to this process

//TODO: this can trigger a invalid operation exception due to collection object changing

// _processPlus.Handle

foreach (

var cachedFunction in

RemoteModule.CachedFunctions.ToArray()

.Where(cachedFunction => cachedFunction.Key.Item2 == _processPlus.Handle))

RemoteModule.CachedFunctions.Remove(cachedFunction);

// Avoid the finalizer

GC.SuppressFinalize(this);

}

catch (Exception ex)

{

Console.WriteLine("Error occured trying to dispose of Process Module. e:" + ex.Message);

}

}

/// <summary>

/// A collection containing all injected modules.

/// </summary>

public IEnumerable<InjectedModule> InjectedModules => _internalInjectedModules.AsReadOnly();

/// <summary>

/// Frees the loaded dynamic-link library (DLL) module and, if necessary, decrements its reference count.

/// </summary>

/// <param name="moduleName">The name of module to eject.</param>

public void Eject(string moduleName)

{

// Fint the module to eject

var module = RemoteModules.FirstOrDefault(m => m.Name == moduleName);

// Eject the module is it's valid

if (module != null)

RemoteModule.InternalEject(_processPlus, module);

}

/// <summary>

/// Injects the specified module into the address space of the remote process.

/// </summary>

/// <param name="path">

/// The path of the module. This can be either a library module (a .dll file) or an executable module

/// (an .exe file).

/// </param>

/// <param name="mustBeDisposed">The module will be ejected when the finalizer collects the object.</param>

/// <returns>A new instance of the <see cref="InjectedModule" />class.</returns>

public InjectedModule Inject(string path, bool mustBeDisposed = true)

{

// Injects the module

var module = InjectedModule.InternalInject(_processPlus, path);

// Add the module in the list

_internalInjectedModules.Add(module);

// Return the module

return module;

}

/// <summary>

/// Frees the loaded dynamic-link library (DLL) module and, if necessary, decrements its reference count.

/// </summary>

/// <param name="module">The module to eject.</param>

public void Eject(IProcessModule module)

{

#if LAUNCH_MDA

System.Diagnostics.Debugger.Launch();

#endif

// If the module is valid

if (!module.IsValid) return;

// Find if the module is an injected one

var injected = _internalInjectedModules.FirstOrDefault(m => m.Equals(module));

if (injected != null)

_internalInjectedModules.Remove(injected);

// Eject the module

RemoteModule.InternalEject(_processPlus, module);

}

/// <summary>

/// Frees resources and perform other cleanup operations before it is reclaimed by garbage collection.

/// </summary>

~ModuleFactory()

{

Dispose();

}

/// <summary>

/// Fetches a module from the remote process.

/// </summary>

/// <param name="moduleName">

/// A module name (not case sensitive). If the file name extension is omitted, the default library

/// extension .dll is appended.

/// </param>

/// <returns>A new instance of a <see cref="RemoteModule" /> class.</returns>

public IProcessModule FetchModule(string moduleName)

{

// Convert module name with lower case

moduleName = moduleName.ToLower();

// Add the dll extension if it doesnt already have one

if (!Path.HasExtension(moduleName))

moduleName += ".dll";

// Get the matching process module

var matchingModule = NativeModules.FirstOrDefault(m => m.ModuleName.ToLower() == moduleName);

if (matchingModule == null)

{

// Return null if there's no matching module

return null;

}

// Return a new `RemoteModule` instance

return new RemoteModule(_processPlus, matchingModule);

// Fetch and return the module

//return new RemoteModule(_processPlus, NativeModules.First(m => m.ModuleName.ToLower() == moduleName));

}

/// <summary>

/// Fetches a module from the remote process.

/// </summary>

/// <param name="module">A module in the remote process.</param>

/// <returns>A new instance of a <see cref="RemoteModule" /> class.</returns>

private IProcessModule FetchModule(ProcessModule module)

{

return FetchModule(module.ModuleName);

}