"Avancé" Application Console

Je ne sais pas si cette question a été répondue par ailleurs et je n'arrive pas à trouver quelque chose par le biais de google qui n'est pas un exemple "Hello World"... je code en C# .NET 4.0.

Je suis en train de développer une console de l'application qui va ouvrir, afficher du texte, et puis attendre que l'utilisateur les commandes d'entrée, où les commandes s'exécutent en particulier de la logique métier.

Par exemple: Si l'utilisateur ouvre l'application et les types de "l'aide", je veux afficher un certain nombre de déclarations, etc etc. Je ne suis pas sûr de savoir comment code le "gestionnaire d'événement" pour la saisie de l'utilisateur.

Espérons que cela a du sens. Toute aide serait grandement appréciée!
Des acclamations.

Le Code d'une application simple qui dit "Bad command" peu importe ce que les types d'utilisateurs. Puis poste ton code et faire de votre question plus spécifique.
Je voudrais vraiment, mais je n'ai pas vraiment le code parce que je ne suis pas sûr où commencer...

OriginalL'auteur keynesiancross | 2011-01-05

c#console event-handling user-input

20

Vous avez besoin de plusieurs étapes pour atteindre cet objectif, mais il ne devrait pas être difficile. D'abord, vous avez besoin d'un analyseur qui analyse ce que vous écrivez. À lire chaque commande suffit d'utiliser var command = Console.ReadLine(), et ensuite d'analyser cette ligne. Et exécuter la commande... Principales de la logique devrait avoir une base à la recherche de ce (genre de):
```
public static void Main(string[] args)
{
    var exit = false;
    while(exit == false)
    {
         Console.WriteLine();
         Console.WriteLine("Enter command (help to display help): "); 
         var command = Parser.Parse(Console.ReadLine());
         exit = command.Execute();
    }
}
```
Sorte de, vous pourriez probablement changer pour être plus compliqué.

Le code de la Parser et de commande est une sorte de simple:
```
public interface ICommand
{
    bool Execute();
}

public class ExitCommand : ICommand
{
    public bool Execute()
    {
         return true;
    }
}

public static Class Parser
{
    public static ICommand Parse(string commandString) { 
         //Parse your string and create Command object
         var commandParts = commandString.Split(' ').ToList();
         var commandName = commandParts[0];
         var args = commandParts.Skip(1).ToList(); //the arguments is after the command
         switch(commandName)
         {
             //Create command based on CommandName (and maybe arguments)
             case "exit": return new ExitCommand();
               .
               .
               .
               .
         }
    }
}
```
Très bien, merci. C'est certainement le genre de chose que je suis à la recherche d'
Désolé, comment fonctionne l'interface de travail dans ce cas? Je n'ai pas travaillé avec des interfaces beaucoup, de sorte que peut-être mon problème...
L'interface, il suffit de spécifier la méthode d'un ceratin objet doit avoir. Avec cela en place, vous pouvez définir plusieurs objets qui hérite de l'interface, et laissez votre analyseur de créer ces objets pour vous. Vous pouvez modifier l'interface à ce que jamais vous vous sentez comme, je l'ai fait avec un simple Execute qui renvoie true si le programme doit quitter. Je peux mettre à jour avec une commande simple et l'échantillon.
+1 Très belle et propre conception.
Merci... et une bonne chose avec cette solution est que chaque Command "vie" dans leur propre contexte, en quelque sorte. Donc, rien n'empêche une commande de demander à l'utilisateur avec plus de questions.

OriginalL'auteur Tomas Jansson

Je sais que c'est une vieille question, mais j'étais à la recherche d'une réponse trop. J'ai été incapable de trouver un simple si, si je construit InteractivePrompt. Il est disponible comme un Package NuGet et vous pouvez facilement étendre le code qui est sur GitHub. Il dispose d'une histoire pour la session en cours également.

Les fonctionnalités de la question pourrait être mis en œuvre avec InteractivePrompt:

static string Help(string strCmd)
{
    //... logic
    return "Help text";
}
static string OtherMethod(string strCmd)
{
    //... more logic
    return "Other method";
}
static void Main(string[] args)
{
    var prompt = "> ";
    var startupMsg = "BizLogic Interpreter";
    InteractivePrompt.Run(
        ((strCmd, listCmd) =>
        {
            string result;
            switch (strCmd.ToLower())
            {
                case "help":
                    result = Help(strCmd);
                    break;
                case "othermethod":
                    result = OtherMethod(strCmd);
                    break;
                default:
                    result = "I'm sorry, I don't recognize that command.";
                    break;
            }

            return result + Environment.NewLine;
        }), prompt, startupMsg);
}

OriginalL'auteur sorrell

0

C'est assez facile, il suffit d'utiliser la Console.WriteLine et Console.ReadLine() méthodes. À partir de la ReadLine vous obtenir une chaîne de caractères. Vous pourriez avoir un si horrible que l'énoncé de valider cela contre l'on sait ou devrait entrées. Mieux serait d'avoir une table de recherche. Plus sophistiqué serait d'écrire un analyseur syntaxique. Cela dépend vraiment de combien sont complexes les entrées peuvent être.

mais avec la Console.ReadLine() la méthode, comment puis-je code les différentes permutations de réponses etc? Par exemple, la Console.ReadLine(), si(Console.ReadLine() == "help) { } etc etc

OriginalL'auteur John Pickup
0

Console.WriteLine Console.ReadLine et Console.ReadKey sont vos amis. ReadLine et ReadKey attend une entrée de l'utilisateur. Le string[] args aurez tous vos paramètres tels que les "aide". Le tableau est créé en séparant les arguments de ligne de commande par des espaces.

OriginalL'auteur Joe

switch (Console.ReadLine())
{
    case "Help":
        //print help
        break;

    case "Other Command":
        //do other command
        break;

    //etc.

    default:
        Console.WriteLine("Bad Command");
        break;
}

Si vous êtes à la recherche pour analyser les commandes qui ont d'autres choses comme les paramètres, par exemple "manipuler file.txt" ensuite, cela seul ne fonctionne pas. Mais vous pouvez par exemple utiliser String.Split pour séparer l'entrée dans une commande et les arguments.

OriginalL'auteur Tesserex

Un exemple:

    static void Main(string[] args)
{
Console.WriteLine("Welcome to test console app, type help to get some help!");
while (true)
{
string input = Console.ReadLine();
int commandEndIndex = input.IndexOf(' ');
string command = string.Empty;
string commandParameters = string.Empty;
if (commandEndIndex > -1)
{
command = input.Substring(0, commandEndIndex);
commandParameters = input.Substring(commandEndIndex + 1, input.Length - commandEndIndex - 1);
}
else
{
command = input;
}
command = command.ToUpper();
switch (command)
{
case "EXIT":
{
return;
}
case "HELP":
{
Console.WriteLine("- enter EXIT to exit this application");
Console.WriteLine("- enter CLS to clear the screen");
Console.WriteLine("- enter FORECOLOR value to change text fore color (sample: FORECOLOR Red) ");
Console.WriteLine("- enter BACKCOLOR value to change text back color (sample: FORECOLOR Green) ");
break;
}
case "CLS":
{
Console.Clear();
break;
}
case "FORECOLOR":
{
try
{
Console.ForegroundColor = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), commandParameters);
}
catch
{
Console.WriteLine("!!! Parameter not valid");
}
break;
}
case "BACKCOLOR":
{
try
{
Console.BackgroundColor = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), commandParameters);
}
catch
{
Console.WriteLine("!!! Parameter not valid"); 
}
break;
}
default:
{
Console.WriteLine("!!! Bad command");
break;
}
}
}
}

ce n'est pas une bonne conception depuis votre fonction est de faire TOUT le travail. Vous devriez diviser en sorte que chaque partie a une responsabilité.
je suis d'accord avec ça, mais j'ai compris qu'il est à la recherche pour le code qu'il peut apprendre de, et ce n'est pas trop compliqué. Il est exact que la logique devrait être séparés.. À la fin les deux échantillons de votre et le mien donne un résultat identique.
Il a certainement le même résultat à la fin, mais je ne pense pas que ma solution est plus complexe et il est important que vous apprenez comment faire les choses de la bonne façon.... même si le mien est probablement pas adapté pour tout le monde mais le design est quelque chose que vous devriez penser. J'ai même envisager de ma solution plus facile, car il est beaucoup plus "fluent" lorsque vous le lisez et que vous passez tous les détails si vous n'en avez pas besoin. Sur un haut niveau, il s seulement, la commande de lecture, l'analyse, la commande et la dernière exécution de la commande. Qui est, vous pouvez ignorer les détails sur la façon dont la commande est analysée et la façon dont il est exécuté.
yep, je signe

OriginalL'auteur HABJAN

C'est très simpliste, mais qui pourraient répondre à vos besoins.

//somewhere to store the input
string userInput="";
//loop until the exit command comes in.
while (userInput != "exit")
{
//display a prompt
Console.Write("> ");
//get the input
userInput = Console.ReadLine().ToLower();
//Branch based on the input
switch (userInput)
{
case "exit": 
break;
case "help": 
{
DisplayHelp(); 
break;
}
case "option1": 
{
DoOption1(); 
break;
}
//Give the user every opportunity to invoke your help system :)
default: 
{
Console.WriteLine ("\"{0}\" is not a recognized command.  Type \"help\" for options.", userInput);
break;
}
}
}

OriginalL'auteur Brett

Vous devez vous connecter pour publier un commentaire.