Séparer la chaîne contenant les paramètres de la ligne de commande en chaîne [] en C#

cela m'ennuie qu'il n'y ait pas de fonction pour séparer une chaîne basée sur une fonction qui examine chaque caractère. S'il y en avait, vous pourriez l'écrire comme ceci:

    public static IEnumerable<string> SplitCommandLine(string commandLine)
    {
        bool inQuotes = false;

        return commandLine.Split(c =>
                                 {
                                     if (c == '\"')
                                         inQuotes = !inQuotes;

                                     return !inQuotes && c == ' ';
                                 })
                          .Select(arg => arg.Trim().TrimMatchingQuotes('\"'))
                          .Where(arg => !string.IsNullOrEmpty(arg));
    }

Bien qu'ayant écrit cela, pourquoi ne pas écrire les méthodes d'extension. Bon, vous avez parlé de moi...

tout D'abord, ma propre version de Split qui prend une fonction qui doit décider si le caractère spécifié doit séparer la chaîne:

    public static IEnumerable<string> Split(this string str, 
                                            Func<char, bool> controller)
    {
        int nextPiece = 0;

        for (int c = 0; c < str.Length; c++)
        {
            if (controller(str[c]))
            {
                yield return str.Substring(nextPiece, c - nextPiece);
                nextPiece = c + 1;
            }
        }

        yield return str.Substring(nextPiece);
    }

il peut y avoir des chaînes vides selon la situation, mais peut-être que cette information sera utile dans d'autres cas, donc je ne supprime pas les entrées vides dans cette fonction.

Deuxièmement (et plus généralement) un petit helper qui va couper une paire de citations assorties du début et de la fin d'une chaîne. C'est plus compliqué que la méthode de finition standard - il ne coupera qu'un caractère de chaque extrémité, et il ne coupera pas d'une seule extrémité:

    public static string TrimMatchingQuotes(this string input, char quote)
    {
        if ((input.Length >= 2) && 
            (input[0] == quote) && (input[input.Length - 1] == quote))
            return input.Substring(1, input.Length - 2);

        return input;
    }

et je suppose que vous voulez aussi des tests. Bien, très bien. Mais ce doit être absolument la dernière chose! D'abord une fonction d'assistance qui compare le résultat de la scission avec le contenu du tableau:

    public static void Test(string cmdLine, params string[] args)
    {
        string[] split = SplitCommandLine(cmdLine).ToArray();

        Debug.Assert(split.Length == args.Length);

        for (int n = 0; n < split.Length; n++)
            Debug.Assert(split[n] == args[n]);
    }

alors je peux écrire des tests comme celui-ci:

        Test("");
        Test("a", "a");
        Test(" abc ", "abc");
        Test("a b ", "a", "b");
        Test("a b \"c d\"", "a", "b", "c d");

voici le test pour vos exigences:

        Test(@"/src:""C:\tmp\Some Folder\Sub Folder"" /users:""abcdefg@hijkl.com"" tasks:""SomeTask,Some Other Task"" -someParam",
             @"/src:""C:\tmp\Some Folder\Sub Folder""", @"/users:""abcdefg@hijkl.com""", @"tasks:""SomeTask,Some Other Task""", @"-someParam");

notez que l'implémentation a la caractéristique supplémentaire de supprimer les guillemets autour d'un argument si cela a du sens (grâce à la fonction TrimMatchingQuotes). Je crois que cela fait partie de l'interprétation normale en ligne de commande.

L'analyseur de ligne de commande de Windows se comporte comme vous le dites, divisé sur l'espace à moins qu'il n'y ait une citation non fermée avant lui. Je recommande d'écrire l'analyseur vous-même. Quelque chose comme ceci peut-être:

    static string[] ParseArguments(string commandLine)
    {
        char[] parmChars = commandLine.ToCharArray();
        bool inQuote = false;
        for (int index = 0; index < parmChars.Length; index++)
        {
            if (parmChars[index] == '"')
                inQuote = !inQuote;
            if (!inQuote && parmChars[index] == ' ')
                parmChars[index] = '\n';
        }
        return (new string(parmChars)).Split('\n');
    }

j'ai pris la réponse de Jeffrey L Whitledge et il amélioré un peu.

il supporte maintenant les guillemets simples et doubles. Vous pouvez utiliser des guillemets dans les paramètres eux-mêmes en utilisant d'autres guillemets dactylographiés.

il supprime également les citations des arguments car ceux-ci ne contribuent pas à l'information de l'argument.

    public static string[] SplitArguments(string commandLine)
    {
        var parmChars = commandLine.ToCharArray();
        var inSingleQuote = false;
        var inDoubleQuote = false;
        for (var index = 0; index < parmChars.Length; index++)
        {
            if (parmChars[index] == '"' && !inSingleQuote)
            {
                inDoubleQuote = !inDoubleQuote;
                parmChars[index] = '\n';
            }
            if (parmChars[index] == '\'' && !inDoubleQuote)
            {
                inSingleQuote = !inSingleQuote;
                parmChars[index] = '\n';
            }
            if (!inSingleQuote && !inDoubleQuote && parmChars[index] == ' ')
                parmChars[index] = '\n';
        }
        return (new string(parmChars)).Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
    }

Le bonne et pure solution gérée par Earwicker n'a pas pu gérer des arguments comme:

Test("\"He whispered to her \\"I love you\\".\"", "He whispered to her \"I love you\".");

Il a retourné 3 éléments:

"He whispered to her \"I
love
you\"."

donc voici un correctif pour soutenir le "cité \" escape\" citation":

public static IEnumerable<string> SplitCommandLine(string commandLine)
{
    bool inQuotes = false;
    bool isEscaping = false;

    return commandLine.Split(c => {
        if (c == '\' && !isEscaping) { isEscaping = true; return false; }

        if (c == '\"' && !isEscaping)
            inQuotes = !inQuotes;

        isEscaping = false;

        return !inQuotes && Char.IsWhiteSpace(c)/*c == ' '*/;
        })
        .Select(arg => arg.Trim().TrimMatchingQuotes('\"').Replace("\\"", "\""))
        .Where(arg => !string.IsNullOrEmpty(arg));
}

Testé avec 2 cas supplémentaires:

Test("\"C:\Program Files\"", "C:\Program Files");
Test("\"He whispered to her \\"I love you\\".\"", "He whispered to her \"I love you\".");

a également noté que le réponse acceptée par Atif Aziz qui utilise CommandLineToArgvW aussi échoué. Il a retourné 4 éléments:

He whispered to her \ 
I 
love 
you". 

Espérons que cela aide quelqu'un à la recherche d'une telle solution dans le futur.

environnement.GetCommandLineArgs ()

j'aime les itérateurs, et de nos jours LINQ rend IEnumerable < String> aussi facilement utilisable que des tableaux de chaîne, donc mon point de vue suivant l'esprit de la réponse de Jeffrey l Whitledge est (comme une méthode d'extension de chaîne):

    public static IEnumerable<string> ParseArguments(this string commandLine)
    {
        if (string.IsNullOrWhiteSpace(commandLine))
            yield break;
        var sb = new StringBuilder();
        bool inQuote = false;
        foreach (char c in commandLine) {
            if (c == '"' && !inQuote) {
                inQuote = true;
                continue;
            }
            if (c != '"' && !(char.IsWhiteSpace(c) && !inQuote)) {
                sb.Append(c);
                continue;
            }
            if (sb.Length > 0) {
                var result = sb.ToString();
                sb.Clear();
                inQuote = false;
                yield return result;
            }
        }
        if (sb.Length > 0)
            yield return sb.ToString();
    }

Ce Le Projet de Code de l'article est ce que j'ai utilisé dans le passé. C'est un bon code, mais ça pourrait marcher.

ce article MSDN est la seule chose que j'ai pu trouver qui explique comment C# analyse les arguments en ligne de commande.

dans votre question vous avez demandé un regex, et je suis un grand fan et l'utilisateur d'eux, donc quand j'ai eu besoin de faire ce même argument divisé que vous, j'ai écrit mon propre regex après googler autour et ne pas trouver une solution simple. J'aime les solutions courtes, donc j'en ai fait une et la voici:

            var re = @"\G(""((""""|[^""])+)""|(\S+)) *";
            var ms = Regex.Matches(CmdLine, re);
            var list = ms.Cast<Match>()
                         .Select(m => Regex.Replace(
                             m.Groups[2].Success
                                 ? m.Groups[2].Value
                                 : m.Groups[4].Value, @"""""", @"""")).ToArray();

il traite les blancs et les guillemets à l'intérieur des guillemets, et convertit " "fermé à". N'hésitez pas à utiliser le code!

Un purement solution gérée pourrait être utile. Il y a trop de commentaires de "problèmes" pour la fonction WINAPI et elle n'est pas disponible sur d'autres plateformes. Voici mon code a un comportement défini (que vous pouvez modifier si vous le souhaitez).

il devrait faire la même chose que .NET/Windows en fournissant ce paramètre string[] args , et je l'ai comparé avec un certain nombre de valeurs" intéressantes".

C'est un mise en œuvre classique state-machine qui prend chaque caractère de la chaîne d'entrée et l'interprète pour l'état actuel, produisant la sortie et un nouvel état. L'état est défini dans les variables escape , inQuote , hadQuote et prevCh , et la sortie est collectée en currentArg et args .

quelques-unes des spécialités que j'ai découvertes par des expériences sur une invite de commande réelle (Windows 7): \ produit \ , \" produit " , "" produit " .

le personnage de ^ semble aussi magique: il disparaît toujours quand il ne le double pas. Sinon, cela n'a aucun effet sur une ligne de commande réelle. Mon implémentation ne supporte pas cela, car je n'ai pas trouvé de modèle dans ce comportement. Peut-être que quelqu'un en sait plus à ce sujet.

quelque chose qui ne s'inscrit pas dans ce modèle est le suivant commande:

cmd /c "argdump.exe "a b c""

la commande cmd semble saisir les citations externes et prendre le reste mot à mot. Il doit y avoir une sauce magique spéciale là-dedans.

Je n'ai pas fait de benchmarks sur ma méthode, mais considérez-la raisonnablement rapide. Il n'utilise pas Regex et ne fait pas de concaténation de chaîne de caractères mais utilise plutôt un StringBuilder pour collecter les caractères d'un argument et les met dans une liste.

/// <summary>
/// Reads command line arguments from a single string.
/// </summary>
/// <param name="argsString">The string that contains the entire command line.</param>
/// <returns>An array of the parsed arguments.</returns>
public string[] ReadArgs(string argsString)
{
    // Collects the split argument strings
    List<string> args = new List<string>();
    // Builds the current argument
    var currentArg = new StringBuilder();
    // Indicates whether the last character was a backslash escape character
    bool escape = false;
    // Indicates whether we're in a quoted range
    bool inQuote = false;
    // Indicates whether there were quotes in the current arguments
    bool hadQuote = false;
    // Remembers the previous character
    char prevCh = '"151910920"';
    // Iterate all characters from the input string
    for (int i = 0; i < argsString.Length; i++)
    {
        char ch = argsString[i];
        if (ch == '\' && !escape)
        {
            // Beginning of a backslash-escape sequence
            escape = true;
        }
        else if (ch == '\' && escape)
        {
            // Double backslash, keep one
            currentArg.Append(ch);
            escape = false;
        }
        else if (ch == '"' && !escape)
        {
            // Toggle quoted range
            inQuote = !inQuote;
            hadQuote = true;
            if (inQuote && prevCh == '"')
            {
                // Doubled quote within a quoted range is like escaping
                currentArg.Append(ch);
            }
        }
        else if (ch == '"' && escape)
        {
            // Backslash-escaped quote, keep it
            currentArg.Append(ch);
            escape = false;
        }
        else if (char.IsWhiteSpace(ch) && !inQuote)
        {
            if (escape)
            {
                // Add pending escape char
                currentArg.Append('\');
                escape = false;
            }
            // Accept empty arguments only if they are quoted
            if (currentArg.Length > 0 || hadQuote)
            {
                args.Add(currentArg.ToString());
            }
            // Reset for next argument
            currentArg.Clear();
            hadQuote = false;
        }
        else
        {
            if (escape)
            {
                // Add pending escape char
                currentArg.Append('\');
                escape = false;
            }
            // Copy character from input, no special meaning
            currentArg.Append(ch);
        }
        prevCh = ch;
    }
    // Save last argument
    if (currentArg.Length > 0 || hadQuote)
    {
        args.Add(currentArg.ToString());
    }
    return args.ToArray();
}

Actuellement, c'est le code que j'ai:

    private String[] SplitCommandLineArgument(String argumentString)
    {
        StringBuilder translatedArguments = new StringBuilder(argumentString);
        bool escaped = false;
        for (int i = 0; i < translatedArguments.Length; i++)
        {
            if (translatedArguments[i] == '"')
            {
                escaped = !escaped;
            }
            if (translatedArguments[i] == ' ' && !escaped)
            {
                translatedArguments[i] = '\n';
            }
        }

        string[] toReturn = translatedArguments.ToString().Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
        for(int i = 0; i < toReturn.Length; i++)
        {
            toReturn[i] = RemoveMatchingQuotes(toReturn[i]);
        }
        return toReturn;
    }

    public static string RemoveMatchingQuotes(string stringToTrim)
    {
        int firstQuoteIndex = stringToTrim.IndexOf('"');
        int lastQuoteIndex = stringToTrim.LastIndexOf('"');
        while (firstQuoteIndex != lastQuoteIndex)
        {
            stringToTrim = stringToTrim.Remove(firstQuoteIndex, 1);
            stringToTrim = stringToTrim.Remove(lastQuoteIndex - 1, 1); //-1 because we've shifted the indicies left by one
            firstQuoteIndex = stringToTrim.IndexOf('"');
            lastQuoteIndex = stringToTrim.LastIndexOf('"');
        }
        return stringToTrim;
    }

ça ne marche pas avec des citations évitées, mais ça marche pour les cas que j'ai rencontrés jusqu'à présent.

il s'agit d'une réponse au code D'Anton, qui ne fonctionne pas avec des citations échappées. J'ai modifié 3 endroits.

1. Le constructeur pour StringBuilder dans SplitCommandLineArguments à la place \" avec \r
2. Dans le pour "en boucle 151960920" dans SplitCommandLineArguments , j'ai maintenant remplacer \r par \ .
3. a changé la méthode SplitCommandLineArgument de privé à public static .

public static string[] SplitCommandLineArgument( String argumentString )
{
    StringBuilder translatedArguments = new StringBuilder( argumentString ).Replace( "\\"", "\r" );
    bool InsideQuote = false;
    for ( int i = 0; i < translatedArguments.Length; i++ )
    {
        if ( translatedArguments[i] == '"' )
        {
            InsideQuote = !InsideQuote;
        }
        if ( translatedArguments[i] == ' ' && !InsideQuote )
        {
            translatedArguments[i] = '\n';
        }
    }

    string[] toReturn = translatedArguments.ToString().Split( new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries );
    for ( int i = 0; i < toReturn.Length; i++ )
    {
        toReturn[i] = RemoveMatchingQuotes( toReturn[i] );
        toReturn[i] = toReturn[i].Replace( "\r", "\"" );
    }
    return toReturn;
}

public static string RemoveMatchingQuotes( string stringToTrim )
{
    int firstQuoteIndex = stringToTrim.IndexOf( '"' );
    int lastQuoteIndex = stringToTrim.LastIndexOf( '"' );
    while ( firstQuoteIndex != lastQuoteIndex )
    {
        stringToTrim = stringToTrim.Remove( firstQuoteIndex, 1 );
        stringToTrim = stringToTrim.Remove( lastQuoteIndex - 1, 1 ); //-1 because we've shifted the indicies left by one
        firstQuoteIndex = stringToTrim.IndexOf( '"' );
        lastQuoteIndex = stringToTrim.LastIndexOf( '"' );
    }
    return stringToTrim;
}