C# AssemblyInfo类代码示例

        public static bool IsAssemblyInGAC(string assemblyName)
        {
            var assembyInfo = new AssemblyInfo { cchBuf = 512 };
            assembyInfo.currentAssemblyPath = new string('\0', assembyInfo.cchBuf);

            IAssemblyCache assemblyCache;

            var hr = CreateAssemblyCache(out assemblyCache, 0);

            if (hr == IntPtr.Zero)
            {
                hr = assemblyCache.QueryAssemblyInfo(
                    1,
                    assemblyName,
                    ref assembyInfo);

                if (hr != IntPtr.Zero)
                {
                    return false;
                }

                return true;
            }

            Marshal.ThrowExceptionForHR(hr.ToInt32());
            return false;
        }

        /// <summary>
        /// Registers the specified assembly and resolves the types in it when the AppDomain requests for it.
        /// </summary>
        /// <param name="assemblyFilePath">The path to the assemly to load in the LoadFrom context.</param>
        /// <remarks>This method does not load the assembly immediately, but lazily until someone requests a <see cref="Type"/>
        /// declared in the assembly.</remarks>
        public void LoadAssemblyFrom(string assemblyFilePath)
        {
            if (!this.handlesAssemblyResolve)
            {
                AppDomain.CurrentDomain.AssemblyResolve += this.CurrentDomain_AssemblyResolve;
                this.handlesAssemblyResolve = true;
            }

            Uri assemblyUri = GetFileUri(assemblyFilePath);

            if (assemblyUri == null)
            {
                throw new ArgumentException(Resources.InvalidArgumentAssemblyUri, "assemblyFilePath");
            }

            if (!File.Exists(assemblyUri.LocalPath))
            {
                throw new FileNotFoundException();
            }

            AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyUri.LocalPath);
            AssemblyInfo assemblyInfo = this.registeredAssemblies.FirstOrDefault(a => assemblyName == a.AssemblyName);

            if (assemblyInfo != null)
            {
                return;
            }

            assemblyInfo = new AssemblyInfo() { AssemblyName = assemblyName, AssemblyUri = assemblyUri };
            this.registeredAssemblies.Add(assemblyInfo);
        }

 private void AddAssemblyToList(AssemblyInfo info)
 {
     if (info != null && info.IsManagedAssembly)
       {
     listViewAssemblies.Items.Add(CreateListViewItem(info));
       }
 }

        private void Render(XmlWriter reportBuilder, AssemblyInfo assemblyInfo, IEnumerable<ContextInfo> contexts)
        {
            reportBuilder.WriteStartElement("testsuite");
            reportBuilder.WriteAttributeString("name", assemblyInfo.Name);

            // gather statistics
            var specsInThisAssembly = contexts.SelectMany(x => SpecificationsByContext[x]);

            var specsByResult = specsInThisAssembly.GroupBy(x => ResultsBySpecification[x].Status)
                .ToDictionary(x => x.Key, x => x.Count());

            reportBuilder.WriteAttributeString("test", specsInThisAssembly.Count().ToString());
            reportBuilder.WriteAttributeString("failures", specsByResult.ContainsKey(Status.Failing) ? specsByResult[Status.Failing].ToString() : "0");
            reportBuilder.WriteAttributeString("skipped",
                ((specsByResult.ContainsKey(Status.Ignored) ? specsByResult[Status.Ignored] : 0) +
                 (specsByResult.ContainsKey(Status.NotImplemented) ? specsByResult[Status.NotImplemented] : 0)).ToString());
            

            foreach (var entry in contexts.GroupBy(x => x.Concern))
            {
                RenderTestsForConcern(reportBuilder, entry.Key, entry);
            }

            reportBuilder.WriteEndElement();
        }

        /// <summary>
        /// Registers the specified assembly and resolves the types in it when the AppDomain requests for it.
        /// </summary>
        /// <param name="assemblyFilePath">The path to the assemly to load in the LoadFrom context.</param>
        /// <remarks>This method does not load the assembly immediately, but lazily until someone requests a <see cref="Type"/>
        /// declared in the assembly.</remarks>
        public async void LoadAssemblyFrom(string assemblyFilePath)
        {
            //if (!this.handlesAssemblyResolve)
            //{
            //    AppDomain.CurrentDomain.AssemblyResolve += this.CurrentDomain_AssemblyResolve;
            //    this.handlesAssemblyResolve = true;
            //}

            Uri assemblyUri = GetFileUri(assemblyFilePath);

            if (assemblyUri == null)
            {
                throw new ArgumentException(ResourceHelper.InvalidArgumentAssemblyUri, "assemblyFilePath");
            }

            StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri(assemblyUri.AbsoluteUri));

            AssemblyName assemblyName = new AssemblyName { Name = file.DisplayName };
            if (this.loadedAssemblies.Any(a => assemblyName == a.AssemblyName))
            {
                return;
            }

            var assembly = Assembly.Load(assemblyName);
            var assemblyInfo = new AssemblyInfo() { AssemblyName = assemblyName, AssemblyUri = assemblyUri, Assembly = assembly };
            this.loadedAssemblies.Add(assemblyInfo);
        }

        public async Task<TestResult> RunTestAsync(AssemblyInfo assemblyInfo, CancellationToken cancellationToken)
        {
            var contentFile = _contentUtil.GetTestResultContentFile(assemblyInfo);
            var assemblyPath = assemblyInfo.AssemblyPath;
            var builder = new StringBuilder();
            builder.AppendLine($"{Path.GetFileName(assemblyPath)} - {contentFile.Checksum}");
            builder.AppendLine("===");
            builder.AppendLine(contentFile.Content);
            builder.AppendLine("===");
            Logger.Log(builder.ToString());

            try
            {
                var cachedTestResult = await _dataStorage.TryGetCachedTestResult(contentFile.Checksum);
                if (cachedTestResult.HasValue)
                {
                    Logger.Log($"{Path.GetFileName(assemblyPath)} - cache hit");
                    return Migrate(assemblyInfo, cachedTestResult.Value);
                }
            }
            catch (Exception ex)
            {
                Logger.Log($"Error reading cache {ex}");
            }

            Logger.Log($"{Path.GetFileName(assemblyPath)} - running");
            var testResult = await _testExecutor.RunTestAsync(assemblyInfo, cancellationToken);
            await CacheTestResult(contentFile, testResult).ConfigureAwait(true);
            return testResult;
        }

        public static string GetVersion(AssemblyInfo info)
        {
            Assembly assembly = Assembly.GetExecutingAssembly();
            FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
            try
            {
                switch (info)
                {
                    case AssemblyInfo.Title:
                        return fvi.ProductName;
                    case AssemblyInfo.Version:

                        int major = fvi.FileMajorPart;
                        int minor = fvi.FileMinorPart;
                        int rev = fvi.FileBuildPart;

                        string version =
                            major.ToString(CultureInfo.InvariantCulture) + "." +
                            minor.ToString(CultureInfo.InvariantCulture) + "." +
                            rev.ToString(CultureInfo.InvariantCulture);
                        return version;

                    case AssemblyInfo.Company:
                        return fvi.CompanyName;
                }
            }
            catch (Exception)
            {
                return null;
            }
            return null;
        }

        private string BuildTestResultContent(AssemblyInfo assemblyInfo)
        {
            var builder = new StringBuilder();
            var assemblyPath = assemblyInfo.AssemblyPath;
            builder.AppendLine($"Assembly: {Path.GetFileName(assemblyPath)} {GetFileChecksum(assemblyPath)}");
            builder.AppendLine($"Display Name: {assemblyInfo.DisplayName}");
            builder.AppendLine($"Results File Name; {assemblyInfo.ResultsFileName}");

            var configFilePath = $"{assemblyPath}.config";
            var configFileChecksum = File.Exists(configFilePath)
                ? GetFileChecksum(configFilePath)
                : "<no config file>";
            builder.AppendLine($"Config: {Path.GetFileName(configFilePath)} {configFileChecksum}");

            builder.AppendLine($"Xunit: {Path.GetFileName(_options.XunitPath)} {GetFileChecksum(_options.XunitPath)}");
            AppendReferences(builder, assemblyPath);
            builder.AppendLine("Options:");
            builder.AppendLine($"\t{nameof(_options.Test64)} - {_options.Test64}");
            builder.AppendLine($"\t{nameof(_options.UseHtml)} - {_options.UseHtml}");
            builder.AppendLine($"\t{nameof(_options.Trait)} - {_options.Trait}");
            builder.AppendLine($"\t{nameof(_options.NoTrait)} - {_options.NoTrait}");
            builder.AppendLine($"Extra Options: {assemblyInfo.ExtraArguments}");

            return builder.ToString();
        }

        public void AssemblyInfoExecute()
        {
            AssemblyInfo task = new AssemblyInfo();
            task.BuildEngine = new MockBuild();
            task.CodeLanguage = "cs";
            string outputFile = Path.Combine(testDirectory, "AssemblyInfo.cs");
            task.OutputFile = outputFile;
            task.AssemblyTitle = "AssemblyInfoTask";
            task.AssemblyDescription = "AssemblyInfo Description";
            task.AssemblyConfiguration = "";
            task.AssemblyCompany = "Company Name, LLC";
            task.AssemblyProduct = "AssemblyInfoTask";
            task.AssemblyCopyright = "Copyright (c) Company Name, LLC 2005";
            task.AssemblyTrademark = "";
            task.ComVisible = false;
            task.CLSCompliant = true;
            task.Guid = "d038566a-1937-478a-b5c5-b79c4afb253d";
            task.AssemblyVersion = "1.2.3.4";
            task.AssemblyFileVersion = "1.2.3.4";
            task.AssemblyInformationalVersion = "1.2.3.4";
            task.AssemblyKeyFile = @"..\MSBuild.Community.Tasks\MSBuild.Community.Tasks.snk";
            Assert.IsTrue(task.Execute(), "Execute Failed");

            Assert.IsTrue(File.Exists(outputFile), "File missing: " + outputFile);
        }

        private static ListViewItem CreateListViewItem(AssemblyInfo info)
        {
            var item = new ListViewItem(new string[]
              {
            Path.GetFileName(info.FilePath),
            info.DotNetVersion,
            (info.IsAnyCpu ? "Any CPU" : info.Is32BitOnly ? "x86" : info.Is64BitOnly ? "x64" : "UNKNOWN") + (info.Is32BitPreferred ? " (x86 preferred)" : string.Empty),
            info.IsSigned ? "Yes" : "No",
            info.FilePath
              });

              item.Tag = info.FilePath;
              item.UseItemStyleForSubItems = false;

              // Update the color of the signed column.
              if (info.IsSigned)
              {
            item.SubItems[3].ForeColor = Color.Green;
              }
              else
              {
            item.SubItems[3].ForeColor = Color.Red;
              }

              return item;
        }

 public FrmAbout()
 {
     InitializeComponent();
     var ai = new AssemblyInfo();
     this.Text = String.Format( "О {0}", ai.AssemblyTitle );
     this.txt_vesion_null.Text = String.Format( "{0}", ai.AssemblyVersion );
     this.txt_cr.Text = ai.AssemblyCopyright;
 }

 private static TestCacheData CreateTestCacheData(AssemblyInfo assemblyInfo, string resultsFileName, CachedTestResult testResult)
 {
     return new TestCacheData()
     {
         TestResultData = CreateTestResultData(resultsFileName, testResult),
         TestSourceData = CreateTestSourceData(assemblyInfo)
     };
 }

 public override void OnAssemblyStart(AssemblyInfo assembly)
 {
     _originalDirectory = Directory.GetCurrentDirectory();
     if (assembly.Location != null)
     {
         Directory.SetCurrentDirectory(Path.GetDirectoryName(assembly.Location));
     }
 }

 public IAssemblyInfo LoadFrom(string assemblyName)
 {
     Assembly assembly = Assembly.LoadFrom(assemblyName);
     IAssemblyInfo assemblyInfo = new AssemblyInfo();
     assemblyInfo.Name = assembly.FullName;
     assemblyInfo.Types = LoadTypes(assembly);
     return assemblyInfo;
 }

 static Shell()
 {
     Input = Console.In;
     Output = Console.Out;
     Error = new ErrorConsoleWriter(Console.Error);
     CommandsResolver = Infrastucture.CommandsResolver.Default;
     HelpBuilder = HelpBuilder.Default;
     AssemblyInfo = new AssemblyInfo(Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly());
 }