C# Repository.Commit方法代码示例

 private static void UpdateHomePageContent(Repository repo, string homePath, Signature sig)
 {
     File.AppendAllText(homePath, "\nThis will be a bare bone user experience.\n");
     repo.Index.Stage(homePath);
     repo.Commit(sig, sig,
                 "Add warning to the Home page\n\nA very informational explicit message preventing the user from expecting too much.");
 }

        public void SaveFile(string fileName, string content, string username, string email)
        {
            using (var repo = new Repository(_basePath))
            {
                File.WriteAllText(Path.Combine(repo.Info.WorkingDirectory, fileName), content);

                // stage the file
                repo.Stage(fileName);

                // Create the committer's signature and commit
                //var user = repo.Config.Get<string>("user", "name", null);
                //var email = repo.Config.Get<string>("user", "email", null);

                var author = new Signature(username, email, DateTime.Now);
                var committer = author;

                // Commit to the repo
                var commitMessage = string.Format("Revision: {0}", GetRevisionCount(repo, fileName));
                try
                {
                    var commit = repo.Commit(commitMessage, author, committer);
                    foreach (var parent in commit.Parents)
                    {
                        Console.WriteLine("Id: {0}, Sha: {1}", parent.Id, parent.Sha);
                    }
                }
                catch (EmptyCommitException) { } // I don't care if the user didn't change anything at this time
            }
        }

 private static void RenameMyWishListPage(Repository repo, string myWishListPath, Signature sig)
 {
     repo.Index.Unstage(myWishListPath);
     File.Move(myWishListPath, myWishListPath + "List");
     repo.Index.Stage(myWishListPath + "List");
     repo.Commit(sig, sig, "Fix MyWishList page name");
 }

 /// <summary>
 ///     Commit changes to local repo. Use Github.Add first.
 ///     TODO: Possibly add ability for users to specify msg?
 /// </summary>
 public void Commit()
 {
     using (var repo = new Repository(_LocalRepo))
     {
         repo.Commit("Update via Chuck interface.");
     }
 }

        private void btnCommit_Click(object sender, RibbonControlEventArgs e)
        {
            //Get Active  Project
            var pj = Globals.ThisAddIn.Application.ActiveProject;

            //Get Project Filename.
            var projectFile = pj.FullName;

            //Get Directory from File Name
            var directory = Path.GetDirectoryName(projectFile);

            //Create a new Git Repository
            Repository.Init(directory);

            //Open the git repository in a using context so its automatically disposed of.
            using (var repo = new Repository(directory))
            {
                // Stage the file
                repo.Index.Stage(projectFile);

                // Create the committer's signature and commit
                var author = new Signature("Richard", "@ARM", DateTime.Now);
                var committer = author;

                // Commit to the repository
                var commit = repo.Commit("Initial commit", author, committer);
            }
        }

 public static void CommitChanges(string Message, string RepoPath)
 {
     using (var repo = new Repository(RepoPath))
     {
         logger.Debug("Git commit to " + RepoPath);
         Signature sig = new Signature("SantiagoDevelopment", "[email protected]", DateTimeOffset.Now );
         repo.Commit(Message, sig, sig);
     }
 }

        public string Commit()
        {
            if( string.IsNullOrEmpty( RepoPath ) )
                throw new ArgumentException("Must open first");

            using( Repository repo = new Repository(RepoPath) )
            {
                var author = new Signature(UserName, "nulltoken", DateTimeOffset.Now);
                var commit = repo.Commit("Ganji commit\n", author, author);
                return commit.Id.Sha;
            }
        }

        public void AddModifiedFilesToVersioning(string commitMessage)
        {
            Repository.Init(repositoryPath, false);

            using (var repository = new Repository(repositoryPath))
            {

                var filesToAddToCommit = FilesToCommit(repository);

                if (!filesToAddToCommit.Any())
                {
                    return;
                }

                repository.Index.Stage(filesToAddToCommit);
                repository.Commit(commitMessage);
            }
        }

        public static void Commit(FileInfo file)
        {
            using (var repository = new LibGit2Sharp.Repository(file.DirectoryName))
            {
                try
                {
                    var status = repository.RetrieveStatus(file.FullName);

                    switch (status)
                    {
                        case FileStatus.Unaltered:
                            Log.Add($"Commit, FileStatus: {status}");
                            return;
                        case FileStatus.Nonexistent:
                        case FileStatus.Added:
                        case FileStatus.Staged:
                        case FileStatus.Removed:
                        case FileStatus.RenamedInIndex:
                        case FileStatus.StagedTypeChange:
                        case FileStatus.Untracked:
                        case FileStatus.Modified:
                        case FileStatus.Missing:
                        case FileStatus.TypeChanged:
                        case FileStatus.RenamedInWorkDir:
                            {
                                var commit = repository.Commit("Update", CommitOptions);
                                Log.Add($"Commit: {commit.Message}");
                                break;
                            }
                        case FileStatus.Unreadable:
                        case FileStatus.Ignored:
                            throw new InvalidOperationException($"FileStatus: {status}");
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
                catch (Exception e)
                {
                    Log.Add(e.Message);
                }
            }
        }

        /// <summary>
        /// Initializes a new bare repository at the specified location, adds a repository info file to the root directory
        /// and tags the initial commit with he value of <see cref="InitialCommitTagName"/>
        /// </summary>
        public static void InitializeRepository(string location)
        {            
            // initialize a bare repository
            Repository.Init(location, true);

            var directoryCreator = new LocalItemCreator();

            // clone the repository, add initial commit and push the changes back to the actual repository
            using (var tempDirectory = directoryCreator.CreateTemporaryDirectory())
            {
                var clonedRepoPath = Repository.Clone(location, tempDirectory.Directory.Location);

                var repositoryInfoFile = new RepositoryInfoFile(tempDirectory.Directory);

                // add a empty file to the repository
                directoryCreator.CreateFile(repositoryInfoFile, tempDirectory.Directory.Location);

                // commit and push the file to the bare repository we created
                using (var clonedRepo = new Repository(clonedRepoPath))
                {
                    var signature = SignatureHelper.NewSignature();

                    clonedRepo.Stage(repositoryInfoFile.Name);
                    clonedRepo.Commit("Initial Commit", signature, signature, new CommitOptions());                    

                    clonedRepo.Network.Push(clonedRepo.Network.Remotes["origin"], @"refs/heads/master");                    
                }
            }

            //create the configuration branch pointing to the initial commit
            using (var repository = new Repository(location))
            {
                repository.CreateBranch(ConfigurationBranchName.ToString(), repository.GetAllCommits().Single());
                repository.Tags.Add(InitialCommitTagName, repository.GetAllCommits().Single());
            }
        }

        /// <summary>
        ///     rename the entry with all the hassle that accompanies it.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void RenameToolStripMenuItemClick(object sender, EventArgs e)
        {
            SaveFileDialog newFileDialog = new SaveFileDialog
                                               {
                                                   AddExtension = true,
                                                   AutoUpgradeEnabled = true,
                                                   CreatePrompt = false,
                                                   DefaultExt = "gpg",
                                                   InitialDirectory = Cfg["PassDirectory"],
                                                   Title = Strings.FrmMain_RenameToolStripMenuItemClick_Rename
                                               };
            if (newFileDialog.ShowDialog() == DialogResult.Cancel)
            {
                return;
            }

            string tmpFileName = newFileDialog.FileName;
            newFileDialog.Dispose();

            // ReSharper disable once AssignNullToNotNullAttribute
            Directory.CreateDirectory(path: Path.GetDirectoryName(tmpFileName));
            File.Copy(dirTreeView.SelectedNode.Tag + "\\" + listFileView.SelectedItem + ".gpg", tmpFileName);
            using (var repo = new Repository(Cfg["PassDirectory"]))
                {
                    // add the file
                    repo.Remove(listFileView.SelectedItem.ToString());
                    repo.Stage(tmpFileName);
                    // Commit
                    repo.Commit("password moved", new Signature("pass4win", "pass4win", DateTimeOffset.Now),
                        new Signature("pass4win", "pass4win", DateTimeOffset.Now));

                    if (Cfg["UseGitRemote"] == true && this.gitRepoOffline == false)
                    {
                        //push
                        toolStripOffline.Visible = false;
                        var remote = repo.Network.Remotes["origin"];
                        var options = new PushOptions
                        {
                            CredentialsProvider = (url, user, cred) => new UsernamePasswordCredentials
                            {
                                Username = Cfg["GitUser"],
                                Password = DecryptConfig(Cfg["GitPass"], "pass4win")
                            }
                        };
                        var pushRefSpec = @"refs/heads/master";
                        repo.Network.Push(remote, pushRefSpec, options);
                    }
            }
            this.CreateNodes();
        }

 /// <summary>
 ///     Callback for the encrypt thread
 /// </summary>
 /// <param name="result"></param>
 /// <param name="tmpFile"></param>
 /// <param name="tmpFile2"></param>
 /// <param name="path"></param>
 public void EncryptCallback(GpgInterfaceResult result, string tmpFile, string tmpFile2, string path)
 {
     if (result.Status == GpgInterfaceStatus.Success)
     {
         File.Delete(tmpFile);
         File.Delete(path);
         File.Move(tmpFile2, path);
         // add to git
         using (var repo = new Repository(Cfg["PassDirectory"]))
         {
             // Stage the file
             repo.Stage(path);
             // Commit
             repo.Commit("password changes", new Signature("pass4win", "pass4win", DateTimeOffset.Now),
                 new Signature("pass4win", "pass4win", DateTimeOffset.Now));
             if (Cfg["UseGitRemote"] == true && this.gitRepoOffline == false)
             {
                 toolStripOffline.Visible = false;
                 var remote = repo.Network.Remotes["origin"];
                 var options = new PushOptions
                 {
                     CredentialsProvider = (url, user, cred) => new UsernamePasswordCredentials
                     {
                         Username = Cfg["GitUser"],
                         Password = DecryptConfig(Cfg["GitPass"], "pass4win")
                     }
                 };
                 var pushRefSpec = @"refs/heads/master";
                 repo.Network.Push(remote, pushRefSpec, options);
             }
         }
     }
     else
     {
         MessageBox.Show(Strings.Error_weird_shit_happened_encryption, Strings.Error, MessageBoxButtons.OK,
             MessageBoxIcon.Error);
     }
 }

        public IActionResult GetAQuoteViaGit(QuoteViewModel model)
        {
            var watch = Stopwatch.StartNew();

            string rootedPath = Repository.Init("C:\\temp\\rooted\\path");
            string jsondata = new JavaScriptSerializer().Serialize(model);

            using (var repo = new Repository("C:\\temp\\rooted\\path"))
            {
                // Write content to file system
                System.IO.File.WriteAllText(System.IO.Path.Combine(repo.Info.WorkingDirectory, "output.json"), jsondata);

                // Stage the file
                repo.Stage("output.json");

                // Create the committer's signature and commit
                Signature author = new Signature(model.FirstName, model.Email, DateTime.Now);
                Signature committer = author;

                // Commit to the repository
                try {
                    Commit commit = repo.Commit("Quote committed", author, committer);
                    watch.Stop();
                    var elapsedMs = watch.ElapsedMilliseconds;

                    if (ModelState.IsValid)
                    {
                        ViewBag.Message = "Quote number is: " + commit.Id + " Time taken: " + elapsedMs + "ms";
                    }
                }
                catch(Exception ex)
                {
                    ViewBag.Message = "Nothing to commit";
                }
            }
            return View();
        }

        private void renameToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // rename the entry
            InputBoxValidation validation = delegate(string val)
            {
                if (val == "")
                    return "Value cannot be empty.";
                if (new Regex(@"[a-zA-Z0-9-\\_]+/g").IsMatch(val))
                    return "Not a valid name, can only use characters or numbers and - \\.";
                if (File.Exists(Properties.Settings.Default.PassDirectory + "\\" + @val + ".gpg"))
                    return "Entry already exists.";
                return "";
            };

            string value = dataPass.Rows[dataPass.CurrentCell.RowIndex].Cells[1].Value.ToString();
            if (InputBox.Show("Enter a new name", "Name:", ref value, validation) == DialogResult.OK)
            {
                // parse path
                string tmpPath = Properties.Settings.Default.PassDirectory + "\\" + @value + ".gpg";
                Directory.CreateDirectory(Path.GetDirectoryName(tmpPath));
                File.Copy(dataPass.Rows[dataPass.CurrentCell.RowIndex].Cells[0].Value.ToString(), tmpPath);
                using (var repo = new Repository(Properties.Settings.Default.PassDirectory))
                {
                    // add the file
                    repo.Remove(dataPass.Rows[dataPass.CurrentCell.RowIndex].Cells[0].Value.ToString());
                    repo.Stage(tmpPath);
                    // Commit
                    repo.Commit("password moved", new Signature("pass4win", "pass4win", System.DateTimeOffset.Now), new Signature("pass4win", "pass4win", System.DateTimeOffset.Now));
                    //push
                    var remote = repo.Network.Remotes["origin"];
                    var options = new PushOptions();
                    options.CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials
                    {
                        Username = GitUsername,
                        Password = GitPassword
                    };
                    var pushRefSpec = @"refs/heads/master";
                    repo.Network.Push(remote, pushRefSpec, options, new Signature("pass4win", "[email protected]", DateTimeOffset.Now),
                        "pushed changes");
                }
                ResetDatagrid();

            }
        }

//.........这里部分代码省略.........
                    // creating new Git
                    Repository.Init(Properties.Settings.Default.PassDirectory);
                    Properties.Settings.Default.GitUser = EncryptConfig("RandomGarbage", "pass4win");
                    Properties.Settings.Default.GitPass = EncryptConfig("RandomGarbage", "pass4win");
                }
            }
            else
            {
                // so we have a repository let's load the user/pass
                if (Properties.Settings.Default.GitUser != "")
                {
                    GitUsername = DecryptConfig(Properties.Settings.Default.GitUser, "pass4win");
                    GitPassword = DecryptConfig(Properties.Settings.Default.GitPass, "pass4win");
                }
                else
                {
                    string value = "";
                    if (InputBox.Show("Username", "Remote Username:", ref value) == DialogResult.OK)
                    {
                        GitUsername = value;
                        value = "";
                        if (InputBox.Show("Password", "Remote Password:", ref value) == DialogResult.OK)
                        {
                            GitPassword = value;
                        }
                    }
                    if (GitUsername == null)
                    {
                        MessageBox.Show("We really need a username. Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        System.Environment.Exit(1);
                    }
                    if (GitPassword == null)
                    {
                        MessageBox.Show("We really need a password. Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        System.Environment.Exit(1);
                    }
                    Properties.Settings.Default.GitUser = EncryptConfig(GitUsername, "pass4win");
                    Properties.Settings.Default.GitPass = EncryptConfig(GitPassword, "pass4win");
                }

                // Check if we have the latest
                using (var repo = new Repository(Properties.Settings.Default.PassDirectory))
                {
                    Signature Signature = new Signature("pass4win","[email protected]", new DateTimeOffset(2011, 06, 16, 10, 58, 27, TimeSpan.FromHours(2)));
                    FetchOptions fetchOptions = new FetchOptions();
                    fetchOptions.CredentialsProvider = (_url, _user, _cred) => new UsernamePasswordCredentials
                                        {
                                            Username = GitUsername,
                                            Password = GitPassword
                                        };
                    MergeOptions mergeOptions = new MergeOptions();
                    PullOptions pullOptions = new PullOptions();
                    pullOptions.FetchOptions = fetchOptions;
                    pullOptions.MergeOptions = mergeOptions;
                    MergeResult mergeResult = repo.Network.Pull(Signature, pullOptions);
                }

            }

            // Init GPG if needed
            string gpgfile = Properties.Settings.Default.PassDirectory;
            gpgfile += "\\.gpg-id";
            // Check if we need to init the directory
            if (!File.Exists(gpgfile))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(gpgfile));
                KeySelect newKeySelect = new KeySelect();
                if (newKeySelect.ShowDialog() == DialogResult.OK)
                {
                    using (StreamWriter w = new StreamWriter(gpgfile))
                    {
                        w.Write(newKeySelect.gpgkey);
                    }
                    using (var repo = new Repository(Properties.Settings.Default.PassDirectory))
                    {
                        repo.Stage(gpgfile);
                        repo.Commit("gpgid added", new Signature("pass4win", "pass4win", System.DateTimeOffset.Now), new Signature("pass4win", "pass4win", System.DateTimeOffset.Now));
                    }
                }
                else
                {
                    MessageBox.Show("Need key...... Restart the program and try again.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    System.Environment.Exit(1);
                }
            }
            // Setting the exe location for the GPG Dll
            GpgInterface.ExePath = Properties.Settings.Default.GPGEXE;

            // saving settings
            Properties.Settings.Default.Save();

            // Setting up datagrid
            dt.Columns.Add("colPath", typeof(string));
            dt.Columns.Add("colText", typeof(string));

            ListDirectory(new DirectoryInfo(Properties.Settings.Default.PassDirectory), "");

            dataPass.DataSource = dt.DefaultView;
            dataPass.Columns[0].Visible=false;
        }