Discussion :

[Rainui]

Bonjour,
J'ai créé une application WPF qui est composée de deux parties :

• Un "serveur" qui écoute un port en TCP IP et qui stocke les données dans une base SQLite
• Une interface qui permet d'afficher les données

Après avoir terminé mon application, je me suis posé la question de la disponibilité des données.
Je me suis rendu compte qu'il serait intéressant de continuer à enregistrer mes données même si mon application n'est pas lancée.
D'où ma question sur la création d'un service Windows qui s'occuperait de la récupération, du traitement et de la mise en base.
Je précise que l'ordinateur sur lequel doit tourner le programme est en marche en permanence.

Donc, mes questions :
Pensez vous que cette architecture soit judicieuse?
Si oui, est ce qu'il y a des précautions particulières à prendre (optimisation des ressources,...) dans la création d'un service (je n'en ai jamais fait )

Merci pour vos réponses éclairées.

[Pol63]

oui c'est judicieux

c'est comme une application avec ui mais sans ui, donc il n'y a pas de précautions de plus

[Rainui]

Bonsoir Pol63,
Merci pour ta réponse.
Ca me fait plaisir de voir que tu es toujours actif.
Je n'avais pas posté depuis bien longtemps

[Noxen]

Oui, dans ce cas là c'est une bonne idée. C'est un modèle d'architecture qu'on voit lorsqu'on a un service qui doit tourner en tâche de fond et auquel on peut accéder en passant par une interface graphique ou bien que peut joindre un autre service (j'ai en tête l'exemple de Docker Desktop). Pour cela tu faire peut mettre ton service dans une application console avec le modèle des hosted service.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Monitor;
 
await Host
    .CreateApplicationBuilder()
    .AddServices()
    .Build()
    .RunAsync();
 
static class Setup
{
    internal static HostApplicationBuilder AddServices(this HostApplicationBuilder builder)
    {
        builder.Services
            .AddSingleton<IPortListener, MockPortListener>()
            .AddTransient<IDataService, MockDataService>()
            .AddHostedService<PortMonitorHostedService>();
        return builder;
    }
}
 
namespace Monitor
{
    public interface IPortListener
    {
        Task RequestPortAsync();
        Task ReleasePortAsync();
        event EventHandler<string> MessageReceived;
    }
 
    public class MockPortListener : IPortListener
    {
        public Task RequestPortAsync() => Task.CompletedTask;
        public Task ReleasePortAsync() => Task.CompletedTask;
        public event EventHandler<string>? MessageReceived;
 
    }
 
    public interface IDataService { Task SaveAsync(string data); }
 
    public class MockDataService : IDataService
    {
        public Task SaveAsync(string data) => Task.CompletedTask;
    }
 
    public sealed class PortMonitorHostedService : IHostedService
    {
        private readonly IPortListener _listener;
        private readonly IDataService _service;
 
        public PortMonitorHostedService(IPortListener listener, IDataService service)
        {
            _listener = listener;
            _service = service;
            _listener.MessageReceived += OnMessageReceived;
        }
 
        public async Task StartAsync(CancellationToken cancellationToken) => await _listener.RequestPortAsync();
 
        public async Task StopAsync(CancellationToken cancellationToken) => await _listener.ReleasePortAsync();
 
        private async void OnMessageReceived(object? sender, string message) => await _service.SaveAsync(message);
    }
}

Je n'ai aucune idée de ton architecture exacte, mais je donne ici un exemple de la façon de faire. Ensuite, il te faudra voir comment tu veux faire communiquer ton application graphique avec ton service. Ça peut se faire via une api web (voir template web api) ou par un système plus particulier, comme les pipes (anonyme ou nommé) et bien un protocole RPC (Remote Procedure Call). Tu peux voir aussi si le service doit être lancé indépendamment ou si tu donnes l'option de le lancer à partir de l'application graphique.

[Pol63]

Bonsoir Pol63,
Merci pour ta réponse.
Ca me fait plaisir de voir que tu es toujours actif.
Je n'avais pas posté depuis bien longtemps

^^

selon si tu es en framework 4.x ou .net core 3 à 9 c'est un peu différent dans le code (mais pas dans le fonctionnement) (le code de noxen est pour .net core, sinon y a des exemples sur le net)
sc.exe (utilitaire windows) permet d'installer un exe en tant que service

[Rainui]

Je viens de regarder pour créer un service, ça n'a effectivement pas l'air bien compliqué.
Je vous remercie pour vos réponses qui me conforte dans l'idée.
Merci @Noxen pour l'exemple de code.

[StringBuilder]

En termes de précautions, il y a quand même la gestion des IDisposable à bien bétonner, ainsi que l'allocation mémoire.

En effet, une application avec UI, généralement elle ne reste allumée que quelques heures, le temps d'utilisation du PC, et même souvent pas en permanance.
Par cosnéquent, si t'as une fuite mémoire ou des locks sur des ressources qui ne sont jamais releasés (ou très tardivement) tu ne t'en rends pas forcément compte.
Au pire, quand ça commence à trop rammer, tu fermes l'appli et tu la relances.

Pour la partie service Windows, c'est un peu plus gênant, car il tourne 24/24 7/7 donc la moindre ressource par bien gérée, tu risques de ne jamais la rendre, et ainsi finir par avoir une surcharge importante du serveur pour rien.
Accessoirement le Service Windows risque d'avoir un impact plus important sur les ressources qu'une application utilisateur et donc là où ton appli s econtenterait de rammer sans forcément bloquer le serveur, le service, lui, peut amener Windows au blocage.

Donc par exemple, dans le genre de truc à pas faire, c'est de te dire "ok, tout ce que je reçois à stocker dans ma base SQLite je le charge en mémoire dans une List<T> ou autre objet, et vu que je sais facilement retrouver la denrière ligne, je m'amuse jamais à purger les vieilles données.
Ou alors un Bdd.Open() au début du programme et un Bdd.Close() à la fin (donc dans 3 ans).
=> Pendant ce temps la base SQLite est lockée, et impossible de la sauvegarder, quant aux snapshot du disque tu n'as aucune certitude qu'ils ne contiendront pas une base corrupue puisqu'elle est en permanance en cours d'utilisation, avec potentiellement des données dans le cache d'écriture non flushées.