Discussion :

[Pfeffer]

Bonjour à tous,

Je souhaiterai faire en sorte que tant que ma fenêtre n'est pas complètement chargée, une barre de progression soit active.
Dans l'event onLoad de la fenêtre je charge mes données depuis la BDD et je fais les différents binds avec mes composants.

Comment faire assez simplement pour qu'une fenêtre de progression soit active tant que ma fenête principale n'est pas chargée ?

J'ai essayé avec les mots clés aync et await mais ma fenêtre freeze.
J'ai essayé avec un thread, idem.
J'ai essayé avec un beginInvoke, idem.

Une autre idée ?

[J@ckHerror]

Bonjour,

L'idée pourrait être de dissocier l'IU des accès BDD, et donc afficher une form avec une barre de progression, lorsque cette form est affichée alors charger les datas, et ensuite lorsque tout est ok, afficher une 2ème form qui traitera les données. As tu séparé les couches logiciels ? UI, business, bdd ??? parce que si ton SQL est dans le code de la form, tu vas avoir du mal à obtenir ce que tu veux...

J'ai essayé avec les mots clés aync et await mais ma fenêtre freeze.

Tu dois faire une mauvaise utilisation de ces mots clés, leur objectif étant de ne pas freezer les interfaces.

J@ck.

[Pfeffer]

Oui j'ai bien mes couches business object et DAO indépendantes de ma couche UI.
Le problème n'est pas tant la récupération des données en BDD, mais plutôt l'affichage dans le composant ...

[Benbout]

Dans le cas le plus simple, tu n'aurais pas besoin d'une barre de progression mais simplement d'une barre d'initialisation (et microsoft nous offre un composant de base pour cela, le meme que lors du chargement de windows, donc si tu ne veux pas te prendre la tête à faire ton propre template, c'est parfait!).

Concrétement, ca va se matérialiser de cette facon:

Code c# :

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
66
67
68
69
using GalaSoft.MvvmLight;
using MvvmLightDemo.Model;
using System.Threading.Tasks;
 
namespace MvvmLightDemo.ViewModel
{
    /// <summary>
    /// This class contains properties that the main View can data bind to.
    /// <para>
    /// See http://www.mvvmlight.net
    /// </para>
    /// </summary>
    public class MainViewModel : ViewModelBase
    {
        // ton service pour l'importation de données.
        private readonly IDataService _dataService;
 
        // les autres propriétés, je ne les écrit pas car
        // c'est un template sous MVVMLIGHT
        // et l'implémentation différera selon
        // le framework utilisé.
 
        /// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        public MainViewModel(IDataService dataService)
        {
            // récupération de ton/tes services
            _dataService = dataService;
 
            // initialisation de certaines propriétés
            // de ton viewmodel, dont la fameuse barre
            // d'initialisation
            LoadingBoard = true;
 
            // planification des evenements lié au service
            _dataService.LoadedData += _OnDataLoaded;
 
            // lancement de l'importation des données dans un autre thread
            // avec une tache en mode tir et oublie.
            // l'avantage, c'est qu'on peut l'utiliser dans une 
            // méthode non async sans probleme, ca ne bloquera pas
            var load_data_task = Task.Run(() => dataService.ImportData());
        }
 
        private void _OnDataLoaded()
        {
            // on hide la barre d'init.
            LoadingBoard = false;
            // a noter qu'il faudra peut etre
            // forcer la levée de la notification de changement
            // d etat de la propriété, selon
            // le framework utilisé.
 
            // réorganisation de la fenetre / changement
            // d'état / affectation de propriétés /  pour
            // la présentation finale / ou affichage d'une nouvelle
            // page dans le content view peu importe
            // etc
        }
 
        ////public override void Cleanup()
        ////{
        ////    // Clean up if needed
 
        ////    base.Cleanup();
        ////}
    }
}

Selon le framework utilisé, ce ne sera pas exactement pareil mais le principe est le même.
Et s'il faut a tout prix une barre de chargement, alors il suffira juste d'ajouter des evenements adéquat dans ton service. Le principe restant le meme que dans l'exemple (le service leve l'evenement d'update de sa progression, ton viewmodel execute une methode qui est inscrite au gestionnaire d'evenement du dit service, et s'occupe des notifications).

[J@ckHerror]

Désolé pour le retard,

Concernant les appels asynchrones, tu ne devrais pas avoir de soucis majeur à partir du moment ou tu as bien séparé tes couches, il nous faudrait un peu de code pour plus t'aider mais l'idée d'un appel async c'est =>

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
 
public class BusinessClass
{
 
}
 
public class AccesBdd
{
    IEnumerable<BusinessClass> GetBusinessClass(...){ .... sql .... }
 
    Task<IEnumerable<BusinessClass>> GetBusinessClassAsync(...)
    {
        Task.Run( () => this.GetBusinessClass(....));
    }
}
 
//Dans l'UI
private async void btGetBusinessClass_Click(object sender, EventArgs e)
{
     var repo = new AccesBdd();
     var businessClassItems = await repo.GetBusinessClassAsync(....);
}

J'ai mis l'appel asynchrone sur un clique bouton, pour tester.

J@ck.