Bonjour la communauté,
Explicatif de mon projet.

• Gestion de budget, permet de créer des comptes bancaire et les gérer sur les transactions occasionnelle, mensuel
  sur le compte, ou faires des transactions entre comptes

Pour la mise à jour j'ai utilisé le lancement par un bouton puis j'ai testé avec les services et suis arrivé sur la planification des taches.

La je me retrouve avec un comportement que je n'aime pas, le planificateur  lance mon programme pour faire la mise à jour. 
ce n'est pas le comportement que je désire, je veux juste qu'il fasse la mise a jour des transactions mensuelle sans ouvrir mon application.
Si quelqu'un à la réponse, je suis preneur. Si besoin de codes je le collerai  du moins la création de ma tache.

Merci de m'avoir lu

Le planificateur ne fait que lancer des programmes.

Si vous voulez que quelque chose se fasse régulièrement, vous n'avez qu'à le programmer.

Si votre application "à bouton" sauvegarde des trucs dans une base/des fichiers/etc..., pourquoi le "machin" lancé par le planificateur ne pourrait pas les mettre à jour directement ?

salut bacelar, 

Merci d'avoir répondu. 

L histoire du bouton  c'était mon premier cas de figure pour tester ma mise a jour. cela fonctionnait mais je trouvait cela un peu barbare de devoir cliquer une fois par mois sur le bouton dans mon application pour des paiement mensuel qui doivent se faire automatiquement fin du mois.

Pour répondre a ceci : Si vous voulez que quelque chose se fasse régulièrement, vous n'avez qu'à le programmer. , 

je l'ai programme . 

Donc pour ne pas faire avec le bouton , j 'ai essaye avec les services mais même si cela fonctionnait laissé un service tourner pendant un mois à lui faire compter à l'aide d'un Timer, mauvaise utilisations du processeur pour ma part. Donc, je me suis dirigé sur le planificateur de tache.

Même si cela existe , je ne le connaissais pas du moins j'en ai jamais eu l'utilité.

Comme vous l'avez marquer plus haut, le planificateur de tache lance des programmes, ou script ou email. 

Ma question initiale était comment je peux faire pour ne pas lancer le programme pour qu'il s'ouvre en fesant la tache de mise à jour. Certaine tache  dans Windows se font en arrière plan sans ouvrir la programme donc cela doit bien être possible. 

La actuellement, j'essaie de tricher pour y arriver, si quelqu'un a une solution  je suis preneur sinon je continue de mon côté et vois pour y arrivé. 

Une solution possible (je ne sais pas si c'est la meilleure) c'est de faire en sorte que l'application puisse prendre des paramètres en lignes de commande et qu'il réagisse ensuite en fonction de celles-ci. Par exemple, faire que si on lance le programme par la ligne de commande monprog.exe /auto, celui n'affiche pas la fenêtre, fait l'action nécessaire et se ferme. et donc tu sais saisis cette commande dans le programme à exécuter de ton planificateur.

Salut Umfred,(joli prénom on a le même), J ai testé avec des paramètres mais j ai pas obtenu le résultat escompté.

Donc au final, je crée deux projet distinct en Windows Forms, un pour mon application, l'autre pour la mise à jour.

Une database commune aux deux projet. Le premier projet c'est l'application , et la mise à jour  je peux cacher la fenêtre a l'aide du hide, juste lui donner un timer pour qu'il se ferme. Ainsi , ma mise à jour pourra se faire en mode background sans qu'elle s'affiche et gênent l'utilisateur. Voila en gros, c'est la seul solution que j'ai trouvé qui fais ce que je désire.

Me reste plus qu'a gérer. 

L'installation et désinstallation de deux projet en même temps. Si il y a des tuto ici je suis preneur pour faire le exe d'install.

-
Edité par stymax 30 octobre 2023 à 15:27:44

Je trouve votre approche assez lourde.

Je vais donner 2 3 informations qui permettront peut-être de faire quelque chose de moins lourd.

Windows est composé de plusieurs sous-system, "wondow", "console", "Posix", et même maintenant "Linux".

Quand vous lancez un programme, le lanceur de l'OS détermine "dans" quel sous-système doit s'exécuter le programme.

Sous "console", il crée une console s'il n'a pas été lancé depuis une console où un programme ayant déjà une console.

Pour les autres sous-systèmes, c'est à l'application pour se démerder pour créer une IHM (Interface Homme Machine) avec les API offertes par le sous-système.

Windows dispose du concept de sécurité "WorkStation" qui fait en sorte que des programmes dans "WorkStation" différentes ne peuvent pas (ou difficilement) interagir entre eux via des fenêtres.

Quand vous vous logué au système, une "WorkStation" "utilisateur interactif" est créée, idem pour les connexions à distance, etc...

Les services s'exécutent, généralement, dans une "WorkStation" spéciale, la "WorkStation 0".

Donc, si vous faites une application console, il faudrait la mettre dans une "WorkStation" autre que celle de l'utilisateur interactif, ainsi, il ne verrait pas la console.

Dans le cas des applications non-console, c'est encore plus simple, vous n'êtes pas obligé de "créer" la moindre IHM.

En Winforms, l'IHM ne se lance qu'avec l'exécution de "Application.Run" dans la fonction Main.

En fonction du contenu dans la ligne de commande qui a lancé le programme, vous pouvez lancer ou ne pas lancer l'IHM.

Pour connaitre le contenu de la ligne de commande :

c# - How do I pass command-line arguments to a WinForms application? - Stack Overflow

Je vous conseille donc de faire UNE application Winforms.

Quand l'utilisateur la lancera "manuellement", elle affichera son IHM via "Application.Run".

Quand le scheduler lancera l'application, il y aura dans la ligne de commande les informations pour ne pas afficher l'IHM et faire le traitement demandé.

Avec cette approche, votre programme pourra travailler même si personne n'est connecté à la machine ("WorkSation 0"), pas d'oubli etc... .

Vous pouvez "facilement" mettre au bien l'application "en mode caché" car elle se comportera pareillement dans la "WorkSation 0" que dans la "WorkStation" de l'utilisateur interactif (ici, le développeur).

Vous n'avez qu'un exécutable à gérer.

Il faudra juste gérer correctement le cas où une instance interactive de l'application s'exécute pendant qu'une autre instance lancée automatiquement par le scheduler.

Je vais check le lien que tu as mis  

Un grand merci bacelar, j'ai retesté  à nouveau avec un paramètre, mais la différence c'est que ton lien m'a aidé. 

En gros j'avais testé cette approche, mais je gérais le cas du update comme paramètres dans ma page accueil. et sur ton lien j'ai vu que cela était possible de le faire dans program.cs. J'avais certainement une ligne de code qui intervenait et qui me bloquait le mode silencieux car elle activait (button , label ou autre).

Bref avoir discuté avec vous m'a permis de trouvé une solution et ne pas devoir gérer deux projet mais un seul comme cela doit être fais. 
Je place le code d'une création de la planification de tache qui permet d'ouvrir form2 avec un paramètre en cliquant ou laissant la tache s'exécuté. Sinon le programme agit normalement quand on le lance et reste sur form1.

Dans le program.cs 
 static void Main()
 {
     // To customize application configuration such as set high DPI settings or default font,
     // see https://aka.ms/applicationconfiguration.
    
     ApplicationConfiguration.Initialize();

     string[] args = Environment.GetCommandLineArgs();
     bool isSilentMode = args.Contains("/update");

     if (isSilentMode){

         Application.EnableVisualStyles();
         Application.SetCompatibleTextRenderingDefault(false);
         Application.Run(new Form2());
     }
     else
     {
         Application.EnableVisualStyles();
         Application.SetCompatibleTextRenderingDefault(false);
         Application.Run(new Form1());
     }
 }

Dans le Form1

 public partial class Form1 : Form
 {
     public Form1()
     {
         InitializeComponent();
         string taskName = "Test";
         string folderName = "TestInterface";
        
         using (TaskService ts = new TaskService())

         {
             TaskFolder folder = ts.GetFolder(folderName);
             if (folder == null)
             {
                 folder = ts.RootFolder.CreateFolder(folderName);
             }

             bool taskExists = false;
             foreach (var task in folder.GetTasks())
             {
                 if (task.Name == taskName)
                 {
                     taskExists = true;
                     break;
                 }
             }

             if (taskExists)
             {

                 labelStatus.Text = "La tâche existe déjà.";
             }
             else
             {
                 TaskDefinition td = ts.NewTask();
                 td.RegistrationInfo.Description = "Mise à jour des paiements mensuels";

                 // Configuration de la tâche pour qu'elle n'ouvre pas le programme

                 td.Settings.DisallowStartIfOnBatteries = true;
                 td.Settings.StopIfGoingOnBatteries = false;

                 td.Settings.AllowHardTerminate = false;
                 td.Settings.StartWhenAvailable = true;

                 DateTime triggerDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1, 0, 0, 0);
                 MonthlyTrigger trigger = new MonthlyTrigger(1) // Répétition chaque mois
                 {
                     StartBoundary = triggerDate

                 };
                 td.Triggers.Add(trigger);

                 td.Actions.Add(new ExecAction(GetApplicationExecutablePath(), "/update"));



                 folder.RegisterTaskDefinition(taskName, td);
             }
         }
     }
     private string GetApplicationExecutablePath()
     {
         return Application.ExecutablePath;
     }

 }

Pour le Form2 j ai juste changé la couleur du background en black de quoi différencier.

Pour cacher la Form2 suffit de placer un Hide();

Ici c'est juste pour montrer mais de cette manière vous pouvez l'adapter avec une tache

-
Edité par stymax 31 octobre 2023 à 1:36:22

Attention, une tâche planifiée qui ne demande pas à avoir une personne connectée sera lancé dans la "WorkStation 0", donc aucune fenêtre ne sera jamais visible, hide ou pas.