C# AssemblyRef类代码示例

    private TypeRef([NotNull] string typeName, [CanBeNull] AssemblyRef assembly)
    {
      Assert.ArgumentNotNull(typeName, "typeName");

      TypeName = typeName;
      Assembly = assembly ?? AssemblyRef.Empty;
    }

		public Csvm(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module, Csvm oldOne) {
			this.deobfuscatorContext = deobfuscatorContext;
			this.module = module;
			if (oldOne.resource != null)
				this.resource = (EmbeddedResource)module.Resources[oldOne.module.Resources.IndexOf(oldOne.resource)];
			if (oldOne.vmAssemblyRef != null)
				this.vmAssemblyRef = module.ResolveAssemblyRef(oldOne.vmAssemblyRef.Rid);
		}

		public AssemblyReferenceNodeImpl(ITreeNodeGroup treeNodeGroup, ModuleDef asmRefOwnerModule, AssemblyRef assemblyRef) {
			TreeNodeGroup = treeNodeGroup;
			this.asmRefOwnerModule = new WeakReference(asmRefOwnerModule);
			// Make sure we don't hold on to the original reference since it could prevent GC of the
			// owner module.
			AssemblyRef = assemblyRef.ToAssemblyRef();
			AssemblyRef.Rid = assemblyRef.Rid;
		}

 public TypeDefOrRefSig FindOrCreateTypeRef(ModuleDef module, AssemblyRef asmRef, string ns, string name, bool isValueType)
 {
     var typeRef = module.UpdateRowId(new TypeRefUser(module, ns, name, asmRef));
     if (isValueType)
         return new ValueTypeSig(typeRef);
     
     return new ClassSig(typeRef);
 }

		static MModule GetModule(AssemblyRef asmRef) {
			foreach (var mm in modules.Values) {
				var asm = mm.moduleDef.Assembly;
				if (asm != null && asm.FullName == asmRef.FullName)
					return mm;
			}
			return null;
		}

		static void OverwriteAssembly(AssemblyRef dst, AssemblyRef src) {
			dst.Name = src.Name;
			dst.Version = src.Version;
			dst.PublicKeyOrToken = src.PublicKeyOrToken;
			dst.Culture = src.Culture;
			dst.Attributes = src.Attributes;
			dst.Hash = src.Hash;
		}

 public AssemblyReferenceTreeNode(AssemblyRef r, AssemblyTreeNode parentAssembly)
 {
     if (parentAssembly == null)
         throw new ArgumentNullException("parentAssembly");
     if (r == null)
         throw new ArgumentNullException("r");
     this.r = r;
     this.parentAssembly = parentAssembly;
     this.LazyLoading = true;
 }

		internal AssemblyReferenceTreeNode(AssemblyRef r, AssemblyTreeNode parentAssembly, DnSpyFileListTreeNode dnSpyFileListTreeNode) {
			if (parentAssembly == null)
				throw new ArgumentNullException("parentAssembly");
			if (dnSpyFileListTreeNode == null)
				throw new ArgumentNullException("dnSpyFileListTreeNode");
			if (r == null)
				throw new ArgumentNullException("r");
			this.r = r;
			this.dnSpyFileListTreeNode = dnSpyFileListTreeNode;
			this.parentAssembly = parentAssembly;
			this.LazyLoading = true;
		}

		private ISymbolWriter LoadSymbolWriter(AssemblyDefinition assembly, AssemblyRef output)
		{
			// TODO: Get symbol writing to work.
//			ISymbolWriterProvider symProv = null;
//			if (this.usingMdb) {
//				symProv = new Mono.Cecil.Mdb.MdbWriterProvider ();
//			} else if (this.usingPdb) {
//				symProv = new Mono.Cecil.Pdb.PdbWriterProvider ();
//			} else {
//				this.warnings.Add ("-writePDBFile specified, but no symbol file found, cannot write symbols.");
//			}
//			if (symProv != null) {
//				return output.IsFilename ?
//					symProv.GetSymbolWriter (assembly.MainModule, output.Filename) :
//					symProv.GetSymbolWriter (assembly.MainModule, output.Streams.Symbols);
//			}
			return null;
		}

 static bool IsAssemblyRef(AssemblyRef asmRef, UTF8String name, PublicKeyToken token)
 {
     if (asmRef.Name != name)
         return false;
     var pkot = asmRef.PublicKeyOrToken;
     if (pkot == null)
         return false;
     return token.Equals(pkot.Token);
 }

 /// <summary>
 /// Add an external assembly to this PEFile (.assembly extern)
 /// </summary>
 /// <param name="assemName">the external assembly name</param>
 /// <returns>a descriptor for this external assembly</returns>
 public AssemblyRef AddExternAssembly(string assemName) {
   if (assemName.CompareTo(mscorlibName) == 0) return metaData.mscorlib;
   AssemblyRef anAssem = new AssemblyRef(metaData,assemName);
   metaData.AddToTable(MDTable.AssemblyRef,anAssem);
   // Console.WriteLine("Adding assembly " + assemName);
   return anAssem;
 }

 /// <summary>
 /// Add a managed resource from another assembly.
 /// </summary>
 /// <param name="resName">The name of the resource</param>
 /// <param name="assem">The assembly where the resource is</param>
 /// <param name="isPublic">Access for the resource</param>
 public void AddExternalManagedResource (string resName, AssemblyRef assem, uint flags) {
   resources.Add (new ManifestResource (resName, flags, assem));
 }

		public ClassSig Type(string ns, string name, AssemblyRef asmRef) {
			return (ClassSig)Type(false, ns, name, asmRef);
		}

 public void Write(ISyntaxHighlightOutput output, ILanguage language, AssemblyRef asmRef, bool showToken)
 {
     output.Write(NameUtils.CleanIdentifier(asmRef.Name), TextTokenKind.Text);
     WriteToken(output, asmRef, showToken);
 }

		public void Find() {
			resource = FindCsvmResource();
			vmAssemblyRef = FindVmAssemblyRef();
		}