hoe voer je een winform uit vanuit de console-applicatie?

Hoe maak, voer en beheer ik een winform vanuit een consoletoepassing?

Antwoord 1, autoriteit 100%

De gemakkelijkste optie is om een ​​Windows Forms-project te starten en vervolgens het uitvoertype te wijzigen in Consoletoepassing. U kunt ook een verwijzing naar System.Windows.Forms.dll toevoegen en beginnen met coderen:

using System.Windows.Forms;
[STAThread]
static void Main() {
    Application.EnableVisualStyles();
    Application.Run(new Form()); // or whatever
}

Het belangrijkste is de [STAThread]op uw Main()-methode, vereist voor volledige COM-ondersteuning.

Antwoord 2, autoriteit 38%

Ik wilde dit onlangs doen en ontdekte dat ik niet tevreden was met de antwoorden hier.

Als je Marc’s advies opvolgt en het output-type instelt op Console Application, zijn er twee problemen:

1) Als u de toepassing vanuit Verkenner start, krijgt u een irritant consolevenster achter uw formulier dat niet verdwijnt totdat uw programma is afgesloten. We kunnen dit probleem verhelpen door FreeConsole aan te roepen voordat de GUI (Application.Run) wordt weergegeven. De ergernis hier is dat het consolevenster nog steeds verschijnt. Het gaat meteen weg, maar is er toch voor even.

2) Als u het vanaf een console start en een GUI weergeeft, wordt de console geblokkeerd totdat de GUI wordt afgesloten. Dit komt omdat de console (cmd.exe) denkt dat het console-apps synchroon moet starten en Windows-apps asynchroon (het Unix-equivalent van “myprocess &”).

Als u het output-type als Windows-toepassing laat, maar correctAttachConsole aanroept, krijgt u geen tweede consolevenster wanneer het wordt aangeroepen vanaf een console en krijgt u niet de onnodige console wanneer het wordt aangeroepen vanuit Explorer . De juiste manier om AttachConsole aan te roepen, is door er -1 aan door te geven. Dit zorgt ervoor dat ons proces wordt gekoppeld aan de console van ons bovenliggende proces (het consolevenster dat ons heeft gelanceerd).

Dit heeft echter twee verschillende problemen:

1) Omdat de console Windows-apps op de achtergrond start, wordt de prompt onmiddellijk weergegeven en is verdere invoer mogelijk. Aan de ene kant is dit goed nieuws, de console is niet geblokkeerd in uw GUI-app, maar in het geval dat u uitvoer naar de console wilt dumpen en nooit de GUI wilt tonen, komt de uitvoer van uw programma na de prompt en wordt er geen nieuwe prompt weergegeven weergegeven als u klaar bent. Dit ziet er een beetje verwarrend uit, om nog maar te zwijgen van het feit dat uw “console-app” op de achtergrond draait en de gebruiker vrij is om andere opdrachten uit te voeren terwijl deze actief is.

2) Streamomleiding raakt ook in de war, b.v. “myapp some parameters > somefile” kan niet worden omgeleid. Het stream-omleidingsprobleem vereist een aanzienlijke hoeveelheid p/Invoke om de standaardhandles te repareren, maar het is oplosbaar.

Na vele uren jagen en experimenteren, ben ik tot de conclusie gekomen dat er geen manier is om dit perfect te doen. U kunt eenvoudigweg niet alle voordelen van zowel de console als het venster krijgen zonder bijwerkingen. Het is een kwestie van kiezen welke bijwerkingen het minst vervelend zijn voor de doeleinden van uw toepassing.

Antwoord 3, autoriteit 25%

Dit is de beste methode die ik heb gevonden:
Stel eerst het uitvoertype van uw projecten in op “Windows-toepassing” en P/Invoke AllocConsole om een ​​consolevenster te maken.

internal static class NativeMethods
{
    [DllImport("kernel32.dll")]
    internal static extern Boolean AllocConsole();
}
static class Program
{
    static void Main(string[] args) {
        if (args.Length == 0) {
            // run as windows app
            Application.EnableVisualStyles();
            Application.Run(new Form1()); 
        } else {
            // run as console app
            NativeMethods.AllocConsole();
            Console.WriteLine("Hello World");
            Console.ReadLine();
        }
    }
}

Antwoord 4, autoriteit 6%

Het is heel eenvoudig om te doen:

Voeg gewoon het volgende attribuut en de code toe aan je Main-methode:

[STAThread]
void Main(string[] args])
{
   Application.EnableVisualStyles();
   //Do some stuff...
   while(!Exit)
   {
       Application.DoEvents(); //Now if you call "form.Show()" your form won´t be frozen
       //Do your stuff
   }
}

Je bent nu volledig in staat om WinForms te tonen 🙂

Antwoord 5, autoriteit 5%

U kunt een winform-project maken in VS2005/VS2008 en de eigenschappen ervan wijzigen in een opdrachtregeltoepassing. Het kan dan worden gestart vanaf de opdrachtregel, maar zal nog steeds een winform openen.

Antwoord 6, autoriteit 3%

Alle bovenstaande antwoorden zijn een grote hulp, maar ik dacht eraan wat meer tips toe te voegen voor de absolute beginner.

Dus u wilt iets doen met Windows Forms, in een consoletoepassing:

Voeg een verwijzing toe naar System.Windows.Forms.dllin uw consoletoepassingsproject in Solution Explorer. (Klik met de rechtermuisknop op Oplossingsnaam->add->Referentie…)

Specificeer de naamruimte in code: using System.Windows.Forms;

Declareer de benodigde eigenschappen in uw klas voor de besturingselementen die u aan het formulier wilt toevoegen.

bijv. int Left { get; set; } // need to specify the LEFT position of the button on the Form

En voeg dan het volgende codefragment toe in Main():

static void Main(string[] args)
{
Application.EnableVisualStyles();
        Form frm = new Form();  // create aForm object
        Button btn = new Button()
        {
            Left = 120,
            Width = 130,
            Height = 30,
            Top = 150,
            Text = "Biju Joseph, Redmond, WA"
        };
       //… more code 
       frm.Controls.Add(btn);  // add button to the Form
       //  …. add more code here as needed
       frm.ShowDialog(); // a modal dialog 
}

Antwoord 7

U zou de klasse Application op dezelfde manier moeten kunnen gebruiken als Winform-apps. Waarschijnlijk is de gemakkelijkste manier om een ​​nieuw project te starten, te doen wat Marc voorstelde: een nieuw Winform-project maken en dit in de opties wijzigen in een consoletoepassing

Antwoord 8

Dit werkte voor mijn behoeften…

Task mytask = Task.Run(() =>
{
    MyForm form = new MyForm();
    form.ShowDialog();
});

Hiermee wordt de vanaf in een nieuwe thread gestart en wordt de thread niet vrijgegeven totdat het formulier is gesloten. Taskbevindt zich in .Net 4 en hoger.

Antwoord 9

Als je wilt ontsnappen aan Form Freezeen bewerken wilt gebruiken (zoals tekst voor een knop), gebruik dan deze code

Form form = new Form();
Form.Button.Text = "randomText";
System.Windows.Forms.Application.EnableVisualStyles();
System.Windows.Forms.Application.Run(form);

Antwoord 10

Het hangt helemaal af van je keuze, hoe je implementeert.
A. Bijgevoegd proces, bijv: invoer op formulier en afdrukken op console
B. Onafhankelijk proces, bijvoorbeeld: start een timer, sluit niet af, zelfs niet als de console wordt afgesloten.

voor een,

Application.Run(new Form1());
//or -------------
Form1 f = new Form1();
f.ShowDialog();

voor b,
Gebruik draad, of taak iets,
Hoe onafhankelijk een winformulier openen?