C# IAssemblyName类代码示例

		public static extern int CreateAssemblyEnum(
			out IAssemblyEnum ppEnum,
			IApplicationContext pAppCtx,
			IAssemblyName pName,
			uint dwFlags,
			int pvReserved
			);

        public InstallReferenceEnumerator(IAssemblyName assemblyName)
        {
            var hr = FusionImports.CreateInstallReferenceEnum(out refEnum, assemblyName, 0, IntPtr.Zero);

            if (hr < 0)
            {
                Marshal.ThrowExceptionForHR(hr);
            }
        }

        private String GetFullName(IAssemblyName fusionAsmName)
        {
            StringBuilder sDisplayName = new StringBuilder(1024);
            int iLen = 1024;

            int hr = fusionAsmName.GetDisplayName(sDisplayName, ref iLen, (int)AssemblyNameDisplayFlags.ALL);
            if (hr < 0) {
                Marshal.ThrowExceptionForHR(hr);
            }

            return sDisplayName.ToString();
        }

 public ExecuteScriptCommand(string script,
     string[] scriptArgs,
     IFileSystem fileSystem,
     IScriptExecutor scriptExecutor,
     IScriptPackResolver scriptPackResolver,
     ILog logger,
     IAssemblyName assemblyName)
 {
     _script = script;
     ScriptArgs = scriptArgs;
     _fileSystem = fileSystem;
     _scriptExecutor = scriptExecutor;
     _scriptPackResolver = scriptPackResolver;
     _logger = logger;
     _assemblyName = assemblyName;
 }

 public ExecuteReplCommand(
     IFileSystem fileSystem,
     IScriptPackResolver scriptPackResolver,
     IScriptEngine scriptEngine,
     IFilePreProcessor filePreProcessor,
     ILog logger,
     IConsole console,
     IAssemblyName assemblyName
     )
 {
     _fileSystem = fileSystem;
     _scriptPackResolver = scriptPackResolver;
     _scriptEngine = scriptEngine;
     _filePreProcessor = filePreProcessor;
     _logger = logger;
     _console = console;
     _assemblyName = assemblyName;
 }

        private static string GetDisplayName(IAssemblyName native)
        {
            int bufferSize = 1024;
            StringBuilder buffer = new StringBuilder(bufferSize);

            AssemblyDisplayFlags dwDisplayFlags = AssemblyDisplayFlags.ProcessorArchitecture |
                                                  AssemblyDisplayFlags.PublicKeyToken |
                                                  AssemblyDisplayFlags.LanguageId |
                                                  AssemblyDisplayFlags.Culture |
                                                  AssemblyDisplayFlags.Version;

            if (NativeMethods.SUCCESS == native.GetDisplayName(buffer, ref bufferSize, dwDisplayFlags))
            {
                return buffer.ToString();
            }

            return null;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AssemblyDescription"/> class.
        /// </summary>
        /// <param name="assemblyName">Name of the assembly.</param>
        public AssemblyDescription(IAssemblyName assemblyName)
        {
            //  Get the qualified name.
            var stringBuilder = new StringBuilder(10000);
            var iLen = 10000;
            var hr = assemblyName.GetDisplayName(stringBuilder, ref iLen, ASM_DISPLAY_FLAGS.ASM_DISPLAYF_VERSION
                | ASM_DISPLAY_FLAGS.ASM_DISPLAYF_CULTURE
                | ASM_DISPLAY_FLAGS.ASM_DISPLAYF_PUBLIC_KEY_TOKEN
                | ASM_DISPLAY_FLAGS.ASM_DISPLAYF_PROCESSORARCHITECTURE);
            if (hr < 0)
                Marshal.ThrowExceptionForHR(hr);
            var displayName = stringBuilder.ToString();

            //  Load properties from the display name.
            LoadPropertiesFromDisplayName(displayName);

            //  We have the assembly name, so we can use the optimised version to load the fusion properties.
            lazyFusionProperties = new Lazy<AssemblyFusionProperties>(DoLoadFusionProperties);
            lazyReflectionProperties = new Lazy<AssemblyReflectionProperties>(DoLoadReflectionProperties);
        }

        public static AssemblyName ToAssemblyName(IAssemblyName native)
        {
            string displayName = GetDisplayName(native);

            using (AssemblyCache cache = new AssemblyCache())
            {
                // according to MSKB, this is a SUPPORTED method, therefore we can use the obtained path
                // in the ASSEMBLY_INFO struct to generate a fully-populated AssemblyName object.
                // see: http://support.microsoft.com/kb/317540

                string path = cache.QueryAssemblyPath(displayName);

                if (path != null)
                {
                    return AssemblyName.GetAssemblyName(path);
                }
            }

            return new AssemblyName(displayName);
        }

 public ScriptServiceRoot(
     IFileSystem fileSystem,
     IPackageAssemblyResolver packageAssemblyResolver, 
     IScriptExecutor executor,
     IScriptEngine engine,
     IFilePreProcessor filePreProcessor,
     IScriptPackResolver scriptPackResolver, 
     IPackageInstaller packageInstaller,
     ILog logger,
     IAssemblyName assemblyName,
     IConsole console = null)
 {
     FileSystem = fileSystem;
     PackageAssemblyResolver = packageAssemblyResolver;
     Executor = executor;
     Engine = engine;
     FilePreProcessor = filePreProcessor;
     ScriptPackResolver = scriptPackResolver;
     PackageInstaller = packageInstaller;
     Logger = logger;
     Console = console;
     AssemblyName = assemblyName;
 }

 private static extern void CreateAssemblyEnum(out IAssemblyEnum pEnum, IntPtr pUnkReserved, IAssemblyName pName,
     ASM_CACHE_FLAGS dwFlags, IntPtr pvReserved);

 /// <summary>
 ///     Get the next assembly name in the current enumerator or fail
 /// </summary>
 /// <param name="enumerator"></param>
 /// <param name="name"></param>
 /// <returns>0 if the enumeration is not at its end</returns>
 public static int GetNextAssembly(IAssemblyEnum enumerator, out IAssemblyName name)
 {
     return enumerator.GetNextAssembly((IntPtr) 0, out name, 0);
 }

 private static extern int CreateAssemblyNameObject(out IAssemblyName ppName, string szAssemblyName, uint dwFlags, int pvReserved);

 internal UInt16 GetShortProperty(IAssemblyName name, ASM_NAME propertyName)
 {
     uint bufferSize = 512;
     IntPtr buffer = Marshal.AllocHGlobal((int)bufferSize);
     name.GetProperty(propertyName, buffer, ref bufferSize);
     byte low = Marshal.ReadByte(buffer);
     byte high = Marshal.ReadByte(buffer, 1);
     Marshal.FreeHGlobal(buffer);
     return (UInt16)(low + (high << 8));
 }

 internal byte[] GetByteArrayProperty(IAssemblyName name, ASM_NAME propertyName)
 {
     uint bufferSize = 512;
     IntPtr buffer = Marshal.AllocHGlobal((int)bufferSize);
     name.GetProperty(propertyName, buffer, ref bufferSize);
     byte[] result = new byte[bufferSize];
     for (int i = 0; i < bufferSize; i++)
         result[i] = Marshal.ReadByte(buffer, i);
     Marshal.FreeHGlobal(buffer);
     return result;
 }

 internal static extern int CreateAssemblyNameObject(out IAssemblyName ppEnum, String szAssemblyName, uint dwFlags, IntPtr pvReserved);