Angulaire sur le bureau

Les développeurs ont la possibilité d'apporter la bonté angulaire aux applications de bureau.
Parlons Angular—l'une des plates-formes de développement d'applications Web modernes les plus populaires. Avec une longue histoire, des outils matures et un écosystème de développeurs riche, il n'est pas difficile de comprendre pourquoi Angular est le framework SPA de choix pour la création d'applications Web/mobiles modernes.
Cependant, comment Angular fonctionne-t-il pour les applications de bureau ? La réponse logicielle classique s'applique, cela dépend. Il existe des stratégies de partage de code avec le Web, mais cela dépend également beaucoup du type d'application en cours de création et des intégrations de bureau souhaitées.
Les PWA et Electron.JS sont des moyens établis d'apporter du code Web aux applications de bureau, et ce sont tous les deux bonnes options pour Angular. Pour les développeurs .NET, .NET MAUI est la plate-forme de nouvelle génération pour la création d'applications multiplateformes natives pour mobile et ordinateur de bureau. Et avec les applications hybrides Blazor, le code Blazor pour les applications Web est le bienvenu dans .NET MAUI pour mobile/bureau. applications avec JS sur le front-end – l'un de ces investissements peut-il être transféré à .NET MAUI ? Parlons d'Angular, mais les moyens d'activer les applications de bureau avec les technologies Web devraient être à peu près les mêmes quel que soit le framework JS, donc React, Vue et d'autres devraient également se sentir les bienvenus.
Bonté angulaire sur le bureau, faisons-le. Cet article a été écrit et publié dans le cadre de l'2021 C# Advent.
Commencer correctement
Si vous êtes nouveau dans le monde Angular, l'un des meilleurs moyens de commencer est le CLI angulaire. Les conditions préalables à la construction avec Angular sont une version LTS Node.js pour le runtime et npm pour les dépendances. Il est facile d'installer globalement l'outil Angular CLI, comme ceci :
npm install -g @angular/cliNous pouvons ensuite lancer une nouvelle application Angular. Le modèle vous guide à travers quelques paramètres avant de créer le projet.
L'outil Angular CLI installe les packages npm angulaires nécessaires et d'autres dépendances. Une fois cela fait, nous pouvons naviguer à l'intérieur du projet et voir tout le code/les configurations.

Kendo UI for Angular peut vous aider.
Angular as PWA[19659008]L'un des moyens les plus simples pour qu'une application Web fonctionne sur un ordinateur de bureau est PWA : les applications Web peuvent devenir progressivement de meilleurs citoyens sur les plates-formes mobiles/de bureau. fonctionnalités : être installable sur le bureau et demander aux techniciens d'assistance d'apporter une assistance hors ligne, des notifications push, un accès au matériel, etc. quelques éléments dans une application Angular existante : un nouveau fichier manifeste est déposé et indique au navigateur comment l'application doit se comporter lorsqu'elle est installée par l'utilisateur. L'ensemble de démarrage contient une variété d'icônes d'application à épingler sur l'écran d'accueil, la barre tactile et plus encore – les icônes par défaut sont ajoutées à un répertoire Assets.[19659022]{
"nom": "angularpwa",
"short_name": "angularpwa",
"theme_color": "#1976d2",
"background_color": "#fafafa",
"afficher": "autonome",
"portée": "./",
"start_url": "./",
"icônes": [
{
« src »: « assets/icons/icon-72×72.png »,
« sizes »: « 72×72 »,
« type »: « image/png »,
« purpose »: « maskable any »
},
{
« src »: « assets/icons/icon-96×96.png »,
« sizes »: « 96×96 »,
« type »: « image/png »,
« purpose »: « maskable any »
},
…
…
]
}
La page de démarrage index.html contient désormais une référence au nouveau fichier manifeste Web.
Angularpwa
Un agent de service de mise en cache par défaut est également déposé, avec le fichier de configuration à savoir ngsw-config.json—cela indique quels types d'actifs peuvent être mis en cache.
{
"$schema": "./node_modules/@angular/service-worker/config/schema.json",
"index": "/index.html",
"assetGroups" : [
{
"name": "app",
"installMode": "prefetch",
"resources": {
"files": [
"/favicon.ico",
"/index.html",
"/manifest.webmanifest",
"/*.css",
"/*.js"
]
}
},
{
"nom": "actifs",
"installMode": "paresseux",
"updateMode": "prélecture",
"Ressources": {
"fichiers": [
"/assets/**",
"/*.(svg|cur|jpg|jpeg|png|apng|webp|avif|gif|otf|ttf|woff|woff2)"
]
}
}
]
}Le fichier de configuration ServiceWorker doit être référencé dans le fichier angular.json—le ngswConfigPath relie le ServiceWorker, permettant la configuration de la production dans les schémas de construction.
{
"$schema": "./node_modules/@angular/cli/lib/config/schema.json",
"version 1,
"newProjectRoot": "projets",
"projets": {
"angularpwa": {
"projectType": "application",
"schémas": {
"@schematics/angular:application": {
"strict": vrai
}
},
"racine": "",
"sourceRoot": "src",
"préfixe": "application",
"architecte": {
"construire": {
"builder": "@angular-devkit/build-angular:browser",
"options": {
"outputPath": "dist/angularpwa",
"index": "src/index.html",
"main": "src/main.ts",
"polyfills": "src/polyfills.ts",
"tsConfig": "tsconfig.app.json",
"actifs": [
"src/favicon.ico",
"src/assets",
"src/manifest.webmanifest"
],
"styles": [
"src/styles.css"
],
"scénarios": [],
"serviceWorker": vrai,
"ngswConfigPath": "ngsw-config.json"
},
"configurations": {
"production": {
« budgets » : [
{
"type": "initial",
"maximumWarning": "500kb",
"maximumError": "1mb"
},
{
"type": "anyComponentStyle",
"maximumWarning": "2kb",
"maximumError": "4kb"
}
],
"fileReplacements": [
{
"replace": "src/environments/environment.ts",
"with": "src/environments/environment.prod.ts"
}
],
"outputHashing": "all",
"serviceWorker": vrai,
"ngswConfigPath": "ngsw-config.json"
},
...
...
}
}
}
}
}
}Et enfin, le app.module.ts importe désormais dans ServiceWorkerModule et enregistre le ServiceWorker.
import { NgModule } de '@angular/core' ;
importer { BrowserModule } depuis '@angular/platform-browser' ;
importer { AppRoutingModule } de './app-routing.module';
importer { AppComponent } de './app.component' ;
importer { ServiceWorkerModule } de '@angular/service-worker' ;
importer { environnement } de '../environments/environment' ;
@NgModule({
déclarations : [
AppComponent
],
importations : [
BrowserModule,
AppRoutingModule,
ServiceWorkerModule.register('ngsw-worker.js', {
enabled: environment.production,
registrationStrategy: 'registerWhenStable:30000'
})
],
fournisseurs : [],
bootstrap : [AppComponent]
})
export class AppModule { }C'est un aperçu de toutes les pièces en mouvement qui commencent à transformer une application angulaire régulière en une PWA. Cependant, nous ne pouvons pas simplement exécuter l'application avec la commande Angular Serve – les techniciens de maintenance ne fonctionnent pas avec les compilations en mémoire. Nous avons besoin d'une version de production, comme ceci :
Une fois la construction terminée avec la configuration de production, nous pouvons voir les artefacts dans le répertoire de distribution – tout est compilé en HTML/JS/CSS déployable.
npm i -g http-server
http-server -p 8080 -c-1
Excellent—nous pouvons accéder à l'adresse IP du serveur HTTP local et voir notre PWA en action ! Notez l'option d'installation qui indique que l'utilisateur peut installer et exécuter cette application sur le bureau sans le navigateur Chrome.
Angular dans Electron
Un autre concurrent sérieux pour amener les applications Angular sur le bureau est Electron—la méthode open source populaire et éprouvée pour héberger des applications Web sur le bureau.
Electron aide à créer des applications de bureau multiplateformes robustes qui sont essentiellement HTML/CSS/JS, mais avec de fortes intégrations avec le système d'exploitation hôte lors de l'exécution en tant qu'application de bureau. Electron contient deux éléments pour fournir un environnement d'exécution et un canevas de rendu cohérents : Node.js et le moteur Chromium.
À partir d'une application CLI Angular standard, il n'est pas difficile d'ajouter la prise en charge Electron. dev dependance.
npm install electron@latest --save-devMaintenant, pour configurer toutes les choses Electron dans un projet Angular, ajoutons un simple fichier App.js. Pour démarrer Electron afin qu'il s'exécute sur le bureau, nous devons essentiellement ouvrir une nouvelle fenêtre de navigateur avec des dimensions spécifiées et charger l'URL de notre application Angular. Nous avons également besoin d'écouteurs pour l'ouverture/la fermeture des fenêtres de l'application. Voici le code :
const {
application,
Fenêtre du navigateur
} = require('électron')
const url = require("url");
const chemin = require("chemin");
laisser appWindow
function initWindow() {
appWindow = new BrowserWindow({
largeur: 1000,
hauteur : 800,
Préférences Web : {
nodeIntegration : vrai
}
})
appWindow.loadURL(
url.format({
chemin d'accès : chemin.join(__dirname, `/dist/index.html`),
protocole : "fichier : ",
barres obliques : vrai
})
);
appWindow.on('fermé', fonction () {
appWindow = null
})
}
app.on('prêt', initWindow)
app.on('fenêtre-tout-fermé', fonction () {
if (process.platform !== 'darwin') {
app.quit()
}
})
app.on('activer', fonction () {
if (gagner === null) {
initWindow()
}
})Ensuite, nous devons configurer notre application Angular pour se construire elle-même et Bootstrap à partir du fichier App.js. Voici la configuration dans package.json avec le point d'entrée principal et un script de construction pour démarrer Electron :
{
"nom": "électron angulaire",
"version": "0.0.0",
"main": "app.js",
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build",
"watch": "ng build --watch --configuration development",
"test": "ng test",
"start:electron": "ng build --base-href ./ && electron ."
},
...
...
}C'est tout : nous pouvons maintenant lancer notre application et voir Angular hébergé dans le shell Electron.
appWindow.webContents.openDevTools()

Angular with .NET MAUI

dotnet build -t:Run -f net6.0-maccatalyst
Conclusion