Dans l'environnement industriel, les contrôleurs à faible configuartion, comme ceux équipés de processeurs bicoeurs et de 2 à 4 Go de RAM fonctionnant sous Windows Embedded 7 ou 10, représentent une part significative du parc machine. Cependant, les méthodes de compilation et de gestion de la mémoire par défaut des applications IHM (Interface Homme-Machine) développées en C# peuvent souvent entraîner un encombrement important, des démarrages lents, une consommation excessive de mémoire et des ralentissements, voire des plantages. Cet article aborde ces défis en proposant des techniques concrètes d'optimisation pour la réduction de la taille des exécutables, l'accélération du démarrage, le contrôle de la mémoire résidente et la prévention des fuites, en tenant compte des spécificités des environnements industriels (communications Modbus/série, acquisition de données, fonctionnement 24/7).

I. Enjeux et Objectifs d'Optimisation pour les PC Industriels à Ressources Limitées

1. Problématiques Clés (Matériel + Logiciel + Contexte Industriel)

La convergence des contraintes matérielles, des défis logiciels et des exigences opérationnelles industrielles pose des défis spécifiques pour les applications IHM C#.

2. Objectifs d'Optimisation (Métriques Quantifiables)

Les objectifs suivants définissent les améliorations mesurables pour garantir la fluidité des applications sur des plateformes restreintes.

II. Compilation Allégée (Réduction de la Taille et Accélération du Démarrage)

1. Publication en Fichier Unique avec .NET 8 NativeAOT (La Stratégie Ultime)

L'approche NativeAOT de .NET 8 est la solution la plus efficace pour réduire drastiquement la taille des applications et accélérer leur démarrage, en compilant le code C# directement en code machine natif.

<!-- Configuration clé dans le fichier projet .csproj -->
<PropertyGroup>
  <TargetFramework>net8.0-windows</TargetFramework>
  <RuntimeIdentifier>win-x64</RuntimeIdentifier>  <!-- Ou win-x86 selon la cible -->
  <PublishAot>true</PublishAot>                     <!-- Active la compilation NativeAOT -->
  <PublishSingleFile>true</PublishSingleFile>       <!-- Crée un exécutable unique -->
  <PublishTrimmed>true</PublishTrimmed>             <!-- Supprime le code inutilisé -->
  <InvariantGlobalization>true</InvariantGlobalization> <!-- Exclut les ressources de globalisation -->
  <SelfContained>true</SelfContained>               <!-- Inclut le runtime .NET -->
  <EnableCompressionInSingleFile>true</EnableCompressionInSingleFile> <!-- Compresse le fichier unique -->
</PropertyGroup>

Commande de Publication (Permet de réduire la taille à 40–70 Mo) :

dotnet publish -c Release -r win-x64 --self-contained true

Comparaison des Résultats (Mesures réelles sur contrôleur J1900) :

Astuces d'Élagage :

• Supprimer les bibliothèques non utilisées : Par exemple, désinstaller ZedGraph ou InfluxDB si non requis.
• Utiliser ILLink : L'option <PublishTrimmed>true</PublishTrimmed> l'active automatiquement.
• Désactiver la globalisation : L'option <InvariantGlobalization>true</InvariantGlobalization> peut économiser 10 à 20 Mo.

2. Accélération du Démarrage (Points d'Optimisation Communs)

• Désactiver les initialisations superflues : Déplacer le chargement des ressources non essentielles (ex: modèles de rapports, données historiques) vers un thread d'arrière-plan ou à la première utilisation.
• Chargement différé des composants UI : Pour les contrôles complexes dans des TabControl ou Panel, utiliser SuspendLayout() et ResumeLayout() pour un chargement groupé.
• Éviter les opérations intensives au démarrage : Retarder le début des timers et des boucles d'acquisition (ex: démarrer 5 à 10 secondes après l'affichage de l'interface principale).

private async void FormulairePrincipal_ChargementAffiche(object sender, EventArgs e)
{
    // Afficher l'interface de base rapidement
    labelStatut.Text = "Initialisation en cours...";

    await Task.Delay(3000); // Introduire un délai avant de démarrer les tâches intensives

    timerAcquisitionDonnees.Start();
    timerMiseAJourUI.Start();
}

III. Gestion de la Mémoire (Prévention des Fuites et Réduction de la Consommation)

1. Utilisation Rigoureuse de using pour la Libération des Ressources (Source Fréquente de Fuites)

Assurez-vous que toutes les ressources implémentant IDisposable sont correctement libérées.

using var imageCapture = cameraDevice.Capturer.ObtenirImage(); // Acquisition d'une image
using var imageRedimensionnee = imageCapture.Redimensionner(nouvelleLargeur, nouvelleHauteur); // Traitement de l'image
using var imageBitmap = imageRedimensionnee.ConvertirEnBitmap(); // Conversion en Bitmap

// Libérer l'ancienne image avant d'affecter la nouvelle
if (zoneAffichageImage.Image != null)
{
    zoneAffichageImage.Image.Dispose();
}
zoneAffichageImage.Image = imageBitmap; // Affectation de la nouvelle image
// Note : imageBitmap est maintenant gérée par PictureBox.Image.Dispose() lors du remplacement ou de la fermeture du contrôle.

2. Désinscription Obligatoire des Événements (Point de Fuite Typique)

Une mauvaise gestion des souscriptions aux événements peut créer des fuites de mémoire, car l'objet émetteur maintient une référence à l'abonné, l'empêchant d'être collecté par le GC.

private void S_abonnerAuxEvenements()
{
    controleurPLC.DonneesRecues += TraiterDonneesPLC; // Abonnement
}

private void SeDesabonnerDesEvenements()
{
    controleurPLC.DonneesRecues -= TraiterDonneesPLC; // Désabonnement impératif
}

protected override void OnFormClosing(FormClosingEventArgs e)
{
    SeDesabonnerDesEvenements(); // S'assurer de désabonner lors de la fermeture du formulaire
    base.OnFormClosing(e);
}

private void TraiterDonneesPLC(object sender, DonneesPLCEventArgs e)
{
    // Logique de traitement des données
}

3. Limitation de la Taille des Tampons (Prévention de la Croissance Infinie)

Les tampons de données d'acquisition peuvent rapidement consommer toute la mémoire disponible s'ils ne sont pas gérés. Implémentez une politique de "fenêtre glissante" pour vos files d'attente.

private readonly Queue<ValeurCapteur> _bufferCapteurs = new Queue<ValeurCapteur>();
private const int TAILLE_MAX_TAMPON = 1000;

public void AjouterDonneeCapteur(ValeurCapteur donnee)
{
    lock (_bufferCapteurs) // Protection contre les accès concurrents
    {
        _bufferCapteurs.Enqueue(donnee); // Ajout de la nouvelle donnée
        if (_bufferCapteurs.Count > TAILLE_MAX_TAMPON)
        {
            _bufferCapteurs.Dequeue(); // Suppression de la donnée la plus ancienne
        }
    }
}

4. Déclenchement Manuel du Garbage Collector (Périodiquement sur Machines Limitées)

Bien que le GC de .NET soit automatique, un déclenchement forcé périodique peut aider sur des systèmes très limités, notamment pour compacter le tas des objets volumineux.

private void TimerNettoyageGC_Tick(object sender, EventArgs e)
{
    // Indiquer au GC de compacter le Large Object Heap une fois
    GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
    // Forcer une collecte de génération 2 et attendre la finalisation des objets
    GC.Collect(2, GCCollectionMode.Forced, true);
    GC.WaitForPendingFinalizers();
}

IV. Optimisations Pratiques pour les Scénarios Industriels

1. Limitation de la Fréquence d'Acquisition : Adapter dynamiquement la fréquence. Par exemple, si l'utilisation CPU dépasse 70%, passer l'intervalle d'acquisition de 200 ms à 500 ms.
2. Limitation de la Fréquence de Rafraîchissement UI : Mettre à jour les graphiques et les contrôles complexes toutes les 1 à 2 secondes. Utiliser des appels Invoke groupés pour les mises à jour de contrôles WinForms.
3. Désactivation des Fonctionnalités Non Essentielles : Désactiver le double buffering des contrôles (DoubleBuffered = false) ou la prise en charge des hautes résolutions DPI si non nécessaire.
4. Journalisation Simplifiée : En production, n'enregistrer que les avertissements (Warning) et les erreurs (Error). Désactiver la journalisation de niveau "Info".
5. Considérations après AOT + Trim :
   • Le code utilisant la réflexion peut nécessiter l'ajout de l'attribut [Preserve] pour éviter que des membres ne soient supprimés par l'élagueur.
   • Les DLL chargées dynamiquement devront être incluses manuellement dans le processus de publication si elles ne sont pas détectées automatiquement.

V. Synthèse : Liste des Optimisations C# pour PC Industriels

• Compilation : .NET 8 NativeAOT + Fichier unique + Trimming + Compression.
• Démarrage : Chargement différé des modules + Initialisation asynchrone.
• Mémoire : Utilisation stricte de using + Désabonnement systématique des événements + Limite de taille des tampons + Déclenchement manuel du GC.
• Acquisition : Traitement asynchrone + Limitation de fréquence + Désolidarisation des flux avec des canaux (System.Threading.Channels).
• UI : Rafraîchissement par lots + Saut de trames + Désactivation des animations superflues.
• Déploiement : Exécutable unique + Exécution en tant qu'administrateur + Démarrage automatique via le planificateur de tâches.