Backgroundworker mit C#.net

[Anti-Programmierer (Gast)]

Kennt jemand ein gutes Tutorial zum Backgroundworker?
Ich möchte damit eine Filterung relisieren.
Habe versucht die Daten ohne Worker zu filtern, jedoch ist ab Beginn der 
Filterung das Programm zu langsam geworden und es hat unglaublich 
gehakt.
Nun muss ich das auslagern in diesen Worker.
Doch wie funktioniert das?
Ich habe immer 2 Werte die ich diesem übergebe. Das Filter ist 211 
Ordnung, d.h ich muss insgesamt 211 float Multiplikationen durchführen.
Wie übergebe ich nun die Daten, und bekomm ich so etwas wie einen 
Interrupt, wenn ein Filterwert fertig ist?. Muss die dann anschließend 
in ein Diagramm schreiben.
Über Hilfe wäre ich sehr dankbar

mfg
Anti-Programmierer

[Peter II (Gast)]

http://msdn.microsoft.com/en-us/library/cc221403%28v=vs.95%29.aspx

[Anti-Programmierer (Gast)]

Kannst du mir auch sagen, auf was Konkret ich da achten muss?
Die Seite hab ich schon durchgeschaut, aber mir ist noch ned wirklich 
klar wie ich das mit dem übergeben und dem multiplizieren machen muss

[Peter II (Gast)]

Anti-Programmierer schrieb:
> Kannst du mir auch sagen, auf was Konkret ich da achten muss?

nein nicht wirklich, weil ich ja nicht weiss was du kannst. Ich arbeitet 
selber aber nur mit normaln Thread und nicht mit dem Backgroundworker.

Hast du noch nie mit Thread gearbeitet?

[Anti-Programmierer (Gast)]

Nein
Habe das für ein Schulprojekt benötigt und mir selbst beigebracht und 
nun steh ich halt vor dem Problem, dass ein paar Sachen Macken machen.
Hab grad überprüft. Ich mach eine Double Multiplikation und das 211 mal, 
das dauert halt ewig lange, und ich muss das nun irgendwie optimieren da 
ich sonst nicht zusammenkomme...

[Peter II (Gast)]

Anti-Programmierer schrieb:
> Ich mach eine Double Multiplikation und das 211 mal,
> das dauert halt ewig lange, und ich muss das nun irgendwie optimieren da
> ich sonst nicht zusammenkomme...

was ist bei dir ewig lange? Sotwas sollte doch in ein paar ms erledigt 
sein.

Mit thread könnte man es so machen.

Man speicher die Werte in einer Liste
Starten den Thread und übergibt ihm die Liste
Wenn der Thread fertig ist, dann ruft er über delcates eine Funktion aus 
dem hauptprogramm auf, und dieser zeigt dann die Infos an.
Thread beendet sich

Zeig doch mal den code mit der Berechnung und ein paar zahlen wie lange 
es dauert.

[bluppdidupp (Gast)]

Beim Aufruf von .RunWorkerAsync() kann man als Parameter ein Objekt 
übergeben.
Im Worker selbst (DoWork) kann man über e.Argument an das Objekt 
drankommen.
Was auch immer im Worker produziert wird, packt man dann in e.Result 
rein.
Darauf kann man wiederrum in RunWorkerCompleted zugreifen.

Zwischenergebnisse könnte man über ReportProgress raushauen.

[Anti-Programmierer (Gast)]

 {
            #region Filter
            // Beim Start muss erstmal der Ringbuffer befüllt werden.
            if (hilfeee == 211)
            {
                for (int i = 0; i < 210; i++)
                {
                    Ringbufferx[i] = Ringbufferx[i + 1];
                    Ringbuffery[i] = Ringbuffery[i + 1];
                    if (hilfeee <= 104)
                        Atmungung[i] = Atmungung[i + 1];
                }
                Ringbufferx[210] = x;
                Ringbuffery[210] = y;
                Atmungung[104] = x;


            }
            if (hilfeee <= 210)
            {
                Ringbufferx[hilfeee] = x;
                Ringbuffery[hilfeee] = y;

                if (hilfeee <= 104)
                    Atmungung[hilfeee] = y;
                    

                hilfeee++;
            }
            else
            {
                for (int i = 0; i < 211; i++)
                {
                    xf = Koeffizienten[i] * Ringbufferx[i];
                    yf = Koeffizienten[i] * Ringbuffery[i];
                    CreateGraphHerz();

                }
            }

Hier führe ich meine Filterung durch.
Solange ich noch keine 211 Messwerte erhalten habe( also hilfeee < 211 
ist), aktualisiert er meine Diagramme so, dass die Messwerte schön 
flüssig dargestellt werden.
gehts dann aber weiter und es kommen weitere Messwerte hinzu, beginnt 
das unglaublich zu hacken und meine Diagramme werden nur mehr alle 
800-1000ms aktualisiert( vorhin ca alle 120ms)

Die Daten empfange ich mit:

 int RecievedLine = 0;

            //Test-Serielle-Schnittstelle: - Backgroundworker
            while (serialPort.BytesToRead != 0) // Abfragen, ob ein 2tes Byte bereits im Buffer ist.
            {                                   // Wenn ja, wird dies auch ausgelesen
                RecievedLine = serialPort.ReadByte();
                    h2 = h2 + 1;
                    if (h2 == 4)
                        h2 = 1;
                
                lbRecieved.Invoke(lbRecievedDelegate, new object[] { RecievedLine });
            }

Die Datei-Auswertung folgt dann:

 void InvokeLBRecieved(int Data)
        {
                #region Daten auswerten
               h1 = Data - '0';

              // this.Text = Convert.ToString(serialPort.BytesToRead);

               if (count1 == 0)
               {
                   if (h2 == 1)
                       Wert = h1 * 100;
                   if (h2 == 2)
                       Wert = Wert + h1 * 10;
                   if (h2 == 3)
                   {
                       Wert = Wert + h1;
                       h3 = Wert;
                       count1 = 1;
                   }
               }
               if (count1 == 1 & count3 == 0)// Bettsensor links hinten //ADC1
                {
                    hlihiP = h3;
                   // h2 = 0;
                    // Hier wird die Berechnung durchgeführt!
                    // 3 Empfangene Bytes ergeben 1nen Messwert! 
                    // Der erste empfangene Wert mit dem MSB muss ganz nach links geschoben werden
                    // Da wir nur 19 der 24 Bits für unsere Daten zur verfügung haben, müssen wir diese noch mit 5 nach rechts shiften.
                    if (count2 == 1) 
                    {
                       lihiP = (hlihiP << 16);
                    }
                    if (count2 == 2)
                    {
                        lihiP |= (hlihiP << 8);
                        
                    }
                    if (count2 == 3)
                    {
                           lihiP = lihiP + hlihiP;
                           lihiP = (lihiP >> 5);
                           lihiP = (lihiP << 5);
                           
                           // Durch den Höchswert dividieren und mit einem Wert( 1V?) multiplizieren, float, Variable
                           //Typecasten
                          // CreateGraphHerz();
                           count2 = 0;
                       //    tw.WriteLine(lihiP);
                           CreateGraphAll();
                           count3++;
                    }
                       count1 = 0;
                       count2 ++;
                }

Was mich wundert ist, dass er dann CreateGraphAll(); nur alle Sekunden 
oder so macht.
Meines Verständnisses sollte doch der Event-Handler von Data-Received 
die Filtermultiplikation unterbrechen und die Dateiauswertung machen 
oder liege ich da irgendwo falsch?
Die Dateiauswertung von oben wird ab dem if(count1 == 1 & count3 == 0) 
noch  5 mal fast gleich, bis auf die Abfragen durchgeführt. Erst beim 
letzten dieser Blöcke rufe ich meine Filterungsfunktion auf.

[Peter II (Gast)]

[c]
if (hilfeee == 211)
            {
                for (int i = 0; i < 210; i++)
                {
                    Ringbufferx[i] = Ringbufferx[i + 1];
                    Ringbuffery[i] = Ringbuffery[i + 1];
                    if (hilfeee <= 104)
                        Atmungung[i] = Atmungung[i + 1];
                }
                Ringbufferx[210] = x;
                Ringbuffery[210] = y;
                Atmungung[104] = x;


            }
[c]

das ist doch schon mal sehr fragwürdig. Warum die Abfrage
if (hilfeee <= 104)

Wenn vorher schon if (hilfeee == 211) abgefragt wird?

Dann solltest du dich mal wirklich mit dem Thema ringpuffer auseinander 
setzen. Er heist so weil es ein ring ist. Du schiebst du daten aber 
immer durch die gegend - warum? merk dir doch einfach die aktuelle 
Position dann liegen ebend die daten von 100..210..0..99 aber dafür 
sparst du dir die aktion 400werte zu verschieben.

[Peter II (Gast)]

for (int i = 0; i < 211; i++)
                {
                    xf = Koeffizienten[i] * Ringbufferx[i];
                    yf = Koeffizienten[i] * Ringbuffery[i];
                    CreateGraphHerz();

                }

das sieht auch merkwürdig aus, sicher das du CreateGraphHerz 211 mal 
aufrufen musst? Und globale variabeln sind auch nicht wirklich sinnvoll. 
Niemand sieht was mit xf oder yf passiert. Vermutlich verwendet 
CreateGraphHerz sie, aber das sieht niemand.

for (int i = 0; i < 211; i++)
{
   int xf = Koeffizienten[i] * Ringbufferx[i];
   int yf = Koeffizienten[i] * Ringbuffery[i];
   CreateGraphHerz(xf, xy);
}

würde die sache schon mal verständlicher machen.

[Anti-Programmierer (Gast)]

Stimmt die Abfrage mit den 104 kann ich mir ersparen.
Naja damit schreibe ich den neuen Wert immer an die letzte Position des 
Ringbuffers, wie soll ich das sonst gestalten?

[Peter II (Gast)]

Anti-Programmierer schrieb:
> Stimmt die Abfrage mit den 104 kann ich mir ersparen.
> Naja damit schreibe ich den neuen Wert immer an die letzte Position des
> Ringbuffers, wie soll ich das sonst gestalten?

nicht an die letze position, sondern an die nächste.

erst schreibst du von 0 bis 211 rein, dann machst du mit 0, 1, 2, 3, 4 
weiter und merkt dir die Stelle.

Wenn du also in der 4. Position etwas geschrieben hast, dann steht an 
der 5. Stelle der älteste Wert. Wenn du alle werte abfrage willst musst 
du dann also von 5 bis 211 und dann noch von 0 bis 4 durchgehen.

http://de.wikipedia.org/wiki/Warteschlange_%28Datenstruktur%29

[Anti-Programmierer (Gast)]

Stimmt, an das hab ich noch gar nicht gedacht, erspart wirklich einiges. 
Danke

[Anti-Programmierer (Gast)]

Oh Gott, so erst seh ich, dass das absoulter Schwachsinn ist^^.
xf ist ja die Summe aller Multiplikationen und das Diagramm muss ich 
auch erst danach aufrufen!
Das nervt mich jetzt^^ sicher schon 100mal drübergeschaut und das ist 
mir nie aufgefallen.

[Peter II (Gast)]

Anti-Programmierer schrieb:
> xf ist ja die Summe aller Multiplikationen und das Diagramm muss ich
> auch erst danach aufrufen!

aber dann stimmt das ja überhaupt nicht.

for (int i = 0; i < 211; i++)
{
   xf = Koeffizienten[i] * Ringbufferx[i];

hier wird doch xf immer überschrieben, damit gewinnt nur der letzt wert. 
(Das könnte man dann auch schneller programmieren)

[Anti-Programmierer (Gast)]

Jep, habs schon auf xf + Wert aus Multiplikation geändert.
Wie schneller gehts den? was ist dem am Effizientesten?
wäre froh wenn ich einfach die Funktion lassen kann und keinen 
BackgroundWorker machen muss^^

[Peter II (Gast)]

Anti-Programmierer schrieb:
> Wie schneller gehts den? was ist dem am Effizientesten?

nein ist schon ok, ich meinte das alte falsche verhalten hätte man auch 
so schreiben können:

xf = Koeffizienten[211] * Ringbufferx[211];

ohne schleife. Aber das wolltest du ja gar nicht.

> wäre froh wenn ich einfach die Funktion lassen kann und keinen
> BackgroundWorker machen muss^^
bei den paar werten lohnt sich das auch nicht. das wird wenn man es 
richtig gemacht ein ein paar ms berechnet.

Kannst ja deinen code noch  mal zeigen, nach dem du die fehler entfernt 
hast.

[Anti-Programmierer (Gast)]

Jo ich setz mich heute Abend ran und werd mal alle Fehler die ich finde 
ausbessern, ich stell ihn dann morgen rein damit du nochmal ein Auge 
drauf werfen kannst.
Ist es eig schneller wenn ich int64 anstatt von double verwende? ich hab 
zwar Koeffizienten die 0.000xxxxxxxxxxx Format haben, aber könnte diese 
Werte ja als ganzzahl nehmen und später noch ne Division durchführen

[Peter II (Gast)]

Anti-Programmierer schrieb:
> Ist es eig schneller wenn ich int64 anstatt von double verwende?

spielt bei den paar zahlen keine rolle.

[Anti-Programmierer (Gast)]

okay, danke

[Anti-Programmierer (Gast)]

So Sorry, war am Wochenende nicht motiviert am Programm zu arbeiten.

void Filterung()
        {
            #region Filter
            // Beim Start muss erstmal der Ringbuffer befüllt werden.
            if (hilfeee <= 210)
            {
                Ringbufferx[hilfeee] = x;
                Ringbuffery[hilfeee] = y;
                hilfeee++;
            }
            else
            {
                if (hilfsindex >= 211)
                    hilfsindex = 0;

                xf = 0;
                yf = 0;

                for (int i = 0; i < (211 - hilfsindex); i++)
                {
                        xf = xf + Koeffizienten[i] * Ringbufferx[hilfsindex + i];
                        yf = yf + Koeffizienten[i] * Ringbuffery[hilfsindex + i];
                }
                for (int i = (211 - hilfsindex); i < 211; i++)
                {
                    xf = xf + Koeffizienten[i] * Ringbufferx[hilfsindex2];
                    yf = yf + Koeffizienten[i] * Ringbuffery[hilfsindex2];
                    hilfsindex2++;
                }
                CreateGraphHerz(xf, yf);

                Ringbufferx[hilfsindex] = x;
                Ringbuffery[hilfsindex] = y;

                hilfsindex2 = 0;
                hilfsindex++;
            }
            #endregion
        }

Denk ich mir das so richtig?
Habe ein Filter 211 Ordnung, d.h beim ersten if, schreibe ich das Filter 
erstmal voll.
Sobald es voll ist arbeite ich den else Zweig durch und führe dort die 
Filterung durch. Dann kommt der Ringbuffer( da bin ich mir ned sicher ob 
der so stimmt)  und danach wieder von Anfang an den Ringbuffer 
beschreiben, mit Hilfsindex als Hilfsvariable

[Peter II (Gast)]

ich denke das kann man noch vereinfachen

[c]
bool init = false;

void Filterung()
{
   #region Filter

   Ringbufferx[hilfeee] = x;
   Ringbuffery[hilfeee] = y;

   hilfeee++;
   if (hilfeee >= 211) {
      init = true;
      hilfeee = 0;
   }

   if ( !init) {
      return;
   }

   xf = 0;
   yf = 0;
   for (int i = 0; i < 211); i++)
   {
      xf = xf + Koeffizienten[i] * Ringbufferx[hilfsindex + i];
      yf = yf + Koeffizienten[i] * Ringbuffery[hilfsindex + i];
   }
   CreateGraphHerz(xf, yf);

   #endregion
}

[Peter II (Gast)]

so 2.Versuch

bool init = false;

void Filterung()
{
   #region Filter

   Ringbufferx[hilfeee] = x;
   Ringbuffery[hilfeee] = y;

   hilfeee++;
   if (hilfeee >= 211) {
      init = true;
      hilfeee = 0;
   }

   if ( !init) {
      return;
   }

   xf = 0;
   yf = 0;
   for (int i = 0; i < 211; i++)
   {
      xf = xf + Koeffizienten[i] * Ringbufferx[(i+hilfeee-1)%211];
      yf = yf + Koeffizienten[i] * Ringbuffery[(i+hilfeee-1)%211];
   }
   CreateGraphHerz(xf, yf);

   #endregion
}

[Anti-Programmierer (Gast)]

hm danke, ich werde mir das mal durchdenken

[Anti-Programmierer (Gast)]

Weist du zufällig auch noch, wie ich während des ersten füllen des 
Filters einen Ladebalken einfüge? Msdn hilft mir da nicht wirklich 
weiter. Blockt der Ladebalken mein Programm, bzw muss ich das nun in 
einem Backgroundworker machen?

mfg

[Peter II (Gast)]

Anti-Programmierer schrieb:
> Msdn hilft mir da nicht wirklich
> weiter.
glaube ich nicht

> Blockt der Ladebalken mein Programm, bzw muss ich das nun in
> einem Backgroundworker machen?
warum sollte der Ladebalken dein Programm blockieren, im schlimmsten 
fall wird er nur nicht aktualisiert.

An was für einen Ladebalken hast du überhaupt gedacht?

void Filterung()
{
   #region Filter

   Ringbufferx[hilfeee] = x;
   Ringbuffery[hilfeee] = y;

   hilfeee++;

   LadeBalken++;

Evenutell müsstest du aber mal mehr von deinen code zeigen, dann man 
sieht ja nicht wie Filterung aufgerufen wird.

[Anti-Programmierer (Gast)]

Die Filterung wird gleich nach der seriellen Schnittstelle aufgerufen. 
Danach muss natürlich erst mal das Filter initialisert, also gefüllt 
werden. Während das geschieht soll er mir eine neue Form aufmachen, in 
der nur der Ladebalken ist und mit so anzeigt, wie weit die 
Initialisierung abgeschlossen ist. Das dauert so ca 20 Sekunden.
Währenddessen soll mein Hauptfenster deaktiviert sein ( aber nicht 
ausgeblendet, also nur so grau, damit der Benutzer nichts machen kann) 
erst wenn das Filter gefüllt ist soll das Fenster wieder aktiv werden

[Anti-Programmierer (Gast)]

Ich kann dir auch gerne den ganzen Programmcode senden wenn du willst, 
dann kannst du dir selbst davon ein Bild machen!