Wie die Konsole neu starten, app?

Ich glaube nicht, dass Sie wirklich brauchen, neu starten, ganze app. Führen Sie einfach gewünschten Methode(N) nach drücken der Taste R. Keine Notwendigkeit, neu zu starten.

static void Main(string[] args)
{
    var info = Console.ReadKey();
    if (info.Key == ConsoleKey.R)
    {
        var fileName = Assembly.GetExecutingAssembly().Location;
        System.Diagnostics.Process.Start(fileName);
    }
}

Ich weiß, es ist 7 Jahre alt, aber ich kam gerade über diese. Ich denke tatsächlich, dass das aufrufen der ausführbaren Datei und schließen Sie das aktuelle Programm ist ein bisschen ein cluge. Wie bereits erwähnt, dies wird über Gedanken. Ich denke, die sauberste und die meisten modularen Art und Weise ist, alles zu nehmen, das ist in der Main - Methode und machen eine andere Methode, sagen wir mal Run() enthält alles, was in der Main - Methode, und rufen Sie dann die neue Run() Methode aus der Main Methode oder wo im code es gewünscht ist, starten Sie das Programm neu.

Also, wenn die Main Methode sah so aus:

static void Main(string[] args)
{
    /*
    Main Method Variable declarations;
    Main Method Method calls;
    Whatever else in the Main Method;
    */
    int SomeNumber = 0;
    string SomeString = default(string);

    SomeMethodCall();
    //etc.
}

Dann erstellen Sie einfach eine Run() Methode und setzen Sie alles aus Main hinein, etwa so:

public static void Run()
{
    //Everything that was in the Main method previously

    /*
    Main Method Variable declarations;
    Main Method Method calls;
    Whatever else in the Main Method;
    */
    int SomeNumber = 0;
    string SomeString = default(string);

    SomeMethodCall();
    //etc.
}

Nun, dass die Run() Methode erstellt und es hat all die Sachen, die in der Main Methode vor, nur machen Sie Ihre main-Methode so auf:

static void Main(string[] args)
{
    Run();
}

Nun, wo in der code, den Sie möchten, um "re-start" - das Programm, rufen Sie einfach den Run() Methode etwa so:

if(/*whatever condition is met*/)
{
    //do something first

    //then "re-start" the program by calling Run();
    Run();
}

Dies ist also ein Blick auf das gesamte Programm vereinfacht:

EDIT: Wenn ich geschrieben dieses Zitat habe ich nicht berücksichtigt, alle Argumente, die vielleicht schon an das Programm übergeben. Um diese vier Dinge müssen geändert werden in meiner ursprünglichen Antwort.

1. deklarieren Sie eine Globale List<string> wie diese:

   public static List<string> MainMethodArgs = new List<string>();.

2. In der Main Methode setzt den Wert des MainMethodArgs Liste entspricht der
   übergebenen Werte in die Main Methode über args wie diese:

   MainMethodArgs = args.ToList();

3. Beim erstellen der Run() Methode ändern Sie die Signatur, so dass es erwartet einen
   string[] genannt args werden, übergeben Sie es wie folgt:

   public static void Run(string[] args)
{
....
}

4. Überall dort, wo im Programm die Run() - Methode aufgerufen wird, übergeben MainMethodArgs
   zu Run() wie diese:

   Run(MainMethodArgs.ToArray());

Änderte ich das Beispiel unten, um diese änderungen widerzuspiegeln.

using System;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExampleConsole
{
    class Program
    {
        public static List<string> MainMethodArgs = new List<string>();
        static void Main(string[] args)
        {
            MainMethodArgs = args.ToList();
            Run(MainMethodArgs.ToArray());
        }

        public static void Run(string[] args)
        {
            Console.WriteLine("Run() is starting");
            Console.ReadLine();
            //stuff that used to be in the public method
            int MainMethodSomeNumber = 0;
            string MainMethodSomeString = default(string);

            SomeMethod();
            //etc.
        }

        public static void SomeMethod()
        {
            Console.WriteLine("Rebuild Log Files"
            + " Press Enter to finish, or R to restar the program...");
            string restar = Console.ReadLine();
            if (restar.ToUpper() == "R")
            {
                //here the code to restart the console...
                Run(MainMethodArgs.ToArray());
            }
        }
    }
}

In Effekt das Programm "neu gestartet", ohne re-führen Sie die ausführbare Datei und schließen Sie die vorhandene Instanz von dem Programm. Dies scheint viel mehr "Programmierer wie" zu mir.

Genießen.

Jeder ist über-denken. Probieren Sie etwas wie dieses:

class Program : IDisposable
{

    class RestartException : Exception
    {
        public RestartException() : base()
        {
        }
        public RestartException( string message ) : base(message)
        {
        }
        public RestartException( string message , Exception innerException) : base( message , innerException )
        {
        }
        protected RestartException( SerializationInfo info , StreamingContext context ) : base( info , context )
        {
        }
    }

    static int Main( string[] argv )
    {
        int  rc                      ;
        bool restartExceptionThrown ;

        do
        {
            restartExceptionThrown = false ;
            try
            {
                using ( Program appInstance = new Program( argv ) )
                {
                    rc = appInstance.Execute() ;
                }
            }
            catch ( RestartException )
            {
                restartExceptionThrown = true ;
            }
        } while ( restartExceptionThrown ) ;
        return rc ;
    }

    public Program( string[] argv )
    {
        //initialization logic here
    }

    public int Execute()
    {
        //core of your program here
        DoSomething() ;
        if ( restartNeeded )
        {
            throw new RestartException() ;
        }
        DoSomethingMore() ;
        return applicationStatus ;
    }

    public void Dispose()
    {
        //dispose of any resources used by this instance
    }

}

//here the code to restart the console...
System.Diagnostics.Process.Start(Environment.GetCommandLineArgs()[0], Environment.GetCommandLineArgs().Length > 1 ? string.Join(" ", Environment.GetCommandLineArgs().Skip(1)) : null);