È possibile creare un'applicazione GUI desktop in .NET core?

Sviluppo programmi WinForms da alcuni anni. Sto ora esaminando .NET Core (incluso ASP.NET Core MVC). Sto cercando la nuova tecnologia desktop GUI. Nell'aggiornamento 3 di Visual Studio 2015 non riesco a vedere alcuna opzione per creare un'app GUI in .NET Core. Cosa mi sto perdendo?

Non ti sei perso niente. MS non ha fornito alcun modo ragionevole per creare applicazioni GUI direttamente utilizzando .Net Core fino a .Net Core 3, sebbene UWP (Universal Windows Platform) sia parzialmente costruito su .Net Core.

.Net Core 3.0 include il supporto per Winforms e WPF, sebbene sia solo per Windows.

.Net 6 includerà .Net MAUI, che supporterà applicazioni desktop e mobili Windows e macOS, con applicazioni desktop Linux supportate dalla comunità (non MS). .Net 5 includerà una versione di anteprima di .Net MAUI.

Per le opzioni multipiattaforma emerse negli ultimi 2 anni, vedere altre risposte.

Potresti usare Electron e collegarlo con Edge.js risp. electron-edge . Edge.js consente a electron (node.js) di chiamare .net dll e viceversa. In questo modo puoi scrivere la GUI con HTML, CSS e JavaScript e il backend con .net core. Anche Electron è multipiattaforma e si basa sul browser Chrome.

AvaloniaUI ora ha il supporto per l'esecuzione su .NET Core su Win / OSX / Linux. XAML, associazioni e modelli di controllo inclusi.

es. per sviluppare su MacOs con Rider:

1. Segui le istruzioni per installare i nuovi modelli dotnet di Avalonia
2. Apri JetBrains Rider e dalla schermata di benvenuto,
3. Scegli New Solution-> (Vicino alla parte superiore dell'elenco dei modelli) -> More Templates-> Pulsante Install Template...-> vai alla directory in cui hai clonato i modelli al passaggio 1.
4. Fare clic sul Reloadpulsante
5. Guarda! I modelli Avalonia ora appaiono nell'elenco dei New Solutionmodelli!
6. Scegli un modello Avalonia
7. Costruisci ed esegui. Guarda la GUI aperta davanti ai tuoi occhi.

È ora possibile utilizzare Qt / QtQuick / QML con .NET Core, utilizzando Qml.Net .

È altamente performante (non "chiacchierone"), completamente caratterizzato e funziona su Linux / OSX / Windows.

Controlla il mio post sul blog per vedere come si confronta con le altre opzioni attualmente disponibili.

PS: sono l'autore.

Un'opzione potrebbe essere l'utilizzo di Electron con JavaScript, HTML e CSS per l'interfaccia utente e la creazione di un'applicazione console .Net Core che ospiterà autonomamente un'API Web per la logica di back-end. Electron avvierà l'applicazione console in background che esporrà un servizio su localhost: xxxx.

In questo modo è possibile implementare tutta la logica di back-end utilizzando .Net per essere accessibile tramite richieste HTTP da JavaScript.

Dai un'occhiata a questo post, spiega come creare un'applicazione desktop multipiattaforma con Electron e .Net Core e controlla il codice su GitHub

Per la creazione di console basata interfaccia utente, è possibile utilizzare gui.cs . È open-source (da Miguel, creatore di Xamarin) e funziona su .Net core su Windows, Linux e MacOs.

Ha i seguenti componenti:

• Bottoni
• Etichette
• Inserimento di testo
• Visualizzazione del testo
• Campo di modifica dell'ora
• Tasti della radio
• Caselle di controllo
• Finestre di dialogo
  • Caselle di messaggio
• finestre
• Menu
• ListViews
• Cornici
• ProgressBars
• Visualizzazioni a scorrimento e barre di scorrimento
• Visualizzatore / editor esadecimale (HexView)

Screenshot di esempio

abbiamo codificato una soluzione open source per electron con core .net: Electron.NET . https://github.com/ElectronNET/Electron.NET

Godere!

.NET Core 3 avrà il supporto per la creazione di applicazioni desktop di Windows. Ho guardato una demo della tecnologia ieri durante la .NET Conference. Questo è l'unico post sul blog che ho trovato, ma illustra il punto: https://blogs.msdn.microsoft.com/dotnet/2018/05/07/net-core-3-and-support-for-windows- applicazioni-desktop /

tl; dr : non sono sicuro che sarebbe possibile per gli sviluppatori .NET Core fornire un framework GUI multipiattaforma.

Mi sento come se ci si aspettasse che un framework GUI multipiattaforma fosse incluso negli strumenti ufficiali (specialmente una vecchia versione degli strumenti - hai detto che stai eseguendo l'aggiornamento 3 di VS 2015) per una prima versione di .NET Core è un po 'prematuro.

I framework GUI sono davvero piuttosto pesanti e dipendono dalle astrazioni hardware già presenti sulla macchina host. Su Windows c'è generalmente un unico gestore di finestre (WM) e un ambiente desktop (DE) utilizzato dalla maggior parte degli utenti, ma sulle molte diverse distribuzioni di Linux che sono supportate, ci sono un numero qualsiasi di possibili WM e DE - ammesso che la maggior parte degli utenti lo farà stai usando X-Server o Wayland in combinazione con KDE, Gnome o XFCE. Ma nessuna installazione Linux è la stessa.

Il fatto che la comunità open source non possa davvero accontentarsi di una configurazione "standard" per VM e DE significa che sarebbe piuttosto difficile per gli sviluppatori di .NET Core creare un framework GUI che funzionerebbe su tutte le piattaforme e combinazioni di DE e WM.

Molte persone qui hanno alcuni ottimi suggerimenti (dall'uso di ASP.NET Core alla creazione di un'applicazione Web e all'utilizzo di un browser per elencare un gruppo di framework multipiattaforma). Se dai un'occhiata ad alcuni dei framework GUI multipiattaforma menzionati elencati, vedrai quanto sono pesanti.

Tuttavia, c'è luce alla fine del tunnel mentre Miguel de Icaza ha mostrato Xamarin in esecuzione ingenuamente su Linux e MacOS a .NET Conf quest'anno (2017, se stai leggendo questo in futuro), quindi potrebbe valere la pena provare che quando è pronto.

(ma sarà necessario eseguire l'aggiornamento da VS 2015 a VS 2017 per accedere alle funzionalità di .NET Core 2.0)

Sto lavorando a un progetto che potrebbe aiutare: https://github.com/gkmo/CarloSharp

La seguente applicazione è scritta in .net con l'interfaccia utente in HTML / JS / CSS (Angular)

È possibile sviluppare un'applicazione Web con .NET Core e MVC e incapsularla in un'app JavaScript universale di Windows: https://docs.microsoft.com/en-us/windows/uwp/porting/hwa-create-windows

È ancora un'app Web ma è un modo molto leggero per trasformare un'app Web in un'app desktop senza apprendere un nuovo framework o / e sviluppare nuovamente l'interfaccia utente, e funziona alla grande.

L'inconveniente è diverso da electron o ReactXP, ad esempio, il risultato è un'app Windows universale e non un'app desktop multipiattaforma.

Sì, è possibile.

.NET Core non ha componenti per l'applicazione GUI nativa pronta all'uso. Tuttavia, esiste un pacchetto NuGet chiamato Electron.NET , come da risposta di Gregor Biswanger.

Electron è un framework che ti consente di creare applicazioni GUI native su Node.js. Electron.NET è un pacchetto NuGet che consente di utilizzare Electron e Node.js dall'interno del codice .NET Core.

La buona notizia è che non devi imparare JavaScript, Electron o Node.js per poter utilizzare il pacchetto NuGet. I file JS vengono eseguiti all'interno dell'applicazione, ma vengono generati automaticamente dal processo di compilazione.

Tutto quello che devi fare è creare un'app ASP.NET Core MVC piuttosto standard. L'unica differenza è che, invece di essere eseguito nel browser, viene eseguito come un'app nativa con finestra. Oltre a poche righe di codice specifiche per il pacchetto Electron.NET, non sarà necessario apprendere nulla oltre ASP.NET Core MVC.

Questa pagina fornisce un tutorial su come usarlo. Contiene anche alcuni collegamenti a repository di codice di esempio.

Negromante.
Per il caso speciale delle applicazioni WinForms esistenti :

c'è un modo, anche se non so quanto bene funzioni.
Esso va come questa:
Prendere l'attuazione WinForms da mono.
Portalo su .NET Core o NetStandard.

Ricompila le tue applicazioni WinForms con il nuovo System.Windows.Forms.
Correggi tutto ciò che potrebbe essere danneggiato da NetCore.
Prega che mono implementa le parti di cui hai bisogno in modo impeccabile.
(in caso contrario, puoi sempre smettere di pregare e inviare al progetto singolo una richiesta pull con la tua correzione / patch / funzionalità)

Ecco il mio repository CoreFX WinForms:
https://github.com/ststeiger/System.CoreFX.Forms

È una vecchia domanda, ma sì, è possibile sviluppare applicazioni desktop (GUI) multipiattaforma, per Windows, Linux e macOS, utilizzando VSCode, .Net Core, C #, gtk3, gtksharp e Glade come GUI Designer.

Ecco come .

Se usi .Net Core 3.0e sopra esegui i seguenti passaggi e sei a posto: (userò .NET Core CLI , ma puoi usare anche Visual Studio)

1. md MyWinFormsApp passaggio facoltativo
2. cd MyWinFormsApp passaggio facoltativo
3. dotnet new sln -n MyWinFormsApp passaggio facoltativo, ma è una buona idea
4. dotnet new winforms -n MyWinFormsApp Mi dispiace, questo non è facoltativo
5. dotnet sln add MyWinFormsApp fallo se hai eseguito il passaggio 3

Va bene, puoi smettere di leggere la mia risposta e iniziare ad aggiungere codice al MyWinFormsAppprogetto. ma se vuoi lavorare con Form Designer continua a leggere.

6. Apri il MyWinFormsApp.csprojfile e cambia <TargetFramework>netcoreapp3.1<TargetFramework>in <TargetFrameworks>net472;netcoreapp3.1</TargetFrameworks>(se stai usando netcoreapp3.0non preoccuparti, cambialo in <TargetFrameworks>net472;netcoreapp3.0</TargetFrameworks>)
7. Quindi aggiungi quanto segue ItemGroup

  <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
    <Compile Update="Form1.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Update="Form1.Designer.cs">
      <DependentUpon>Form1.cs</DependentUpon>
    </Compile>
  </ItemGroup>

Dopo aver eseguito questi passaggi, questo è ciò che dovresti ottenere:

<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFrameworks>net472;netcoreapp3.1</TargetFrameworks>
    <UseWindowsForms>true</UseWindowsForms>
  </PropertyGroup>

  <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
    <Compile Update="Form1.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Update="Form1.Designer.cs">
      <DependentUpon>Form1.cs</DependentUpon>
    </Compile>
  </ItemGroup>

</Project>

8. Apri Program.cse aggiungi il seguente preprocessore-if

#if NETCOREAPP3_1
    Application.SetHighDpiMode(HighDpiMode.SystemAware);
#endif

Ora puoi aprire il MyWinFormsAppprogetto usando Visual Studio 2019 ( penso che tu possa usare anche Visual Studio 2017, ma non ne sono sicuro ) e fai doppio clic su Form1.cse dovresti vedere questo:

Ok, apri Toolbox ( Ctrl+W,X) e inizia ad aggiungere controlli alla tua app e rendila carina.

Puoi leggere ulteriori informazioni su designer @ Windows Forms .NET Core Designer