Discussion :

[ewaca]

bonjour,

j'ai réussi a faire le petit programme de calcul que je voulais, il fait ce que je lui demande, nikel, mais quand je pousse un peu sur le nombre de claculs, il ne répond pas jusqu'a la fin de l'éxécution. J'ai mis une progress bar histoire de savoir ou s'en est durant les longs calculs, mais du coup ça sert a rien :/
je voulais juste savoir si c'était normal, si ça voulais dire que c'était codé avec les pieds ou autres choses que je ne soupçonne pas.

merci

[PixelJuice]

Bonjour,

il est possible que ton calcul puisse être optimisé (il nous faudrait donc ta méthode de calcul )par contre , si le calcul est trop long quoi qu'il arrive , il te faudra le faire a l'aide d'un thread.

Si le programme ne réponds c'est que , ton calcul monopolise toute l'attention du thread principale , celui qui est aussi responsable de l'interface du logiciel , du coup il n'a plus le temps de s'occuper du programme lui même et freeze.

Tu peux aussi utiliser un BackgroundWorker , qui est un composant .NET qui permet de simplifier l'utilisation d'un Thread.

[Graffito]

Solution "Quick and dirty" : faire

Code :

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

Applications.DoEvents() ;

Après chaque mise à jour de la ProgressBar.

[The_badger_man]

Tu as un tuto ici: http://glarde.developpez.com/dotnet/bgworker/cs/

[ewaca]

merci pour vos réponses, je vais voir, je comptais essayer le multithreading donc vais déja voir pour un thread et si c'est trop compliqué je vais opter pour le background worker

voici mes boucles qui font varier les paramètres de mon calcul :

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
 for (double x = dxmin; x <= dxmax; x++)
                {
                    for (y = dymin; y <= dymax; y++)
                    {
                        for (double z = zmin; z <= zmax; z++)
                        {
                            for (double h = hmin; h <= hmax; h++)
                            {
                                for (double g = gmin; g <= gmax + 0.0001; g += 0.100000000000)
                                {
                                    prism[m, 0] = x;
                                    prism[m, 1] = y;
                                    prism[m, 2] = z;
                                    prism[m, 3] = h;
                                    prism[m, 4] = g;
                                    RMS = 0;
                                    Grav.CalculAnomalie(x, y, z, g, h, X, centre, Y, TailleMaille, maille, R, DG, anomalie);
                                    for (int i = 0; i < TailleMaille; i++)
                                    {
                                        RMS += Math.Sqrt(Math.Pow((G[i] - anomalie[i]), 2) /TailleMaille);//Math.Pow((G[i] - anomalie[i]), 2) / (G.Max() - G.Min())
                                    }
 
                                    prism[m, 5] = RMS; //ajoute la RMS en colonne 6 
                                    Trms[m] = RMS;
                                    progressBar1.Value = m;
                                    m = m + 1;
                                }
                            }
                        }
                    }
                }

et voici le détail de ma class Grav :

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
public class Grav
{
    static public double[] CalculAnomalie(double x, double y, double z, double g, double h, double [] X, double centre, double [] Y, int TailleMaille, double[,] maille, double[,] R, double[,] DG, double[] anomalie)
    {
        double x1 = X[(int)centre] - x / 2;
        //Console.WriteLine(x1);
        double y1 = Y[(int)centre] + y / 2;
        double z1 = z + 0.0000001;
        double Dg = g;
        double x2 = X[(int)centre] + x / 2;
        double y2 = Y[(int)centre] - y / 2;
        double z2 = z1 + h;
 
 
        //calcul des dx, dy, dz 
 
        for (int i = 0; i < TailleMaille; i++)
        {
            //Console.WriteLine(maille.GetLength(1));
            maille[i, 4] = x1 - maille[i, 0]; //dx1
            maille[i, 5] = x2 - maille[i, 0]; //dx2
            maille[i, 6] = y1 - maille[i, 1]; //dy1
            maille[i, 7] = y2 - maille[i, 1]; //dy2
            maille[i, 8] = z2 - maille[i, 2]; //dz1
            maille[i, 9] = z1 - maille[i, 2]; //dz2
        }
 
 
        //calcul de la distance du point a tous les bords du prisme
 
        for (int i = 0; i < TailleMaille; i++)
        {
            R[i, 0] = Math.Sqrt(Math.Pow(maille[i, 4], 2) + Math.Pow(maille[i, 6], 2) + Math.Pow(maille[i, 8], 2));
            R[i, 1] = Math.Sqrt(Math.Pow(maille[i, 4], 2) + Math.Pow(maille[i, 6], 2) + Math.Pow(maille[i, 9], 2));
            R[i, 2] = Math.Sqrt(Math.Pow(maille[i, 5], 2) + Math.Pow(maille[i, 6], 2) + Math.Pow(maille[i, 8], 2));
            R[i, 3] = Math.Sqrt(Math.Pow(maille[i, 5], 2) + Math.Pow(maille[i, 6], 2) + Math.Pow(maille[i, 9], 2));
            R[i, 4] = Math.Sqrt(Math.Pow(maille[i, 5], 2) + Math.Pow(maille[i, 7], 2) + Math.Pow(maille[i, 8], 2));
            R[i, 5] = Math.Sqrt(Math.Pow(maille[i, 5], 2) + Math.Pow(maille[i, 7], 2) + Math.Pow(maille[i, 9], 2));
            R[i, 6] = Math.Sqrt(Math.Pow(maille[i, 4], 2) + Math.Pow(maille[i, 7], 2) + Math.Pow(maille[i, 8], 2));
            R[i, 7] = Math.Sqrt(Math.Pow(maille[i, 4], 2) + Math.Pow(maille[i, 7], 2) + Math.Pow(maille[i, 9], 2));
        }
 
        //Calcul des anomalies liees aux differents bords
        for (int i = 0; i < TailleMaille; i++)
        {
            DG[i, 0] = -0.00667 * Dg * 1000 * (maille[i, 8] * Math.Atan(maille[i, 4] * maille[i, 6] / (maille[i, 8] * R[i, 0])) - maille[i, 4] * Math.Log(R[i, 0] + maille[i, 6]) - maille[i, 6] * Math.Log(R[i, 0] + maille[i, 4]));
            DG[i, 1] = 0.00667 * Dg * 1000 * (maille[i, 9] * Math.Atan(maille[i, 4] * maille[i, 6] / (maille[i, 9] * R[i, 1])) - maille[i, 4] * Math.Log(R[i, 1] + maille[i, 6]) - maille[i, 6] * Math.Log(R[i, 1] + maille[i, 4]));
            DG[i, 2] = 0.00667 * Dg * 1000 * (maille[i, 8] * Math.Atan(maille[i, 5] * maille[i, 6] / (maille[i, 8] * R[i, 2])) - maille[i, 5] * Math.Log(R[i, 2] + maille[i, 6]) - maille[i, 6] * Math.Log(R[i, 2] + maille[i, 5]));
            DG[i, 3] = -0.00667 * Dg * 1000 * (maille[i, 9] * Math.Atan(maille[i, 5] * maille[i, 6] / (maille[i, 9] * R[i, 3])) - maille[i, 5] * Math.Log(R[i, 3] + maille[i, 6]) - maille[i, 6] * Math.Log(R[i, 3] + maille[i, 5]));
            DG[i, 4] = -0.00667 * Dg * 1000 * (maille[i, 8] * Math.Atan(maille[i, 5] * maille[i, 7] / (maille[i, 8] * R[i, 4])) - maille[i, 5] * Math.Log(R[i, 4] + maille[i, 7]) - maille[i, 7] * Math.Log(R[i, 4] + maille[i, 5]));
            DG[i, 5] = 0.00667 * Dg * 1000 * (maille[i, 9] * Math.Atan(maille[i, 5] * maille[i, 7] / (maille[i, 9] * R[i, 5])) - maille[i, 5] * Math.Log(R[i, 5] + maille[i, 7]) - maille[i, 7] * Math.Log(R[i, 5] + maille[i, 5]));
            DG[i, 6] = 0.00667 * Dg * 1000 * (maille[i, 8] * Math.Atan(maille[i, 4] * maille[i, 7] / (maille[i, 8] * R[i, 6])) - maille[i, 4] * Math.Log(R[i, 6] + maille[i, 7]) - maille[i, 7] * Math.Log(R[i, 6] + maille[i, 4]));
            DG[i, 7] = -0.00667 * Dg * 1000 * (maille[i, 9] * Math.Atan(maille[i, 4] * maille[i, 7] / (maille[i, 9] * R[i, 7])) - maille[i, 4] * Math.Log(R[i, 7] + maille[i, 7]) - maille[i, 7] * Math.Log(R[i, 7] + maille[i, 4]));
        }
        //somme des DG
        for (int i = 0; i < TailleMaille; i++)
        {
            anomalie[i] = DG[i, 0] + DG[i, 1] + DG[i, 2] + DG[i, 3] + DG[i, 4] + DG[i, 5] + DG[i, 6] + DG[i, 7];
 
        }
        return anomalie;
    }
}

j'ai surement de mauvais habitudes en terme de nomenclature etc ... du coup ça risque d'etre un peu imbitable :/

[petitours]

Bonjour

Dans cette discussion
http://www.developpez.net/forums/d14...kgroundworker/
Ph_Gr m'a suggéré que le backgroundworker était devenu "has been ", avec l'arrivée de async/await dans le framework 4.5.

Pour avoir découvert le backgroundworker il y a quelques mois et le async/Await il y a quelques jours, je confirme que le async/await est d'une simplicité remarquable ! Il y a une notion de "tache" retournées par les fonction pas évidente à comprendre mais une fois compris c'est bien plus simple à coder et à relire ensuite.

Si jamais...