/// <summary>
/// Uninstal the provided assembly names from the GAC
/// </summary>
/// <param name="assemblyNames"></param>
/// <param name="reference"></param>
/// <param name="disp"></param>
public static void UninstallAssemblies(String[] assemblyNames, InstallReference reference, out AssemblyCacheUninstallDisposition[] disp)
{
var dispResult = AssemblyCacheUninstallDisposition.Uninstalled;
if (reference != null)
{
if (!InstallReferenceGuid.IsValidGuidScheme(reference.GuidScheme))
{
throw new ArgumentException("Invalid reference guid.", "guid");
}
}
IAssemblyCache ac = null;
disp = new AssemblyCacheUninstallDisposition[assemblyNames.Length];
var hr = Utils.CreateAssemblyCache(out ac, 0);
if (hr >= 0)
{
for (var i = 0; i < assemblyNames.Length; i++)
{
hr = ac.UninstallAssembly(0, assemblyNames[i], reference, out dispResult);
if (hr < 0)
{
Marshal.ThrowExceptionForHR(hr);
}
disp[i] = dispResult;
}
}
}
/// <summary>
/// Install the provided assemblies to GAC
/// </summary>
/// <param name="assemblyPaths"></param>
/// <param name="reference"></param>
/// <param name="flags"></param>
public static void InstallAssemblies(String[] assemblyPaths, InstallReference reference, AssemblyCommitFlags flags)
{
if (reference != null)
{
if (!InstallReferenceGuid.IsValidGuidScheme(reference.GuidScheme))
{
throw new ArgumentException("Invalid reference guid.", "guid");
}
}
IAssemblyCache ac = null;
var hr = 0;
hr = Utils.CreateAssemblyCache(out ac, 0);
if (hr >= 0)
{
foreach (var assemblyPath in assemblyPaths)
{
hr = ac.InstallAssembly((int)flags, assemblyPath, reference);
if (hr < 0)
{
Marshal.ThrowExceptionForHR(hr);
}
}
}
}
// assemblyName has to be fully specified name.
// A.k.a, for v1.0/v1.1 assemblies, it should be "name, Version=xx, Culture=xx, PublicKeyToken=xx".
// For v2.0 assemblies, it should be "name, Version=xx, Culture=xx, PublicKeyToken=xx, ProcessorArchitecture=xx".
// If assemblyName is not fully specified, a random matching assembly will be uninstalled.
public static void UninstallAssembly(String assemblyName, InstallReference reference, out AssemblyCacheUninstallDisposition disp)
{
var dispResult = AssemblyCacheUninstallDisposition.Uninstalled;
if (reference != null)
{
if (!InstallReferenceGuid.IsValidGuidScheme(reference.GuidScheme))
{
throw new ArgumentException("Invalid reference guid.", "guid");
}
}
IAssemblyCache ac = null;
var hr = Utils.CreateAssemblyCache(out ac, 0);
if (hr >= 0)
{
hr = ac.UninstallAssembly(0, assemblyName, reference, out dispResult);
}
if (hr < 0)
{
Marshal.ThrowExceptionForHR(hr);
}
disp = dispResult;
}
// See comments in UninstallAssembly
public static String QueryAssemblyInfo(String assemblyName)
{
if (assemblyName == null)
{
throw new ArgumentException("Invalid name", "assemblyName");
}
AssemblyInfo aInfo = new AssemblyInfo();
aInfo.cchBuf = 1024;
// Get a string with the desired length
aInfo.currentAssemblyPath = new String('\0', aInfo.cchBuf);
IAssemblyCache ac = null;
int hr = CreateAssemblyCache(out ac, 0);
if (hr >= 0)
{
hr = ac.QueryAssemblyInfo(0, assemblyName, ref aInfo);
}
if (hr < 0)
{
Marshal.ThrowExceptionForHR(hr);
}
return(aInfo.currentAssemblyPath);
}
/// <summary>
/// Installs the assembly.
/// </summary>
/// <param name="assemblyPath">The assembly path.</param>
/// <param name="force">if set to <c>true</c> force.</param>
public static void InstallAssembly(string assemblyPath, bool force)
{
IAssemblyCache assemblyCache = null;
int flags = force ? (int)CommitFlags.Force : (int)CommitFlags.Refresh;
ThrowOnError(NativeMethods.CreateAssemblyCache(out assemblyCache, 0));
ThrowOnError(assemblyCache.InstallAssembly(flags, assemblyPath, null));
}
static internal int UninstallAssembly(string assembly)
{
assembly = System.Reflection.Assembly.LoadFrom(Path.GetFullPath(assembly)).FullName;
uint n;
IAssemblyCache gac = null;
int hr = CreateAssemblyCache(out gac, 0);
return((hr != 0) ? hr : gac.UninstallAssembly(0, assembly, (IntPtr)0, out n));
}
public AssemblyLoader(IAppDomain appDomain,
IPluginLoaderSettings settings,
IAssemblyCache assemblyCache,
IAssemblyNameReader assemblyNameReader,
IPluginLoaderLogger logger)
{
_AppDomain = appDomain ?? throw new ArgumentNullException(nameof(appDomain));
_Settings = settings ?? throw new ArgumentNullException(nameof(settings));
_AssemblyCache = assemblyCache ?? throw new ArgumentNullException(nameof(assemblyCache));
_AssemblyNameReader = assemblyNameReader ?? throw new ArgumentNullException(nameof(assemblyNameReader));
_Logger = logger;
}
}// GetFusionString
internal static int AddAssemblytoGac(String sAssemFilename)
{
IAssemblyCache ac = null;
int hr = CreateAssemblyCache(out ac, 0);
if (hr != HRESULT.S_OK)
{
return(hr);
}
return(ac.InstallAssembly(0, sAssemFilename, (IntPtr)0));
}// AddAssemblyToGac
static public int AddAssemblyToCache(string assemblyExecutionName)
{
IAssemblyCache ac = null;
int hr = CreateAssemblyCache(out ac, 0);
if (hr != 0)
{
return(hr);
}
return(ac.InstallAssembly(0, assemblyExecutionName, (IntPtr)0));
}
public void GacInstall(string assemblyPath)
{
IAssemblyCache ppAsmCache = null;
int num = NativeMethods.CreateAssemblyCache(out ppAsmCache, 0);
if (num == 0)
{
num = ppAsmCache.InstallAssembly(0, assemblyPath, IntPtr.Zero);
}
if (num != 0)
{
throw new Exception(System.Web.SR.GetString("Failed_gac_install"));
}
}
private void BrowseFilesButton_Click(object sender, EventArgs e)
{
try
{
this.SetUIState(false);
DialogResult result = this.BrowseFilesDialog.ShowDialog();
if (result == System.Windows.Forms.DialogResult.OK)
{
this.AssemblyComboBox.Items.Clear();
this.ClassComboBox.Items.Clear();
this.TypesCheckedListBox.Items.Clear();
string selectedFile = this.BrowseFilesDialog.FileName;
FileInfo assemblyFile = new FileInfo(selectedFile);
DirectoryInfo gac = new DirectoryInfo(@"c:\windows\assembly\GAC_MSIL");
FileInfo[] results = gac.GetFiles(assemblyFile.Name, SearchOption.AllDirectories);
if (MessageBox.Show(this, string.Format("The selected assembly was {0} in the GAC. Event receivers must be registered in the GAC and do not require Safe Control entries. Do you want to register the selected copy of this assembly?", (results.Length > 0 ? "found" : "not found")), "Register Selected Assembly in GAC?", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.Yes)
{
Assembly assembly = Assembly.LoadFile(assemblyFile.FullName);
FUSION_INSTALL_REFERENCE[] gacSettings = new FUSION_INSTALL_REFERENCE[1];
gacSettings[0].dwFlags = 0;
gacSettings[0].guidScheme = AssemblyCache.FUSION_REFCOUNT_OPAQUE_STRING_GUID;
gacSettings[0].szIdentifier = assembly.GetName().Name;
gacSettings[0].szNonCannonicalData = assembly.FullName;
IAssemblyCache cache = AssemblyCache.CreateAssemblyCache();
cache.InstallAssembly(0, assemblyFile.FullName, gacSettings);
}
this.AssemblyComboBox.Items.Add(assemblyFile);
this.AssemblyComboBox.SelectedIndex = 1;
}
this.SetUIState(true);
}
catch (Exception ex)
{
this.HandleException(ex);
}
}
public void Load(IServiceProvider serviceProvider)
{
CodeMetricWindow codeMetricWindow = new CodeMetricWindow(serviceProvider);
this.windowManager = (IWindowManager)serviceProvider.GetService(typeof(IWindowManager));
this.windowManager.Load += new EventHandler(this.WindowManager_Load);
this.windowManager.Windows.Add("CodeMetricWindow", codeMetricWindow, "Code Metrics");
this.assemblyManager = (IAssemblyManager)serviceProvider.GetService(typeof(IAssemblyManager));
this.assemblyCache = (IAssemblyCache)serviceProvider.GetService(typeof(IAssemblyCache));
this.commandBarManager = (ICommandBarManager)serviceProvider.GetService(typeof(ICommandBarManager));
this.separator = this.commandBarManager.CommandBars["Tools"].Items.AddSeparator();
this.button = this.commandBarManager.CommandBars["Tools"].Items.AddButton("&Code Metrics", new EventHandler(this.Button_Click), Keys.Control | Keys.E);
}
static internal int AddAssemblyToCache(string assembly)
{
IAssemblyCache ac = null;
var hr = CreateAssemblyCache(out ac, 0);
if (hr != IntPtr.Zero)
{
return((int)hr);
}
else
{
return(ac.InstallAssembly(0, assembly, (IntPtr)0));
}
}
/// <summary>
/// Installs an assembly into the GAC. Adds a reference to the installing applicaiton.
/// </summary>
/// <param name="assemblyPath">The path to the assembly to be installed</param>
/// <param name="flags">see AssemblyCommitFlags</param>
internal static void InstallAssembly(String assemblyPath, AssemblyCommitFlags flags)
{
IAssemblyCache ac = null;
int hr = 0;
hr = GacUtils.CreateAssemblyCache(out ac, 0);
if (hr >= 0)
{
hr = ac.InstallAssembly((int)flags, assemblyPath, null);
}
if (hr < 0)
{
GacUtils.ThrowMarshalledException(hr);
}
}
// If you use this, fusion will do the streaming & commit
public static void InstallAssembly(string assemblyPath, InstallReference reference, AssemblyCommitFlags flags)
{
if (reference != null)
{
if (!InstallReferenceGuid.IsValidGuidScheme(reference.GuidScheme))
{
throw new ArgumentException("Invalid argument( reference guid).");
}
}
IAssemblyCache asmCache = null;
COM.CheckHR(CreateAssemblyCache(out asmCache, 0));
COM.CheckHR(asmCache.InstallAssembly((int)flags, assemblyPath, reference));
}
static public int RemoveAssemblyFromCache(string assemblyName)
{
IAssemblyCache ac = null;
int hr = CreateAssemblyCache(out ac, 0);
if (hr != 0)
{
return(hr);
}
uint n;
return(ac.UninstallAssembly(0, assemblyName, (IntPtr)0, out n));
}
static internal int RemoveAssemblyFromCache(string assembly)
{
IAssemblyCache ac = null;
uint n;
var hr = CreateAssemblyCache(out ac, 0);
if (hr != IntPtr.Zero)
{
return((int)hr);
}
else
{
return(ac.UninstallAssembly(0, assembly, (IntPtr)0, out n));
}
}
/// <summary>
/// Constructor. Initialise IAssemblyEnum and IAssemblyCache.
/// </summary>
public GACUtil()
{
uint hr = Functions.CreateAssemblyEnum(out IAssemblyEnum pIAssemblyEnum, IntPtr.Zero, null, ASM_CACHE_FLAGS.ASM_CACHE_GAC, IntPtr.Zero);
if (!Macros.SUCCEEDED(hr) || pIAssemblyEnum == null)
{
throw new Exception("[-] Unable to create IAssemblyEnum interface.");
}
this.pIAssemblyEnum = pIAssemblyEnum;
hr = Functions.CreateAssemblyCache(out IAssemblyCache pIAssemblyCache, 0);
if (!Macros.SUCCEEDED(hr) || pIAssemblyCache == null)
{
throw new Exception("[-] Unable to create fusion!IAssemblyEnum interface.");
}
this.pIAssemblyCache = pIAssemblyCache;
}
internal static string GetAssemblyPath(string assemblyName, out string fullName)
{
IAssemblyCache cache = null;
ThrowOnError(NativeMethods.CreateAssemblyCache(out cache, 0));
var info = new AssemblyInfo
{
cbAssemblyInfo = (uint)Marshal.SizeOf(typeof(AssemblyInfo))
};
//ProcessorArchitecture required for this call
fullName = assemblyName;
if (HasProcessorArchitecture(fullName))
{
//getting size of string, cchBuf will be the size
cache.QueryAssemblyInfo(3, fullName, ref info);
}
else
{
//try using possible proccessors
foreach (string p in proccessors)
{
fullName = AppendProccessor(assemblyName, p);
cache.QueryAssemblyInfo(3, fullName, ref info);
//if no size, not found, try another proccessor
if (info.cchBuf > 0)
{
break;
}
}
}
//if no size, not found
if (info.cchBuf == 0)
{
return(null);
}
//get path
info.pszCurrentAssemblyPathBuf = new string(new char[info.cchBuf]);
ThrowOnError(cache.QueryAssemblyInfo(3, fullName, ref info));
return(info.pszCurrentAssemblyPathBuf);
}
public static void InstallAssembly(string path, bool forceRefresh)
{
IAssemblyCache iac = null;
CreateAssemblyCache(out iac, 0);
try {
uint flags = forceRefresh ? 2u : 1u;
int hr = iac.InstallAssembly(flags, path, IntPtr.Zero);
if (hr < 0)
{
Marshal.ThrowExceptionForHR(hr);
}
}
finally {
Marshal.FinalReleaseComObject(iac);
}
}
public MemoryAssemblyMembersCache(IAssemblyCache assemblyCache)
{
_assemblyCache = assemblyCache;
AppDomain.CurrentDomain.AssemblyResolve += (object?sender, ResolveEventArgs args) =>
{
var task = assemblyCache.WaitFor(args.RequestingAssembly.FullName, 20000);
task.Wait();
var item = task.Result;
if (item != null)
{
//AppDomain.CurrentDomain.LO
var fullName = item.FullName;
var refs = item.GetReferencedAssemblies();
foreach (var @ref in refs)
{
if (AssemblyUtils.IsSystemAssembly(@ref) || AssemblyUtils.IsOskAssembly(@ref))
{
continue;
}
var asmDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var assembly = Assembly.LoadFile(Path.Combine(asmDirectory, $"{@ref.Name}.dll"));
//var types = assembly.GetTypes();
//foreach (var type in types)
//{
// try
// {
// var tobj = Activator.CreateInstance(type);
// if (tobj != default)
// break;
// }
// catch (Exception)
// {
// // ignore
// }
//}
}
return(item);
}
return(null);
};
}
protected static void RemoveAssembly(string AssemblyName)
{
LogMessage("RemoveAssembly", "Uninstalling: " + AssemblyName);
// Get an IAssemblyCache interface
IAssemblyCache pCache = AssemblyCache.CreateAssemblyCache();
IASSEMBLYCACHE_UNINSTALL_DISPOSITION puldisposition = IASSEMBLYCACHE_UNINSTALL_DISPOSITION.IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNKNOWN; // Initialise variable
int result = pCache.UninstallAssembly(0, AssemblyName, null, out puldisposition);
if (result == 0)
{
LogMessage("RemoveAssembly", "Uninstalled without error!");
}
else
{
LogMessage("RemoveAssembly", "Uninstall returned status code: " + result);
}
switch (puldisposition)
{
case IASSEMBLYCACHE_UNINSTALL_DISPOSITION.IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED:
LogMessage("RemoveAssembly", "Outcome: Assembly already uninstalled"); break;
case IASSEMBLYCACHE_UNINSTALL_DISPOSITION.IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING:
LogMessage("RemoveAssembly", "Outcome: Delete currently pending"); break;
case IASSEMBLYCACHE_UNINSTALL_DISPOSITION.IASSEMBLYCACHE_UNINSTALL_DISPOSITION_HAS_INSTALL_REFERENCES:
LogMessage("RemoveAssembly", "Outcome: Assembly has remaining install references"); break;
case IASSEMBLYCACHE_UNINSTALL_DISPOSITION.IASSEMBLYCACHE_UNINSTALL_DISPOSITION_REFERENCE_NOT_FOUND:
LogMessage("RemoveAssembly", "Outcome: Unable to find assembly - " + AssemblyName); break;
case IASSEMBLYCACHE_UNINSTALL_DISPOSITION.IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE:
LogMessage("RemoveAssembly", "Outcome: Assembly still in use"); break;
case IASSEMBLYCACHE_UNINSTALL_DISPOSITION.IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED:
LogMessage("RemoveAssembly", "Outcome: Assembly uninstalled"); break;
default:
LogMessage("RemoveAssembly", "Unknown uninstall outcome code: " + puldisposition); break;
}
}
private IModule ResolveModule(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
IAssembly assembly = this.ResolveAssembly(assemblyManager, assemblyCache);
if (assembly != null)
{
string moduleName = this.item;
foreach (IModule module in assembly.Modules)
{
if (moduleName == module.Name)
{
return(module);
}
}
}
return(null);
}
public static void UninstallAssembly(string assemblyName, InstallReference reference, out AssemblyCacheUninstallDisposition disp)
{
AssemblyCacheUninstallDisposition dispResult = AssemblyCacheUninstallDisposition.Uninstalled;
if (reference != null)
{
if (!InstallReferenceGuid.IsValidGuidScheme(reference.GuidScheme))
{
throw new ArgumentException("Invalid argument (reference guid).");
}
}
IAssemblyCache asmCache = null;
COM.CheckHR(CreateAssemblyCache(out asmCache, 0));
COM.CheckHR(asmCache.UninstallAssembly(0, assemblyName, reference, out dispResult));
disp = dispResult;
}
/// <summary>
/// Uninstalls the assembly, using the application as a reference.
/// AssemblyName has to be fully specified name.
/// A.k.a, for v1.0/v1.1 assemblies, it should be "name, Version=xx, Culture=xx, PublicKeyToken=xx".
/// For v2.0 assemblies, it should be "name, Version=xx, Culture=xx, PublicKeyToken=xx, ProcessorArchitecture=xx".
/// If assemblyName is not fully specified, a random matching assembly will be uninstalled.
/// </summary>
/// <param name="assemblyName"></param>
private static AssemblyCacheUninstallDisposition UninstallAssemblyImplementation(String assemblyName)
{
AssemblyCacheUninstallDisposition dispResult = AssemblyCacheUninstallDisposition.Uninstalled;
IAssemblyCache ac = null;
int hr = GacUtils.CreateAssemblyCache(out ac, 0);
if (hr >= 0)
{
hr = ac.UninstallAssembly(0, assemblyName, null, out dispResult);
}
if (hr < 0)
{
GacUtils.ThrowMarshalledException(hr);
}
return(dispResult);
}
private IResource ResolveResource(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
IAssembly assembly = this.ResolveAssembly(assemblyManager, assemblyCache);
if (assembly != null)
{
string resourceName = this.item;
foreach (IResource resource in assembly.Resources)
{
if (resourceName == resource.Name)
{
return(resource);
}
}
}
return(null);
}
public void GacInstall(string assemblyPath)
{
#if !FEATURE_PAL
IAssemblyCache ac = null;
int hr = NativeMethods.CreateAssemblyCache(out ac, 0);
if (0 == hr)
{
hr = ac.InstallAssembly(0, assemblyPath, IntPtr.Zero);
}
#else // !FEATURE_PAL
int hr = -1;
try
{
Process gacutilprocess = new System.Diagnostics.Process();
if (gacutilprocess != null)
{
gacutilprocess.StartInfo.CreateNoWindow = true;
#if PLATFORM_UNIX
gacutilprocess.StartInfo.FileName = "gacutil";
#else
gacutilprocess.StartInfo.FileName = "gacutil.exe";
#endif
gacutilprocess.StartInfo.UseShellExecute = false;
gacutilprocess.StartInfo.Arguments = "/i " + assemblyPath;
gacutilprocess.Start();
while (!gacutilprocess.HasExited)
{
Thread.Sleep(250);
}
hr = gacutilprocess.ExitCode;
}
}
catch (Exception)
{
hr = -1;
}
#endif // FEATURE_PAL
if (0 != hr)
{
throw new Exception(SR.GetString(SR.Failed_gac_install));
}
}
public static string QueryAssemblyInfo(string assemblyName)
{
if (assemblyName == null)
{
throw new ArgumentException("Invalid argument (assemblyName)");
}
AssemblyInfo aInfo = new AssemblyInfo();
aInfo.cchBuf = 1024;
aInfo.currentAssemblyPath = "Path".PadLeft(aInfo.cchBuf);
IAssemblyCache ac = null;
COM.CheckHR(CreateAssemblyCache(out ac, 0));
COM.CheckHR(ac.QueryAssemblyInfo(0, assemblyName, ref aInfo));
return(aInfo.currentAssemblyPath);
}
public bool GacUnInstall(string assemblyName)
{
IAssemblyCache ppAsmCache = null;
uint pulDisposition = 0;
int num2 = NativeMethods.CreateAssemblyCache(out ppAsmCache, 0);
if (num2 == 0)
{
num2 = ppAsmCache.UninstallAssembly(0, assemblyName, IntPtr.Zero, out pulDisposition);
if (pulDisposition == 3)
{
return(false);
}
}
if (num2 != 0)
{
throw new Exception(System.Web.SR.GetString("Failed_gac_uninstall"));
}
return(true);
}
private static string GetLocationImpl(IAssemblyCache assemblyCache, string strongName, string targetProcessorArchitecture)
{
ASSEMBLY_INFO pAsmInfo = new ASSEMBLY_INFO
{
cbAssemblyInfo = (uint)Marshal.SizeOf(typeof(ASSEMBLY_INFO))
};
if (targetProcessorArchitecture != null)
{
strongName = strongName + ", ProcessorArchitecture=" + targetProcessorArchitecture;
}
int hr = assemblyCache.QueryAssemblyInfo((uint)AssemblyCacheEnum.QUERYASMINFO_FLAG_VALIDATE, strongName, ref pAsmInfo);
if ((Win32NTMethods.Failed(hr) && (hr != Win32NTMethods.E_INSUFFICIENT_BUFFER)) || (pAsmInfo.cbAssemblyInfo == 0))
{
return(string.Empty);
}
pAsmInfo.pszCurrentAssemblyPathBuf = new string(new char[pAsmInfo.cchBuf]);
return(!Win32NTMethods.Failed(assemblyCache.QueryAssemblyInfo(3, strongName, ref pAsmInfo)) ? pAsmInfo.pszCurrentAssemblyPathBuf : string.Empty);
}
internal static extern int CreateAssemblyCache(
out IAssemblyCache ppAsmCache,
int reserved);
public static extern int CreateAssemblyCache(
out IAssemblyCache assemblyCache,
uint reserved);
private static extern IntPtr CreateAssemblyCache(
out IAssemblyCache ppAsmCache,
int reserved);
public static extern HResult CreateAssemblyCache(
out IAssemblyCache ppAsmCache,
int dwReserved);
static extern void CreateAssemblyCache(out IAssemblyCache ppAsmCache, uint dwReserved);
private IResource ResolveResource(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
IAssembly assembly = this.ResolveAssembly(assemblyManager, assemblyCache);
if (assembly != null)
{
string resourceName = this.item;
foreach (IResource resource in assembly.Resources)
{
if (resourceName == resource.Name)
{
return resource;
}
}
}
return null;
}
private IAssembly ResolveAssembly(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
IAssemblyReference assemblyReference = this.ParseAssemblyReference(this.assembly, assemblyManager);
for (int i = 0; i < assemblyManager.Assemblies.Count; i++)
{
IAssembly assembly = assemblyManager.Assemblies[i];
if (assembly.Equals(assemblyReference))
{
return assembly;
}
}
if (assemblyCache != null)
{
string location = assemblyCache.QueryLocation(assemblyReference, null);
if ((location != null) && (location.Length > 0))
{
IAssembly assembly = assemblyManager.LoadFile(location);
return assembly;
}
}
return null;
}
private IEventDeclaration ResolveEventDeclaration(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
ITypeDeclaration typeDeclaration = this.ResolveTypeDeclaration(assemblyManager, assemblyCache);
if (typeDeclaration != null)
{
string eventName = this.member;
foreach (IEventDeclaration eventDeclaration in typeDeclaration.Events)
{
string text = this.GetEventReferenceText(eventDeclaration);
if (eventName == text)
{
return eventDeclaration;
}
}
}
return null;
}
private IPropertyDeclaration ResolvePropertyDeclaration(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
ITypeDeclaration typeDeclaration = this.ResolveTypeDeclaration(assemblyManager, assemblyCache);
if (typeDeclaration != null)
{
string propertyName = this.member;
foreach (IPropertyDeclaration propertyDeclaration in typeDeclaration.Properties)
{
string text = this.GetPropertyReferenceText(propertyDeclaration);
if (propertyName == text)
{
return propertyDeclaration;
}
}
}
return null;
}
private IMethodDeclaration ResolveMethodDeclaration(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
ITypeDeclaration typeDeclaration = this.ResolveTypeDeclaration(assemblyManager, assemblyCache);
if (typeDeclaration != null)
{
string methodName = this.member;
foreach (IMethodDeclaration methodDeclaration in typeDeclaration.Methods)
{
string text = this.GetMethodReferenceText(methodDeclaration);
if (methodName == text)
{
return methodDeclaration;
}
}
}
return null;
}
private IFieldDeclaration ResolveFieldDeclaration(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
ITypeDeclaration typeDeclaration = this.ResolveTypeDeclaration(assemblyManager, assemblyCache);
if (typeDeclaration != null)
{
string fieldName = this.member;
foreach (IFieldDeclaration fieldDeclaration in typeDeclaration.Fields)
{
string text = this.GetFieldReferenceText(fieldDeclaration);
if (fieldName == text)
{
return fieldDeclaration;
}
}
}
return null;
}
private ITypeDeclaration ResolveTypeDeclaration(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
IAssembly[] assemblyList = new IAssembly[assemblyManager.Assemblies.Count];
assemblyManager.Assemblies.CopyTo(assemblyList, 0);
if ((this.assembly != null) && (this.assembly.Length > 0))
{
IAssembly assembly = this.ResolveAssembly(assemblyManager, assemblyCache);
assemblyList = (assembly != null) ? new IAssembly[] { assembly } : new IAssembly[0];
}
string typeName = this.item;
foreach (IAssembly assembly in assemblyList)
{
foreach (IModule module in assembly.Modules)
{
foreach (ITypeDeclaration typeDeclaration in module.Types)
{
foreach (ITypeDeclaration currentType in GetNestedTypeList(typeDeclaration))
{
string text = this.GetTypeReferenceText(currentType);
if (typeName == text)
{
return currentType;
}
}
}
}
}
return null;
}
public object Resolve(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
switch (this.type)
{
case CodeIdentifierType.None:
return null;
case CodeIdentifierType.Assembly:
return this.ResolveAssembly(assemblyManager, assemblyCache);
case CodeIdentifierType.Module:
return this.ResolveModule(assemblyManager, assemblyCache);
case CodeIdentifierType.Resource:
return this.ResolveResource(assemblyManager, assemblyCache);
case CodeIdentifierType.Type:
return this.ResolveTypeDeclaration(assemblyManager, assemblyCache);
case CodeIdentifierType.Field:
return this.ResolveFieldDeclaration(assemblyManager, assemblyCache);
case CodeIdentifierType.Method:
return this.ResolveMethodDeclaration(assemblyManager, assemblyCache);
case CodeIdentifierType.Property:
return this.ResolvePropertyDeclaration(assemblyManager, assemblyCache);
case CodeIdentifierType.Event:
return this.ResolveEventDeclaration(assemblyManager, assemblyCache);
}
throw new NotSupportedException("Unable to resolve code identifier.");
}
private static extern int CreateAssemblyCache(out IAssemblyCache ppAsmCache, uint dwReserved);
private IModule ResolveModule(IAssemblyManager assemblyManager, IAssemblyCache assemblyCache)
{
IAssembly assembly = this.ResolveAssembly(assemblyManager, assemblyCache);
if (assembly != null)
{
string moduleName = this.item;
foreach (IModule module in assembly.Modules)
{
if (moduleName == module.Name)
{
return module;
}
}
}
return null;
}
