Warum wird das Programm langsamer?



  • using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.IO;
    
    namespace Equalizer
    {
        public partial class Form1 : Form
        {
            List<decimal> Proz;
            List<decimal> Wert;
            double TagesHighScore;
            bool NeuerHiscore;
    
            public Form1()
            {
                InitializeComponent();
            }
    
            private void btnTest_Click(object sender, EventArgs e)
            {
                label10.Text = "Suche...";
                NeuerHiscore = false;
                openFileDialog1.InitialDirectory = @"C:\Users\Klaus Werner\Desktop\Arbeit\TEST\#Test2011.11.01-2012.03.01\MA29StaerkeD.csv";
    
                if (openFileDialog1.ShowDialog() == DialogResult.Cancel)
                    return;
    
                DataTable Tabelle = new DataTable();
                Tabelle.Columns.Add("Punkte", typeof(double));
                Tabelle.Columns.Add("IndWert", typeof(double));
    
                bool ErsterDurchlauf = false;
                double Min=0.0, Max=0.0;
                string[] Files=openFileDialog1.FileNames;
                for (int i = 0; i < Files.Length; i++)
                    ReadCSV(Files[i], ref Tabelle, ref ErsterDurchlauf,ref Min,ref Max);
    
                for (double Var1 = -0.5; Var1 < 100; Var1 = Var1 + 33)
                {
                    for (double Var2 = -0.5; Var2 < 100; Var2 = Var2 + 33)
                    {
                        for (double Var3 = -0.5; Var3 < 100; Var3 = Var3 + 33)
                        {
                            for (double Var4 = -0.5; Var4 < 100; Var4 = Var4 + 33)
                            {
                                for (double Var5 = -0.5; Var5 < 100; Var5 = Var5 + 33)
                                {
                                    for (double Var6 = -0.5; Var6 < 100; Var6 = Var6 + 33)
                                    {
                                        for (double Var7 = -0.5; Var7 < 100; Var7 = Var7 + 33)
                                        {
                                            for (double Var8 = -0.5; Var8 < 100; Var8 = Var8 + 33)
                                            {
                                                for (double Var9 = -0.5; Var9 < 100; Var9 = Var9 + 33)
                                                {
                                                    Proz = new List<decimal>();
                                                    Wert = new List<decimal>();
    
                                                    if (Var1 > (double)(-0.5))
                                                    {
                                                        Proz.Add(10);
                                                        Wert.Add(numericUpDown1.Value);
                                                    }
                                                    if (Var2 > (double)(-0.5))
                                                    {
                                                        Proz.Add(20);
                                                        Wert.Add(numericUpDown2.Value);
                                                    }
                                                    if (Var3 > (double)(-0.5))
                                                    {
                                                        Proz.Add(30);
                                                        Wert.Add(numericUpDown3.Value);
                                                    }
                                                    if (Var4 > (double)(-0.5))
                                                    {
                                                        Proz.Add(40);
                                                        Wert.Add(numericUpDown4.Value);
                                                    }
                                                    if (Var5 > (double)(-0.5))
                                                    {
                                                        Proz.Add(50);
                                                        Wert.Add(numericUpDown5.Value);
                                                    }
                                                    if (Var6 > (double)(-0.5))
                                                    {
                                                        Proz.Add(60);
                                                        Wert.Add(numericUpDown6.Value);
                                                    }
                                                    if (Var7 > (double)(-0.5))
                                                    {
                                                        Proz.Add(70);
                                                        Wert.Add(numericUpDown7.Value);
                                                    }
                                                    if (Var8 > (double)(-0.5))
                                                    {
                                                        Proz.Add(80);
                                                        Wert.Add(numericUpDown8.Value);
                                                    }
                                                    if (Var9 > (double)(-0.5))
                                                    {
                                                        Proz.Add(90);
                                                        Wert.Add(numericUpDown9.Value);
                                                    }
    
                                                    if (Wert.Count >= 1)
                                                    {
                                                        //DataTable TempTabelle = new DataTable();
                                                        //TempTabelle.Columns.Add("IndWert", typeof(double));
                                                        double TempMin = 0.0;
                                                        double TempMax = 0.0;
    
                                                        string TempPfad = Path.Combine(Application.StartupPath, "Temp.txt");
                                                        StreamWriter Schreibe = new StreamWriter(TempPfad);
    
                                                        for (int i = 0; i < Tabelle.Rows.Count; i++)
                                                        {
                                                            double IndWert = ReturnWert(HoleProz(Convert.ToDouble(Tabelle.Rows[i][1]), Max, Min), Proz, Wert);
                                                            //TempTabelle.Rows.Add(IndWert);
                                                            Schreibe.WriteLine(Tabelle.Rows[i][0] + ";" + IndWert);
    
                                                            if (i == 0)
                                                            {
                                                                TempMin = IndWert;
                                                                TempMax = IndWert;
                                                            }
                                                            else
                                                            {
                                                                if (IndWert < TempMin)
                                                                    TempMin = IndWert;
                                                                if (IndWert > TempMax)
                                                                    TempMax = IndWert;
                                                            }
                                                        }
                                                        Schreibe.Close();
    
                                                        double AlleSteps4 = HoleStepwerte(TempMin, TempMax, 4);
                                                        double AlleSteps5 = HoleStepwerte(TempMin, TempMax, 5);
                                                        double AlleSteps6 = HoleStepwerte(TempMin, TempMax, 6);
                                                        double AlleSteps7 = HoleStepwerte(TempMin, TempMax, 7);
                                                        double AlleSteps8 = HoleStepwerte(TempMin, TempMax, 8);
                                                        double AlleSteps12 = HoleStepwerte(TempMin, TempMax, 12);
                                                        double AlleSteps18 = HoleStepwerte(TempMin, TempMax, 18);
                                                        double AlleSteps25 = HoleStepwerte(TempMin, TempMax, 25);
                                                        double AlleSteps30 = HoleStepwerte(TempMin, TempMax, 30);
    
                                                        double[] TradesImBereich4_1 = new double[4]; TradesImBereich4_1.Initialize();
                                                        double[] WinsImBereich4_1 = new double[4]; WinsImBereich4_1.Initialize();
                                                        double[] PunkteImBereich4_1 = new double[4]; PunkteImBereich4_1.Initialize();
    
                                                        double[] TradesImBereich5_1 = new double[5]; TradesImBereich5_1.Initialize();
                                                        double[] WinsImBereich5_1 = new double[5]; WinsImBereich5_1.Initialize();
                                                        double[] PunkteImBereich5_1 = new double[5]; PunkteImBereich5_1.Initialize();
    
                                                        double[] TradesImBereich6_1 = new double[6]; TradesImBereich6_1.Initialize();
                                                        double[] WinsImBereich6_1 = new double[6]; WinsImBereich6_1.Initialize();
                                                        double[] PunkteImBereich6_1 = new double[6]; PunkteImBereich6_1.Initialize();
    
                                                        double[] TradesImBereich7_1 = new double[7]; TradesImBereich7_1.Initialize();
                                                        double[] WinsImBereich7_1 = new double[7]; WinsImBereich7_1.Initialize();
                                                        double[] PunkteImBereich7_1 = new double[7]; PunkteImBereich7_1.Initialize();
    
                                                        double[] TradesImBereich8_1 = new double[8]; TradesImBereich8_1.Initialize();
                                                        double[] WinsImBereich8_1 = new double[8]; WinsImBereich8_1.Initialize();
                                                        double[] PunkteImBereich8_1 = new double[8]; PunkteImBereich8_1.Initialize();
    
                                                        double[] TradesImBereich12_1 = new double[12]; TradesImBereich12_1.Initialize();
                                                        double[] WinsImBereich12_1 = new double[12]; WinsImBereich12_1.Initialize();
                                                        double[] PunkteImBereich12_1 = new double[12]; PunkteImBereich12_1.Initialize();
    
                                                        double[] TradesImBereich18_1 = new double[18]; TradesImBereich18_1.Initialize();
                                                        double[] WinsImBereich18_1 = new double[18]; WinsImBereich18_1.Initialize();
                                                        double[] PunkteImBereich18_1 = new double[18]; PunkteImBereich18_1.Initialize();
    
                                                        double[] TradesImBereich25_1 = new double[25]; TradesImBereich25_1.Initialize();
                                                        double[] WinsImBereich25_1 = new double[25]; WinsImBereich25_1.Initialize();
                                                        double[] PunkteImBereich25_1 = new double[25]; PunkteImBereich25_1.Initialize();
    
                                                        double[] TradesImBereich30_1 = new double[30]; TradesImBereich30_1.Initialize();
                                                        double[] WinsImBereich30_1 = new double[30]; WinsImBereich30_1.Initialize();
                                                        double[] PunkteImBereich30_1 = new double[30]; PunkteImBereich30_1.Initialize();
    
                                                        double PunkteGesamt = 0;
    
                                                        StreamReader Lese = new StreamReader(TempPfad);
    
                                                        for (int i = 0; i < Tabelle.Rows.Count; i++)
                                                        {
                                                            double Punkte = Convert.ToDouble(Tabelle.Rows[i][0]);
                                                            PunkteGesamt += Punkte;
                                                            string Zeile=Lese.ReadLine();
                                                            string[] Spalte = Zeile.Split(';');
                                                            double NeuerWert = Convert.ToDouble(Spalte[1]);
    
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich4_1, WinsImBereich4_1, PunkteImBereich4_1, AlleSteps4, 4);
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich5_1, WinsImBereich5_1, PunkteImBereich5_1, AlleSteps5, 5);
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich6_1, WinsImBereich6_1, PunkteImBereich6_1, AlleSteps6, 6);
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich7_1, WinsImBereich7_1, PunkteImBereich7_1, AlleSteps7, 7);
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich8_1, WinsImBereich8_1, PunkteImBereich8_1, AlleSteps8, 8);
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich12_1, WinsImBereich12_1, PunkteImBereich12_1, AlleSteps12, 12);
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich18_1, WinsImBereich18_1, PunkteImBereich18_1, AlleSteps18, 18);
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich25_1, WinsImBereich25_1, PunkteImBereich25_1, AlleSteps25, 25);
                                                            InBereichAufteilen(TempMin, NeuerWert, Punkte, TradesImBereich30_1, WinsImBereich30_1, PunkteImBereich30_1, AlleSteps30, 30);
    
                                                            //#####################################################################################
                                                            // HIER IN DIESER FOR-SCHLEIFE VERWEILT DAS PROGRAM EXTREM LANGE!!!! NUR WARUM?
                                                            //#####################################################################################
    
                                                        }
                                                        Lese.Close();
    
                                                        PunkteGesamt = PunkteGesamt / Tabelle.Rows.Count;
                                                        ProzWerte_DurchschnittsWerte(TradesImBereich4_1, WinsImBereich4_1, PunkteImBereich4_1, TradesImBereich5_1, WinsImBereich5_1, PunkteImBereich5_1, TradesImBereich6_1, WinsImBereich6_1, PunkteImBereich6_1, TradesImBereich7_1, WinsImBereich7_1, PunkteImBereich7_1, TradesImBereich8_1, WinsImBereich8_1, PunkteImBereich8_1, TradesImBereich12_1, WinsImBereich12_1, PunkteImBereich12_1, TradesImBereich18_1, WinsImBereich18_1, PunkteImBereich18_1, TradesImBereich25_1, WinsImBereich25_1, PunkteImBereich25_1, TradesImBereich30_1, WinsImBereich30_1, PunkteImBereich30_1, Tabelle.Rows.Count);
    
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich4_1, WinsImBereich4_1, PunkteImBereich4_1, 4);
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich5_1, WinsImBereich5_1, PunkteImBereich5_1, 5);
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich6_1, WinsImBereich6_1, PunkteImBereich6_1, 6);
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich7_1, WinsImBereich7_1, PunkteImBereich7_1, 7);
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich8_1, WinsImBereich8_1, PunkteImBereich8_1, 8);
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich12_1, WinsImBereich12_1, PunkteImBereich12_1, 12);
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich18_1, WinsImBereich18_1, PunkteImBereich18_1, 18);
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich25_1, WinsImBereich25_1, PunkteImBereich25_1, 25);
                                                        SchreibeOptimierungenHeraus(PunkteGesamt, TradesImBereich30_1, WinsImBereich30_1, PunkteImBereich30_1, 30);
    
                                                        label10.Text = "Highscore von EinBereich ist: " + TagesHighScore;
                                                        label10.ForeColor = Color.Red;
    
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (NeuerHiscore)
                    MessageBox.Show("ENDE", "SMMrd_ENDE");
            }
    
            private void SchreibeOptimierungenHeraus(double Pkt_Gewinn, double[] TradesImBereich4_1, double[] WinsImBereich4_1, double[] PunkteImBereich4_1, int A_Bereiche)
            {
                List<double> ProzBereich = new List<double>();
                List<double> SchnittPkt = new List<double>();
                List<int> MerkeBereich = new List<int>();
                List<double> ProzWinsImBereich = new List<double>();
                bool NurEinBereichWerte = true;
    
                for (int i = 0; i < A_Bereiche; i++)
                {
                    if (Pkt_Gewinn < PunkteImBereich4_1[i])
                    {
                        ProzBereich.Add(TradesImBereich4_1[i]);
                        SchnittPkt.Add(PunkteImBereich4_1[i]);
                        ProzWinsImBereich.Add(WinsImBereich4_1[i]);
                        MerkeBereich.Add(i + 1);
                    }
                }
    
                List<double> Konstelation = new List<double>();
    
                for (int ProzB = 0; ProzB < ProzBereich.Count; ProzB++)
                {
                    for (int ProzP = 0; ProzP < SchnittPkt.Count; ProzP++)
                    {
                        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                        // Check verschiedenster Zellen-Konstelationen
                        int AnzKonst = 0;
                        double Konst = 1;
                        string VerwBereiche = "";
                        double ErwGe = 0, AddProzBer = 0, ProzWinTrades = 0.0;
                        //--------------------------------------------
    
                        for (int i = 0; i < SchnittPkt.Count; i++)    // i = Tabelle aller Werte der "Grünen" Zellen
                        {
                            if (ProzBereich[ProzB] >= ProzBereich[i] && SchnittPkt[ProzP] >= SchnittPkt[i])
                            {
                                // ######### Kriterien alle erfüllt #########
                                AnzKonst++;
                                VerwBereiche = VerwBereiche + MerkeBereich[i] + ",";
                                Konst += MerkeBereich[i];
                                ErwGe = ErwGe + (ProzBereich[i] * SchnittPkt[i]);       // zB: 12%Trades * 56%Gewinn
                                ProzWinTrades += (ProzBereich[i] * ProzWinsImBereich[i]);
                                AddProzBer += ProzBereich[i];     // zB: 12%Trades + 23%Trades.... SPÄTER: / 35%, somit Schnitt ProzWins
                            }
    
                        }
                        // ----------------------------------------------------------------------------------------------
                        bool NeueKonstelation = false;
                        if (AnzKonst != 0)      // Errechne Konstelationszahl
                        {
                            NeueKonstelation = true;
    
                            for (int i = 0; i < Konstelation.Count; i++)
                            {
                                if (Konstelation[i] == Konst && Konst != 1)              // Wenn Wert schon vorhanden, Dann keine neue Konstelation!!
                                    NeueKonstelation = false;
                            }
                        }
                        if (NeueKonstelation)        // Neue Konstelation JA ####### HERAUSSCHREIBEN DER DATEN BITTE HIER !!!! ######### 
                        {
                            Konstelation.Add(Konst);    // Merke Konstelationswert
                            double dErwGewPkt = ErwGe / AddProzBer;
                            double dErwProzWin = ProzWinTrades / AddProzBer;
                            double OptWert = dErwGewPkt - Pkt_Gewinn;
    
                            double EinBereichWert = -9999999.9;
                            double Bereichwert = OptWert * AddProzBer;
                            string[] Bereiche = VerwBereiche.Split(',');
                            int LetzterBereich = 0;
                            for (int i = 0; i < Bereiche.Length - 1; i++)
                            {
                                int BereichsZahl = Convert.ToInt32(Bereiche[i]);
                                if (i == 0)
                                {
                                    LetzterBereich = BereichsZahl;
                                    EinBereichWert = OptWert * AddProzBer;
                                }
                                else
                                {
                                    if (BereichsZahl == LetzterBereich + 1)
                                    {
                                        LetzterBereich = BereichsZahl;
                                    }
                                    else
                                    {
                                        EinBereichWert = -9999999;
                                    }
                                }
    
                                if (0 == Bereiche.Length - 2)
                                {
                                    EinBereichWert = OptWert * AddProzBer;
                                }
                            }
                            EinBereichWert = Math.Round(EinBereichWert, 1);
                            OptWert = Math.Round(OptWert, 3);
                            AddProzBer = Math.Round(AddProzBer, 4);
                            dErwGewPkt = Math.Round(dErwGewPkt, 4);
                            dErwProzWin = Math.Round(dErwProzWin, 2);
                            Bereichwert = Math.Round(Bereichwert, 1);
    
                            string VerwendeteBereiche = VerwBereiche.ToString();
                            VerwendeteBereiche = VerwendeteBereiche.TrimEnd(',');
    
                            bool Herausschreiben = true;
                            if (NurEinBereichWerte)
                                if (EinBereichWert < 0)
                                    Herausschreiben = false;
    
                            if (Herausschreiben)
                            {
                                if (EinBereichWert > TagesHighScore)
                                {
                                    NeuerHiscore = true;
                                    TagesHighScore = EinBereichWert;
                                    //MessageBox.Show(EinBereichWert.ToString());
                                }
                            }
                        }
                    }
    
                }
            }
    
            private void ProzWerte_DurchschnittsWerte(double[] TradesImBereich4_1, double[] WinsImBereich4_1, double[] PunkteImBereich4_1, double[] TradesImBereich5_1, double[] WinsImBereich5_1, double[] PunkteImBereich5_1, double[] TradesImBereich6_1, double[] WinsImBereich6_1, double[] PunkteImBereich6_1, double[] TradesImBereich7_1, double[] WinsImBereich7_1, double[] PunkteImBereich7_1, double[] TradesImBereich8_1, double[] WinsImBereich8_1, double[] PunkteImBereich8_1, double[] TradesImBereich12_1, double[] WinsImBereich12_1, double[] PunkteImBereich12_1, double[] TradesImBereich18_1, double[] WinsImBereich18_1, double[] PunkteImBereich18_1, double[] TradesImBereich25_1, double[] WinsImBereich25_1, double[] PunkteImBereich25_1, double[] TradesImBereich30_1, double[] WinsImBereich30_1, double[] PunkteImBereich30_1,int AnzTrades)
            {
                for (int Bereich = 0; Bereich < 4; Bereich++)
                {
                    WinsImBereich4_1[Bereich] = (WinsImBereich4_1[Bereich] * 100) / TradesImBereich4_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 5; Bereich++)
                {
                    WinsImBereich5_1[Bereich] = (WinsImBereich5_1[Bereich] * 100) / TradesImBereich5_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 6; Bereich++)
                {
                    WinsImBereich6_1[Bereich] = (WinsImBereich6_1[Bereich] * 100) / TradesImBereich6_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 7; Bereich++)
                {
                    WinsImBereich7_1[Bereich] = (WinsImBereich7_1[Bereich] * 100) / TradesImBereich7_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 8; Bereich++)
                {
                    WinsImBereich8_1[Bereich] = (WinsImBereich8_1[Bereich] * 100) / TradesImBereich8_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 12; Bereich++)
                {
                    WinsImBereich12_1[Bereich] = (WinsImBereich12_1[Bereich] * 100) / TradesImBereich12_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 18; Bereich++)
                {
                    WinsImBereich18_1[Bereich] = (WinsImBereich18_1[Bereich] * 100) / TradesImBereich18_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 25; Bereich++)
                {
                    WinsImBereich25_1[Bereich] = (WinsImBereich25_1[Bereich] * 100) / TradesImBereich25_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 30; Bereich++)
                {
                    WinsImBereich30_1[Bereich] = (WinsImBereich30_1[Bereich] * 100) / TradesImBereich30_1[Bereich];
                }
                //------------------------------------------------------------------------------------------------------------------------------
                for (int Bereich = 0; Bereich < 4; Bereich++)
                {
                    PunkteImBereich4_1[Bereich] = PunkteImBereich4_1[Bereich] / TradesImBereich4_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 5; Bereich++)
                {
                    PunkteImBereich5_1[Bereich] = PunkteImBereich5_1[Bereich] / TradesImBereich5_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 6; Bereich++)
                {
                    PunkteImBereich6_1[Bereich] = PunkteImBereich6_1[Bereich] / TradesImBereich6_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 7; Bereich++)
                {
                    PunkteImBereich7_1[Bereich] = PunkteImBereich7_1[Bereich] / TradesImBereich7_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 8; Bereich++)
                {
                    PunkteImBereich8_1[Bereich] = PunkteImBereich8_1[Bereich] / TradesImBereich8_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 12; Bereich++)
                {
                    PunkteImBereich12_1[Bereich] = PunkteImBereich12_1[Bereich] / TradesImBereich12_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 18; Bereich++)
                {
                    PunkteImBereich18_1[Bereich] = PunkteImBereich18_1[Bereich] / TradesImBereich18_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 25; Bereich++)
                {
                    PunkteImBereich25_1[Bereich] = PunkteImBereich25_1[Bereich] / TradesImBereich25_1[Bereich];
                }
                for (int Bereich = 0; Bereich < 30; Bereich++)
                {
                    PunkteImBereich30_1[Bereich] = PunkteImBereich30_1[Bereich] / TradesImBereich30_1[Bereich];
                }
                //------------------------------------------------------------------------------------------------------------------------------
                for (int Bereich = 0; Bereich < 4; Bereich++)
                {
                    TradesImBereich4_1[Bereich] = (TradesImBereich4_1[Bereich] * 100) / AnzTrades;
                }
                for (int Bereich = 0; Bereich < 5; Bereich++)
                {
                    TradesImBereich5_1[Bereich] = (TradesImBereich5_1[Bereich] * 100) / AnzTrades;
                }
                for (int Bereich = 0; Bereich < 6; Bereich++)
                {
                    TradesImBereich6_1[Bereich] = (TradesImBereich6_1[Bereich] * 100) / AnzTrades;
                }
                for (int Bereich = 0; Bereich < 7; Bereich++)
                {
                    TradesImBereich7_1[Bereich] = (TradesImBereich7_1[Bereich] * 100) / AnzTrades;
                }
                for (int Bereich = 0; Bereich < 8; Bereich++)
                {
                    TradesImBereich8_1[Bereich] = (TradesImBereich8_1[Bereich] * 100) / AnzTrades;
                }
                for (int Bereich = 0; Bereich < 12; Bereich++)
                {
                    TradesImBereich12_1[Bereich] = (TradesImBereich12_1[Bereich] * 100) / AnzTrades;
                }
                for (int Bereich = 0; Bereich < 18; Bereich++)
                {
                    TradesImBereich18_1[Bereich] = (TradesImBereich18_1[Bereich] * 100) / AnzTrades;
                }
                for (int Bereich = 0; Bereich < 25; Bereich++)
                {
                    TradesImBereich25_1[Bereich] = (TradesImBereich25_1[Bereich] * 100) / AnzTrades;
                }
                for (int Bereich = 0; Bereich < 30; Bereich++)
                {
                    TradesImBereich30_1[Bereich] = (TradesImBereich30_1[Bereich] * 100) / AnzTrades;
                }
            }
    
            static double ReturnWert(double ProzWert, List<decimal> Proz, List<decimal> Wert)
            {
                double Erg = 0.0;
    
                if (Proz.Count < 1)
                    return 0.0;
    
                int Index = -1;
    
                for (int i = 0; i < Proz.Count; i++)
                {
                    if (ProzWert <= (double)Proz[i])
                    {
                        Index = i;
                        i = Proz.Count;
                    }
                }
    
                if (Index == -1)
                    Index = Proz.Count;
    
                if (Index == 0) // if i == 0
                {
                    if (Proz[0] != 0)
                        Erg = ((ProzWert * 100) / (double)Proz[0]) * 1.0;
                    else
                        return 0;
    
                    Erg = ((double)Wert[0] / 100.0) * Erg;
                }
    
                if (Index != 0 && Index != Proz.Count) // else
                {
                    Erg = ProzWert - (double)Proz[Index - 1]; // 30% = 20 von Dif 40
                    double TempProz = (double)Proz[Index] - (double)Proz[Index - 1];//0-40
                    double TempWert = (double)Wert[Index] - (double)Wert[Index - 1];//-70-0
    
                    if (TempProz != 0)
                    {
                        Erg = (Erg * TempWert) / (TempProz);
                    }
                    else
                        return 0;
    
                    Erg = (double)Wert[Index - 1] + Erg;
                }
    
                if (Index == Proz.Count) // if i == Max Index
                {
                    Erg = ProzWert - (double)Proz[Proz.Count - 1];
                    double TempProz = 100 - (double)Proz[Proz.Count - 1];//0-40
                    double TempWert = 0 - (double)Wert[Proz.Count - 1];//-70-0
    
                    if (TempProz != 0)
                    {
                        Erg = (Erg * TempWert) / (TempProz);
                    }
                    else
                        return 0;
    
                    Erg = (double)Wert[Proz.Count - 1] + Erg;
                }
    
                return Erg;
            }
    
            private static double HoleProz(double IndWert, double Max, double Min)
            {
                double Proz100 = Max - Min;
                double Wert = IndWert - Min;
                Wert = ((Wert * 100) / Proz100);
    
                return Wert;
            }
    
            private static void InBereichAufteilen(double Min1, double Wert, double Punkte1, double[] TradesImBereich4_1, double[] WinsImBereich4_1, double[] PunkteImBereich4_1, double AlleSteps4_1, int AnzBreiche)
            {
                string[] Index;
                double Stepwert;
                int SpaltenIndex;
                string Spalte;
                double Punkte=0.0;
                // 4.Bereich
                try
                {
                    Stepwert = (Wert - Min1) / AlleSteps4_1;
                    Spalte = Stepwert.ToString();
                    Index = Spalte.Split(',');
                    SpaltenIndex = Convert.ToByte(Index[0]);
                    Punkte = Punkte1;
                }
                catch
                {
                    SpaltenIndex = 0;
                }
                if (SpaltenIndex < AnzBreiche)
                {
                    TradesImBereich4_1[SpaltenIndex]++;
                    if (Punkte > 0)
                        WinsImBereich4_1[SpaltenIndex]++;
                    PunkteImBereich4_1[SpaltenIndex] += Punkte;
                }
                else
                {
                    SpaltenIndex = AnzBreiche;
                    TradesImBereich4_1[SpaltenIndex - 1]++;
                    if (Punkte > 0)
                        WinsImBereich4_1[SpaltenIndex - 1]++;
                    PunkteImBereich4_1[SpaltenIndex - 1] += Punkte;
                }
    
                return;
            }
    
            double HoleStepwerte(double Minimum, double Maximum, int Bereiche)
            {
                double Wert = 0.0;
    
                Wert = Maximum - Minimum;
                if (Wert != 0)
                    Wert = Wert / Bereiche;
                if (Wert < 0)
                    Wert = Wert * (-1);
    
                return Wert;
            }
    
            void ReadCSV(String file, ref DataTable Tabelle, ref bool ErsterDurchlauf, ref double Min, ref double Max)
            {
                String rowValue;
                string[] cellValue;
    
                if (System.IO.File.Exists(file))
                {
                    StreamReader streamReader = new StreamReader(file);
    
                    streamReader.ReadLine();// Überschrift überspringen
    
                    while (streamReader.Peek() != -1)
                    {
                        rowValue = streamReader.ReadLine();
                        cellValue = rowValue.Split(';');
                        double IndWert = Convert.ToDouble(cellValue[6]);
                        object[] Objekte=new object[2]{cellValue[1],cellValue[6]};
                        Tabelle.Rows.Add(Objekte);
    
                        if (!ErsterDurchlauf)
                        {
                            Min = IndWert;
                            Max = IndWert;
                            ErsterDurchlauf = true;
                        }
                        else
                        {
                            if (IndWert < Min)
                                Min = IndWert;
                            if (IndWert > Max)
                                Max = IndWert;
                        }
                    }
    
                    streamReader.Close();
                }
    
            }
        }
    }
    

    Das Programm läuft am Anfang super schnell bis es nach ca 110 Schleifendurchläufen (VariablenÄnderungen) extrem langsamer wird. Ich habe es schon mit Datatable und StreamWriter/-Reader probiert, bei beiden genau das gleiche Problem. Es wird plötzlich sehr langsam und "hängt" bzw verweilt sehr lange in dem //#### markierten Bereich. Bitte um Ideen oder Anregungen (Ich bin noch nicht so lange in der programmierung tätig, somit bitte ich um verständnis).



  • Naja das kann schon vorkommen wenn 262144 sämtliche Reihen der Tabelle durchlaufen werden...
    Schon mal im Profiler geprüft ?



  • for (double Var1 = -0.5; Var1 < 100; Var1 = Var1 + 33)
                {
                    for (double Var2 = -0.5; Var2 < 100; Var2 = Var2 + 33)
                    {
                        for (double Var3 = -0.5; Var3 < 100; Var3 = Var3 + 33)
                        {
                            for (double Var4 = -0.5; Var4 < 100; Var4 = Var4 + 33)
                            {
                                for (double Var5 = -0.5; Var5 < 100; Var5 = Var5 + 33)
                                {
                                    for (double Var6 = -0.5; Var6 < 100; Var6 = Var6 + 33)
                                    {
                                        for (double Var7 = -0.5; Var7 < 100; Var7 = Var7 + 33)
                                        {
                                            for (double Var8 = -0.5; Var8 < 100; Var8 = Var8 + 33)
                                            {
                                                for (double Var9 = -0.5; Var9 < 100; Var9 = Var9 + 33)
                                                {
    

    👍 😃 👎

    Ohne das Programm jetzt genau verstehen zu wollen, vielleicht überforderst Du einfach den Garbage Collector. Würde mich nicht wundern bei den ganzen Arrays die du in der tief verschachtelten Schleife anlegst. Ahja und das ständige öffnen und schließen der Filestreams ist irgendwie auch nicht so toll.

    Was berechnest Du denn da?



  • Hallo werkla4,

    ich kann dir nur raten, dein Programm noch mal neu zu strukturieren (der Code ist einer der schlimmsten, den ich jemals gesehen habe - ist wirklich was für TheDailyWTF).

    Gerade als Anfänger solltest du so programmieren, daß du übersichtlichen Code schreibst.
    Zuersteinmal das wichtigste: trenne GUI und Logik, d.h. erzeuge dir für die ganzen Berechnungen eine eigene Klasse und rufe diese dann von der GUI aus auf.

    Und dann bin ich mir ziemlich sicher, daß du algorithmisch noch einiges an dem Code verbessern könntest (aber dazu müßte man ersteinmal verstehen, was dein Code überhaupt machen soll...).


Log in to reply