web-dev-qa-db-fra.com

Exécutez les commandes git à partir d'une fonction C #

Comment mon code C # peut-il exécuter des commandes git lorsqu'il détecte des modifications dans un fichier suivi? J'écris un projet de console VisualStudio/C # à cet effet.

Je suis nouveau dans l'environnement .NET et je travaille actuellement sur l'intégration de validations GIT automatisées dans un dossier. J'ai besoin de valider automatiquement tout changement/ajout/suppression sur un dossier connu et de le pousser vers une télécommande git. Toute orientation appréciée. Je vous remercie.

Voici ce que j'ai et le dernier est celui avec lequel j'ai besoin de conseils:

  1. Le référentiel Git est initialement configuré sur un dossier avec un fichier ignoré approprié (terminé).
  2. J'utilise C # FileSystemWatcher pour attraper toutes les modifications sur ledit dossier (terminé).
  3. Une fois que mon projet détecte une modification, il doit valider et pousser ces modifications (en attente).

Commandes provisoires que le projet doit exécuter:

git add -A
git commit "explanations_of_changes"
git Push our_remote

REMARQUE: ce code (sans interaction avec l'utilisateur) sera la seule entité à s'engager dans ce dépôt, donc je ne suis pas inquiet des conflits et je pense que ce flux fonctionnera.

c#gitvisual-studio-2013version-controlwindows-7
16
Yuri

Si vous voulez le faire en C #, vous pouvez appeler la commande git externe par Process.Start lorsque vous détectez un changement de fichier

string gitCommand = "git";
string gitAddArgument = @"add -A" ;
string gitCommitArgument = @"commit ""explanations_of_changes"" "
string gitPushArgument = @"Push our_remote"

Process.Start(gitCommand, gitAddArgument );
Process.Start(gitCommand, gitCommitArgument );
Process.Start(gitCommand, gitPushArgument );

Pas la meilleure solution mais ça marche en C #

11
palazzo train

Je me rends compte que c'est une vieille question, mais je voulais ajouter la solution que j'ai récemment trouvée pour aider ceux à l'avenir.

La classe PowerShell fournit un moyen simple d'interagir avec git. Cela fait partie de l'espace de noms System.Management.Automation Dans .NET. Notez que System.Management.Automation.dll est disponible via NuGet.

string directory = ""; // directory of the git repository

using (PowerShell powershell = PowerShell.Create()) {
    // this changes from the user folder that PowerShell starts up with to your git repository
    powershell.AddScript($"cd {directory}");

    powershell.AddScript(@"git init");
    powershell.AddScript(@"git add *");
    powershell.AddScript(@"git commit -m 'git commit from PowerShell in C#'");
    powershell.AddScript(@"git Push");

    Collection<PSObject> results = powershell.Invoke();
}

À mon avis, c'est plus propre et plus agréable que d'utiliser l'approche Process.Start(). Vous pouvez le modifier selon vos besoins spécifiques en modifiant les scripts ajoutés à l'objet powershell.

Comme l'a commenté @ArtemIllarionov, powershell.Invoke() ne renvoie pas d'erreurs mais la propriété Streams a des informations de sortie. Plus précisément powerShell.Streams.Error Pour les erreurs.

24
ivcubr
    //Console.WriteLine(CommandOutput("git status"));

    public static string CommandOutput(string command,
                                       string workingDirectory = null)
    {
        try
        {
            ProcessStartInfo procStartInfo = new ProcessStartInfo("cmd", "/c " + command);

            procStartInfo.RedirectStandardError = procStartInfo.RedirectStandardInput = procStartInfo.RedirectStandardOutput = true;
            procStartInfo.UseShellExecute = false;
            procStartInfo.CreateNoWindow = true;
            if (null != workingDirectory)
            {
                procStartInfo.WorkingDirectory = workingDirectory;
            }

            Process proc = new Process();
            proc.StartInfo = procStartInfo;
            proc.Start();

            StringBuilder sb = new StringBuilder();
            proc.OutputDataReceived += delegate (object sender, DataReceivedEventArgs e)
            {
                sb.AppendLine(e.Data);
            };
            proc.ErrorDataReceived += delegate (object sender, DataReceivedEventArgs e)
            {
                sb.AppendLine(e.Data);
            };

            proc.BeginOutputReadLine();
            proc.BeginErrorReadLine();
            proc.WaitForExit();
            return sb.ToString();
        }
        catch (Exception objException)
        {
            return $"Error in command: {command}, {objException.Message}";
        }
    }
4
Raj kumar

Une alternative serait de configurer Grunt et TaskRunner avec votre projet.

Grunt devrait être en mesure de fournir l'automatisation de la détection des modifications d'un dossier (ou des dossiers) dans votre projet et d'exécuter les commandes git appropriées pour le valider.

Task Runner vous permet d'initialiser et d'exécuter Grunt à partir de Visual Studio.

L'équipe de Visual Studio a indiqué que Task Runner allait être intégré dans les futures versions de Visual Studio, donc cela pourrait être une solution à long terme.

Remarque: Cela a été mentionné dans les commentaires, mais je pense qu'il vaut la peine de mentionner à nouveau que la validation automatique à chaque fois qu'un fichier est enregistré dans le référentiel n'est pas la meilleure pratique. Vous voulez que les modifications du code fonctionnel/atomique soient intégrées, pas de simples modifications de texte. Auto-Commit à vos risques et périls.

2
Dillie-O