C# Console de recevoir une entrée avec tuyau

Je sais comment le programme d'application de la Console avec des paramètres, par exemple : myProgram.exe param1 param2.

Ma question est, comment puis-je faire mon programme fonctionne avec |, par exemple : echo "mot" | myProgram.exe?

InformationsquelleAutor Patrick Desjardins | 2008-10-14

c#pipe

43

Vous devez utiliser Console.Read() et Console.ReadLine() comme si vous étiez en train de lire la saisie de l'utilisateur. Les tuyaux de remplacer la saisie de l'utilisateur de manière transparente. Vous ne pouvez pas utiliser à la fois facilement (même si je suis sûr que c'est tout à fait possible...).

Edit:

Un simple cat style de programme:
```
class Program
{
    static void Main(string[] args)
    {
        string s;
        while ((s = Console.ReadLine()) != null)
        {
            Console.WriteLine(s);
        }

    }
}
```
Et lorsqu'il est exécuté, comme prévu, la sortie:
```
C:\...\ConsoleApplication1\bin\Debug>echo "Foo bar baz" | ConsoleApplication1.exe 
"Foo bar baz" 

C:\...\ConsoleApplication1\bin\Debug> 
```
- Est-ce que votre exemple qui fonctionne pour : echo "Foo bar baz" | ConsoleApplication1.exe | ConsoleApplication1.exe ?
- Oui. À l'aide d'un niveau inférieur analogie, ce qui se passe vraiment avec un tuyau qui est le flux Stdout de la première demande est branché dans le flux Stdin de la prochaine application dans le pipeline. La console de l'entrée standard stdin se mettre au travers de la première application, et les dernières applications stdout est affiché.
- Tommorow je vais essayer ça!!! Thx 🙂
- Si vous travaillez avec des données binaires: stackoverflow.com/questions/1562417/...
- pourquoi vérifier les ReadLine == null, ne jamais retourner la valeur null? (Ne serait-ce pas renvoie la chaîne vide si rien n'est entré). stackoverflow.com/questions/26338571/...
- Non, il ne reviendra pas une chaîne vide. Comment voulez-vous récupérer les lignes qui sont vides alors? La documentation de Console.ReadLine états qu'elle retourne null si il n'y a plus de lignes à lire: msdn.microsoft.com/de-de/library/...
- oui, merci, tout à fait raison, d'ailleurs, elle renvoie la valeur null juste quand Ctrl-Z est pressé. (pas de Ctrl-C par exemple), donc pas tous les cas de "pas plus de lignes à lire". Je vois la msdn mentionne les touches Ctrl+Z.
InformationsquelleAutor Matthew Scharley
15

Suivantes ne suspend pas l'application de saisie et de travaux lorsque des données sont ou n'est pas courante. Un peu un hack; et en raison de l'erreur de la capture, de la performance pourrait être en manque de lors de de nombreuses canalisations d'appels sont pris, mais... facile.
```
public static void Main(String[] args)
{

    String pipedText = "";
    bool isKeyAvailable;

    try
    {
        isKeyAvailable = System.Console.KeyAvailable;
    }
    catch (InvalidOperationException expected)
    {
        pipedText = System.Console.In.ReadToEnd();
    }

    //do something with pipedText or the args
}
```
- Le grand truc, merci pour cette!
- ici, la réponse de hans passant stackoverflow.com/questions/3453220/... près de la fin, mentionne encore mieux System.Console.WriteLine(System.Console.IsInputRedirected.ToString());
- Truc intéressant. Merci!
InformationsquelleAutor CodeMiller
11

dans .NET 4.5, c'est
```
if (Console.IsInputRedirected)
{
    using(stream s = Console.OpenStandardInput())
    {
        ...
```
- Salut, je n'arrive pas à le faire fonctionner avec ce code, toutes les idées?
InformationsquelleAutor gordy

C'est la façon de le faire:

static void Main(string[] args)
{
    Console.SetIn(new StreamReader(Console.OpenStandardInput(8192))); //This will allow input >256 chars
    while (Console.In.Peek() != -1)
    {
        string input = Console.In.ReadLine();
        Console.WriteLine("Data read was " + input);
    }
}

Ce qui permet à deux méthodes d'utilisation. Lire à partir de entrée standard:

C:\test>myProgram.exe
hello
Data read was hello

ou à la lecture de les canalisations d'entrée:

C:\test>echo hello | myProgram.exe
Data read was hello

InformationsquelleAutor matt burns

3

Voici une autre solution alternative qui a été mis de l'autre des solutions plus un peek().

Sans Peek() j'ai l'expérience que l'application ne serait pas de retour sans ctrl-c, à la fin quand on fait "type t.txt | prog.exe" où t.txt c'est un multi-ligne fichier. Mais juste "prog.exe" ou "echo hi | prog.exe" a bien fonctionné.

ce code est destiné à ne traiter que les canalisations d'entrée.
```
static int Main(string[] args)
{
    //if nothing is being piped in, then exit
    if (!IsPipedInput())
        return 0;

    while (Console.In.Peek() != -1)
    {
        string input = Console.In.ReadLine();
        Console.WriteLine(input);
    }

    return 0;
}

private static bool IsPipedInput()
{
    try
    {
        bool isKey = Console.KeyAvailable;
        return false;
    }
    catch
    {
        return true;
    }
}
```
- ici, la réponse de hans passant stackoverflow.com/questions/3453220/... près de la fin, mentionne encore mieux System.Console.WriteLine(System.Console.IsInputRedirected.ToString());
InformationsquelleAutor Matthew Benedict
2

De la Console.Dans est une référence à un TextReader enroulé autour du flux d'entrée standard. Lorsque la tuyauterie de grandes quantités de données à votre programme, il pourrait être plus facile à travailler de cette façon.

InformationsquelleAutor Joel Mueller
1

il y a un problème avec l'exemple proposé.
```
  while ((s = Console.ReadLine()) != null)
```
sera bloqué en attente pour l'entrée si le programme a été lancé sans les canalisations de données. de sorte que l'utilisateur doit manuellement appuyez sur n'importe quelle touche pour quitter le programme.
- qui est plus digne qu'un commentaire, et d'autres ont abordé qui et une solution
InformationsquelleAutor Alex N

Cela fonctionnera aussi pour les

c:\MyApp.exe < input.txt

J'ai dû utiliser un StringBuilder pour manipuler les entrées saisies à partir de Stdin:

public static void Main()
{
    List<string> salesLines = new List<string>();
    Console.InputEncoding = Encoding.UTF8;
    using (StreamReader reader = new StreamReader(Console.OpenStandardInput(), Console.InputEncoding))
    {
        string stdin;
        do
        {
            StringBuilder stdinBuilder = new StringBuilder();
            stdin = reader.ReadLine();
            stdinBuilder.Append(stdin);
            var lineIn = stdin;
            if (stdinBuilder.ToString().Trim() != "")
            {
                salesLines.Add(stdinBuilder.ToString().Trim());
            }

        } while (stdin != null);

    }
}

InformationsquelleAutor Si Zi

Vous devez vous connecter pour publier un commentaire.