C# Commit.Select方法代码示例

        public SemanticReleaseNotes ScanCommitMessagesForReleaseNotes(GitReleaseNotesArguments arguments, Commit[] commitsToScan)
        {
            var repoParts = arguments.Repo.Split('/');
            var organisation = repoParts[0];
            var repository = repoParts[1];

            var issueNumbersToScan = _issueNumberExtractor.GetIssueNumbers(arguments, commitsToScan, @"#(?<issueNumber>\d+)");

            var since = commitsToScan.Select(c=>c.Author.When).Min();
            var potentialIssues = _gitHubClient.Issue.GetForRepository(organisation, repository, new RepositoryIssueRequest
            {
                Filter = IssueFilter.All,
                Since = since,
                State = ItemState.Closed
            }).Result;

            var closedMentionedIssues = potentialIssues
                .Where(i => issueNumbersToScan.Contains(i.Number.ToString(CultureInfo.InvariantCulture)))
                .ToArray();

            return new SemanticReleaseNotes(closedMentionedIssues.Select(i=>
            {
                var labels = i.Labels == null ? new string[0] : i.Labels.Select(l=>l.Name).ToArray();
                return new ReleaseNoteItem(i.Title, string.Format("#{0}", i.Number), i.HtmlUrl, labels);
            }));
        }

		private void CreateHeadOnlyCommit(string branch, BranchStreamCollection streams, FileCollection allFiles, string branchMergeFrom)
		{
			var headOnlyState = m_headOnlyState[branch];
			var commitId = String.Format("headonly-{0}", branch);
			var commit = new Commit(commitId);

			var message = String.Format("Adding head-only files to {0}", m_branchRenamer.Process(branch));

			foreach (var file in headOnlyState.LiveFiles.OrderBy(i => i, StringComparer.OrdinalIgnoreCase))
			{
				var fileRevision = new FileRevision(allFiles[file], headOnlyState[file],
						mergepoint: Revision.Empty, time: DateTime.Now, author: "", commitId: commitId);
				fileRevision.AddMessage(message);
				commit.Add(fileRevision);
			}

			// check for a merge
			if (branchMergeFrom != null)
			{
				Commit mergeSource = streams.Head(branchMergeFrom);
				if (mergeSource.CommitId.StartsWith("headonly-"))
				{
					commit.MergeFrom = mergeSource;

					// check for deleted files
					var fileLookup = new HashSet<string>(commit.Select(r => r.File.Name));
					foreach (var r in mergeSource)
					{
						if (!fileLookup.Contains(r.File.Name))
						{
							var fileRevision = new FileRevision(
									file: r.File,
									revision: Revision.Empty,   // a bit lazy, but I think we can get away with it
									mergepoint: Revision.Empty,
									time: DateTime.Now,
									author: "",
									commitId: commitId,
									isDead: true);
							fileRevision.AddMessage(message);
							commit.Add(fileRevision);
						}
					}
				}
			}

			if (commit.Any())
			{
				m_log.WriteLine("Added commit {0}", commitId);
				streams.AppendCommit(commit);
			}
		}

        /// <summary>
        ///   To stream.
        /// </summary>
        /// <param name="commiters">The commiters.</param>
        /// <param name="outputStream">The output stream.</param>
        /// <returns>A stream containing markup contents.</returns>
        public Stream ToStream(Commit[] commiters, Stream outputStream = null)
        {
            MemoryStream memory = new MemoryStream();
            StreamWriter writer;

            if (outputStream == null)
            {
                writer = new StreamWriter(memory);
            }
            else
            {
                writer = new StreamWriter(outputStream);
            }

            foreach (TextBlock block in this._blocks)
            {
                switch (block.Type)
                {
                    case BlockType.Author:

                        var uniqueAuthors = commiters.Select(x => x.Author).Distinct();

                        foreach (var author in uniqueAuthors)
                        {
                            this.WriteAuthors(
                                    writer,
                                    block,
                                    commiters.Where(x => x.Author.Equals(author)).ToArray());

                            if (!string.IsNullOrEmpty(block.PostText))
                            {
                                var last = uniqueAuthors.Last();

                                // Add the separator if it is not the last route.
                                if (last != author)
                                {
                                    writer.Write(block.PostText);
                                    writer.Flush();
                                }
                            }
                        }

                        break;

                    case BlockType.Date:

                        // Stub.

                        break;

                    default:

                        int idx;

                        // Search for y-min tokens.
                        while ((idx = block.Text.IndexOf("{ymin}", StringComparison.CurrentCultureIgnoreCase)) > -1)
                        {
                            block.Text = block.Text.Replace(
                                block.Text.Substring(idx, "{ymin}".Length),
                                commiters.Min(x => x.LinesOfChange).ToString());
                        }

                        // Search for y-max tokens.
                        while ((idx = block.Text.IndexOf("{ymax}", StringComparison.CurrentCultureIgnoreCase)) > -1)
                        {
                            block.Text = block.Text.Replace(
                                block.Text.Substring(idx, "{ymax}".Length),
                                commiters.Max(x => x.LinesOfChange).ToString());
                        }

                        // Search for y-min tokens.
                        while ((idx = block.Text.IndexOf("{xmin}", StringComparison.CurrentCultureIgnoreCase)) > -1)
                        {
                            block.Text = block.Text.Replace(
                                block.Text.Substring(idx, "{xmin}".Length),
                                ConvertToJavascriptTimestamp(commiters.Min(x => x.Date)).ToString());
                        }

                        // Search for y-max tokens.
                        while ((idx = block.Text.IndexOf("{xmax}", StringComparison.CurrentCultureIgnoreCase)) > -1)
                        {
                            block.Text = block.Text.Replace(
                                block.Text.Substring(idx, "{xmax}".Length),
                                ConvertToJavascriptTimestamp(commiters.Max(x => x.Date)).ToString());
                        }

                        // Nothing to see here.
                        writer.Write(block.Text);
                        writer.Flush();

                        break;
                }
            }

//.........这里部分代码省略.........