So, ich habe nun mal mit ngen.exe /delete * alle Assemblies entfernt und dann die Applikation gestartet.
Das Problem besteht leider immer noch.

Hast du zufällig noch einen anderen Tipp was ich mal ausprobieren könnte?
Bei dem Zielrechner handelt es sich um ein Thin-Client mit einem Flash Modul als Installationsbasis und einer Auslagerungsdatei die auf 0 MB gestellt worden ist um häufige Schreibzugriffe auf das Flashmodul zu verhindern.

Gruß, DonGyros

Danke für die Erklärung. Habe mich in der Zwischenzeit auch ein wenig in das Thema Native Image Cache eingelesen und jetzt hab ich auch eine bessere Vorstellung davon was da passiert 😁

Werde das wie gesagt heut abend mal probieren und mich dann hoffentlich mit einer Erfolgsmeldung melden 😁

Native-image-cache? Noch wie was von gehört aber man lernt halt nie aus 😁

Werde deinen Ratschlag heute abend nach der Arbeit mal befolgen und hoffen das das Problem damit behoben ist.

Hallo zusammen,

ich habe hier ein etwas merkwürdiges Problem. Ich entwickle seit einer Weile an einer Touchscreen-Oberfläche wo sehr viel mit GDI gezeichnet und animiert wird.
Auf meinem Entwicklunsgrechner läuft die Applikation wie geschmiert. D.h. alle Animationen usw. werden in der gewünschten Geschwindigkeit ausgeführt.

Auf dem Zielrechner sieht es anders aus. Da der auch von der Hardware nicht gerade der stärkste ist, muss ich ein paar Effekte abschalten was aber nicht das eigentliche Problem ist. Es geht viel mehr darum das ich es inzwsichen ein paar Mal geschafft habe das aus unerklärlichen Gründen einen neue Version der Applikation auf einmal total träge läuft und die Animationen z.B. im Schneckentempo ablaufen. Dabei habe ich auch nichts an der Art und Weise geändert wie gezeichnet wird.
Auf meinem Entwicklungsrechner hatte ich das Problem auch schon mal und nachdem ich die Entwicklung ein paar Tage hab ruhen lassen war das Problem auch wieder weg ?(

Verstehe ehrlich gesagt nicht so ganz wo da genau das Problem liegt. Kann mir nur vorstellen das eventuell das Betriebssystem hin und wieder mit was auch immer beschäftigt ist das dann die Applikation nicht genügend Ressourcen zur Verfügung gestellt bekommt aber ein Blick in den Taskmanager sagt etwas ganz anderes aus.

Mich würde mal interessieren ob ihr auch schonmal mit so einer Problematik konfrontiert worden seit oder vielelicht sogar einen Tipp habt woran das liegen könnte.

Gruß, DonGyros

Hmm, scheint wohl bisher niemand was dazu sagen zu können X(

Aktuell sieht der Stand folgendermaßen aus. Wobei ich ehrlich gesagt immer noch nicht weis welchen SocketType und welchen ProtocolType ich letztendlich verwenden sollte. Der folgenden Code wirft so erstmal keine Exceptions allerdings scheint er auch nichts zu bewirken, sprich der Receiver reagiert überhaupt nicht.

Socket socket = null;
try
{
                IPAddress ip = IPAddress.Parse("192.168.0.3");
                int port = 60128;
                IPEndPoint ip_port = new IPEndPoint(IPAddress.Parse("192.168.0.3"), port);

                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //socket.Blocking = false;
                //socket.Bind(ip_port);

                //verursacht eine Exception
                //socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, true);

                socket.Connect(ip_port);
                if (socket.Connected)
                    Console.WriteLine("Socket verbunden");
                else
                    Console.WriteLine("Socket nicht verbunden");
                
                
                //Header- und Datablock
                byte[] header = new byte[23];
                header[0] = 0x49;//'I'
                header[1] = 0x53;//'S'
                header[2] = 0x43;//'C'
                header[3] = 0x50;//'P'
                header[4] = 0x00;
                header[5] = 0x00;
                header[6] = 0x00;
                header[7] = 0x10;//Header Size
                header[8] = 0x00;
                header[9] = 0x00;
                header[10] = 0x00;
                header[11] = 0x07;//Data Size (7)
                header[12] = 0x01;//Version (1)
                header[13] = 0x00;//reserved
                header[14] = 0x00;//reserved
                header[15] = 0x00;//reserved

                header[16] = 0x31;// Unit Type "1"
                header[17] = 0x50;//'P'
                header[18] = 0x57;//'W'
                header[19] = 0x52;//'R'
                header[20] = 0x30;//'0'
                header[21] = 0x30;//'0'
                header[22] = 0x0D;//Carriage Return

                int result = socket.SendTo(header, ip_port);
                Console.WriteLine("Die Anzahl der gesendeten Bytes = > " + result);

               
                if(socket != null)
                {
                    socket.Shutdown(SocketShutdown.Both);
                    //socket.Disconnect(false);
                    socket.Close();
                    Console.WriteLine("Socket wurde beendet");
                } 

            }
            catch (SecurityException ex)
            {
                Console.Out.WriteLine("Fehler beim Herstellen der Verbindung zum Server, evtl. verursacht durch eine Firewall oder ähnliche Schutzmechanismen: " + ex);
            }
            catch (Exception ex)
            {
                Console.Out.WriteLine("Fehler beim Herstellen der Verbindung zum Server: " + ex);
            }

Hallo zusammen,

ich habe nach langer Suche herausgefunden das es wohl möglich ist meinne AVR (AudioVideoReceiver) über Ethernet zu steuern. Wenn ich das richtig sehe so muss ich allerdings wohl eigene Packete erstellen und diese an den AVR schicke.
Habe mal probiert das mit Hilfe von TcpClient zu lösen, das scheint aber doch etwas komplizierter zu werden.

Was ich also erstmal versucht habe ist folgendes:

string cmd = "1PWR00CR";//schaltet den AVR aus
TcpClient tcpClient = new TcpClient();
tcpClient.Connect(IPAddress.Parse("192.168.0.3"), 60128);
NetworkStream sendStream = tcpClient.GetStream();
byte[] sendBytes = System.Text.Encoding.Default.GetBytes(cmd);
sendStream.Write(sendBytes, 0, sendBytes.Length);

Anbei die Beschreibung des Paketaufbaues. Sofern jemand weis wie ich ungefähr vorgehen muss, würd ich mich über Infos sehr freuen!

Es lag wohl an der ersten Welle die nicht mit einer einheitlichen Farbe sondern mit einem Farbverlauf gefüllt wird. Das hat die hohe CPU-Last verursacht. Verpasse ich der ersten Welle eine einfache Farbe so reduziert sich die Auslastung auf ca. 20%.

So, nachdem ich das ganze mal auf GDI umgestellt habe (hat mich doch noch einiges an Nerven gekostet X() und ich das auf meinem Entwicklungsrechner mit einer anständigen Performance hinbekommen habe, kam die Ernüchterung relativ schnell als ich das Programm mal auf dem Zielrechner getestet habe.

Ich habe in meiner Applikation zwei UserControls in denen gezeichnet wird. Ein UserControl im Header-Bereich (hier wird die Hauptnavigation und zwei animierte Wellen gezeichnet). Und dann noch ein UserControl im Main-Bereich wo je nach Bedarf diese horizontale Scrolleiste gemalt wird.

Wenn das Programm gestartet wird sieht man nur das UserControl im Header-Bereich.

Auf meinem Centrino Duo 1,6GHz Notebook läuft die Wellen-Animation butterweich und verbraucht werden so ca. 10% CPU-Last.
Auf dem Zielrechner (ein ThinClient PC, 1 Ghz VIA C7) verbraucht das ganze schon ca. 100% CPU-Leistung. Und selbst bei der Auslastung läuft die Animation nicht mal flüssig.

Ich habe schon alles mögliche probiert komme aber momentan nicht weiter. Ich bin schon kurz davor mich in Direct3D einzuarbeiten weil ich die Hoffnung habe das dadurch die bestehenden Probleme nicht mehr so gravierend ausfallen dürften.

Anbei Code aus dem Wellen-UserControl:

        public MainNavigation()
        {
            InitializeComponent();

            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.UserPaint, true);

            DoubleBuffered = true;


            //-----------------------------------------------------------------------
            //unsichtbare Buttons erstellen (damit Click-Ereignisse ausgelöst werden können)
            //-----------------------------------------------------------------------
            Button b1 = new Button();
            b1.Name = "b1";
            b1.Size = new Size(80, 80);
            b1.Location = new Point(5, 5);
            b1.BackColor = Color.Transparent;
            b1.FlatAppearance.BorderSize = 0;
            b1.FlatAppearance.MouseOverBackColor = Color.Transparent;
            b1.FlatStyle = FlatStyle.Flat;
            b1.Click += new EventHandler(Button_Click);
            this.Controls.Add(b1);

            Button b2 = new Button();
            b2.Name = "b2";
            b2.Size = new Size(80, 80);
            b2.Location = new Point(85, 5);
            b2.BackColor = Color.Transparent;
            b2.FlatAppearance.BorderSize = 0;
            b2.FlatAppearance.MouseOverBackColor = Color.Transparent;
            b2.FlatStyle = FlatStyle.Flat;
            b2.Click += new EventHandler(Button_Click);
            this.Controls.Add(b2);

            Button b3 = new Button();
            b3.Name = "b3";
            b3.Size = new Size(80, 80);
            b3.Location = new Point(165, 5);
            b3.BackColor = Color.Transparent;
            b3.FlatAppearance.BorderSize = 0;
            b3.FlatAppearance.MouseOverBackColor = Color.Transparent;
            b3.FlatStyle = FlatStyle.Flat;
            b3.Click += new EventHandler(Button_Click);
            this.Controls.Add(b3);

            //Animation starten
            startAnimation();
        }

        private void startAnimation()
        {
            Timer t = new Timer();
            t.Interval = 70;
            t.Tick += FormTick;
            t.Start();
        }

Die Welle habe ich mit Hilfe eines GraphicsPath-Objektes erstellt. Sie besteht aus insgesamt 8 Koordinaten-Punkten.
In FormTick wird jetzt einfach für jeden der 8 Koordinaten-Punkte jeweils die Y-Koordinate verändert.
Am Schluss wird dann Invalidate() aufgerufen.

Und hier noch die onPaint-Methode

        protected override void OnPaint(PaintEventArgs e)
        {
            
            base.OnPaint(e);

            g = e.Graphics;

            //Wert auf Geschwindigkeit legen
            g.CompositingQuality = CompositingQuality.HighSpeed;
            g.SmoothingMode = SmoothingMode.HighSpeed;


            path.Reset();

            //++++++++++++++++
            //erste Welle
            //++++++++++++++++
            path.StartFigure(); // Start figure
            curvePoints1[0] = point1;
            curvePoints1[1] = point2;
            curvePoints1[2] = point3;
            curvePoints1[3] = point4;
            path.AddCurve(curvePoints1, 0, 3, 0.8f);

            path.AddLine(iWidth, 25, iWidth, 15);

            curvePoints2[0] = point5;
            curvePoints2[1] = point6;
            curvePoints2[2] = point7;
            curvePoints2[3] = point8;
            path.AddCurve(curvePoints2, 0, 3, 0.8f);
            path.CloseFigure();


            //die Welle mit einem Verlauf füllen
            pthGrBrush = new PathGradientBrush(path);
            // Farbe im Zentrum setzen
            pthGrBrush.CenterColor = Color.FromArgb(100, 255, 255, 255);
            // Farbe entlang der gesamten Grenze setzen
            colors[0] = Color.FromArgb(75, 224,224,224);
            colors[1] = Color.FromArgb(50, 194,194,194);
            colors[2] = Color.FromArgb(25, 164, 164, 164);
            colors[3] = Color.FromArgb(25, 104, 104, 104);
            pthGrBrush.SurroundColors = colors;
            g.FillPath(pthGrBrush, path);//Welle mit Farbe ausfüllen

            //Welle letztendlich zeichnen
            g.DrawPath(penWave1, path);

            //++++++++++++++++
            //zweite Welle
            //++++++++++++++++
            path = new GraphicsPath();
            path.StartFigure();
            curvePoints3[0] = point9;
            curvePoints3[1] = point10;
            curvePoints3[2] = point11;
            curvePoints3[3] = point12;;
            path.AddCurve(curvePoints3, 0, 3, 0.8f);

            path.AddLine(iWidth, 55, iWidth, 45);

            curvePoints4[0] = point13;
            curvePoints4[1] = point14;
            curvePoints4[2] = point15;
            curvePoints4[3] = point16;
            path.AddCurve(curvePoints4, 0, 3, 0.8f);
            path.CloseFigure();

 
            g.FillPath(brush, path);//Welle mit Farbe füllen

            //Welle letztendlich zeichnen
            g.DrawPath(penWave2, path);


            //+++++++++++++++++++++++++++++++
            //Buttons zeichnen (über den Wellen)
            //+++++++++++++++++++++++++++++++
            //Button1
            g.DrawImage(_image1, _rectB1);
            //Button2
            g.DrawImage(_image2, _rectB2);
            //Button3
            g.DrawImage(_image3, _rectB3);


        }

Vielleicht sieht ja jemand von den Experten auf den ersten Blick das ich an einer Stelle etwas total falsch mache und das das Problem sein könnte.
Ich glaube nicht wirklich das ich da noch was verbessern kann aber die Hoffnung stirb t zuletzt 😭

Ja das Ausrechnen ist das eine (was kein Problem darstellen sollte) aber wie definier ich dann nachher das um diesen Punkt skaliert werden soll?

Momentan setzte ich wie gesagt die Höhe und die Breite neu was bewirkt das das Skalieren so wirkt als ob der Skalierpunkt oben links in der Ecke sitzt.

Bleibt mir also nichts anderes übrig als in diesem Zuge auch die Position bei jedem Skalierungsschritt neu zu setzen/anzupassen?

Bei einem deiner Beispiel habe ich gesehen das du eine Matrix verwendest um in dem Fall ein Objekt um denn einen definierten Mittelpunkt zu drehen.
Die Scale-Methode des Matrix-Objektes bietet ja aber das setzen eines Mittelpunktes nicht an wenn ich das richtig gesehen habe.

Mal angenommen ich malen ein Bild auf eine Form:

g.DrawImage(_image, _rect);

Ich habe dann noch eine Zoom-Methode welche die Dimensionen des _rect-Objektes anhand eines übergebenes Faktors setzt. Letztendlich passiert in dieser Methode aber nichts anderes als das die Breite und die Höhe des _rect-Objektes neu gesetzt wird und anschließend eben gemalt wird.
Dadurch erreiche ich das das Skalieren animiert wird.
Jetzt ist es allerdings so das ich wohl auch die Position von _rect entsprechend anpassen sollte weil nach dem Skalieren die Position nicht mehr stimmt.
Wäre das die richtige Herangehensweise oder ist es besser eine andere Methode zu verwenden?

Am liebsten würde ich gerne um einen zentralen Punkt herum skalieren so das ein Anpassen der Location sozusagen überflüssig wird. Ist dies überhaupt möglich?

Vielen Dank an euch zwei!

Werde es dann mal über GDI und dem Ansatz von Andreas versuchen und hoffen das ich das gebacken bekomme 😁

Bei Fragen meld ich mich hier einfach nochmal.

Danke für die schnelle Antwort!
Welchen Ansatz würdest du dann eher bevorzugen? WPF oder doch GDI?
WPF wäre halt komplettes Neuland für mich aber wenn es sich eher lohnt darauf zu setzen dann werd ich mir das auch anschauen.

Gruß, DonGyros

Hallo zusammen,

letzte Nacht bin ich fast verzweifelt X(

Ihr kennt doch sicherlich aus HTPC-Oberflächen usw. so horizontale Scroll-Leisten wo
z.B. 5 Objekte/Grafiken angezeigt werden und das in der Mitte (also das ausgewählte) jeweils in vergrößerter Form dargestellt wird.
Ganz links und ganz recht hat man dann noch jeweils nen Button mit deren Hilfe man sozusagen durch die Liste scrollen kann.
Ich wollte das ganze natürlich so gestalten das eine Art Animation sichtbar wird.
Ich habe versucht das ganze so zu lösen das ich jeweils die einzelnen Objekte auf der x- bzw. y-Achse neu positioniere. Hat aber alles nicht zu einem zufriedenstellenden Ergebniss geführt.

Um es deutlicher zu machen:

<=[1] [2] [  3  ] [4] [5]=>

Drücke ich auf den Pfeil nach links dann will ich das sozusagen alles nach links scrollt. Dabei soll das Bild in der Mitte (3) bei scrollen nach links gleichzeitig verkleinert und neu positioniert werden (möglichst flüssig). Bild 4 soll beim nach links scrollen dann widerrum vergößert und neu positioniert werden.

Ich habe es mit einem Panel und darin befindlichen Komponenten (die dann verschoben und positioniert werden) probiert. Eventuell ist das für so etwas ein komplett falscher Ansatz (geht sowas mit WPF oder GDI besser)?

Ich wäre euch sehr dankbar wenn mir jemand zumindest die nötigen Stichwörter nennen könnte um mich auf den richtigen Weg zu bringen =)
Das ganze muss doch irgendwie lösbar sein.

Gruß, DonGyros

Das würde mich auch brennend interessieren. Allerdings scheint bisher niemand wirklich eine Antwort darauf zu haben.

Gruß, DonGyros

@ talla:

Danke für den Hinweis. Werde mal deinen Ratschlag befolgen und sehen was bei rauskommt 😁

Habe mal die UltraID3Lib ins Projekt gebunden und damit klappt das ohne Probleme.
Werde es wohl jetzt erstmal bei der Lösung belassen.

Falls jemand mir aber dennoch einen Tipp für obenstehendes Problem geben kann wäre ich sehr dankbar.

Gruß, DonGyros

Hallo zusammen,

ich drehe grad am Rad und hoffe das mir jemand von euch weiterhelfen kann 🙁

Ich ermittle ID3-Tags aus MP3-Dateien. Das funktioniert soweit eigentlich ganz gut.
Was ich aber absolut nicht hinbekomme ist das auslesen von ID3-Tags die griechische Zeichen enthalten. Ich glaube ich habe schon alles mögliche mit der Encoding Klasse probiert, komme aber einfach nicht auf ein zufriedenstellendes Ergebniss.

Byte-Array ermitteln:

                FileInfo file = new FileInfo(mp3File);
                Stream s = file.OpenRead();

                byte[] bytes = new byte[128];
                s.Seek(-128, SeekOrigin.End);
                int numBytesToRead = 128;
                int numBytesRead = 0;
                while (numBytesToRead > 0)
                {
                    int n = s.Read(bytes, numBytesRead, numBytesToRead);

                    if (n == 0)
                    {
                        break;
                    }
                    numBytesRead += n;
                    numBytesToRead -= n;
                }
                s.Close();

Ermittlung des Titels:

                string title = ByteToString(bytes, 3, 32);
 
               private static String ByteToString(byte[] bytes, int pos1, int pos2)
              {
                  if ((pos1 > pos2) || (pos2 > bytes.Length - 1))
                 {
                     throw new ArgumentException("Aruments out of range");
                 }

                 int length = pos2 - pos1 + 1;

                 Char[] chars = new Char[length];

                 for (int i = 0; i < length; i++)
                {
                   chars[i] = Convert.ToChar(bytes[i + pos1]);
                }

                return new String(chars);
        }

Anstatt der ByteToString-Methode habe ich jetzt eben probiert mit Hilfe der Encoding-Klasse und dem eigentlichen Byte-Array zu einem Ergebniss zu kommen.
Hab's mit UTF7,8,32,Default, getEncoding(mit diversen Codepages) usw. probiert. Hilft aber irgendwie alles nichts.

Die ID3-Tags hab ich probeweise auf folgende Weise gefüllt. Habe auf griechischen Internetseiten beliebige Wörter in die Zwischenablage kopiert und anschließend einer MP3-Datei über Rechtsklick,Eigenschaften,Dateiinfo eingefügt.
Musikplayer usw. kommen damit auch ohne Probleme klar nur ich irgendwie nicht 8o

Gruß, DonGyros

Hallo zusammen,

ich arbeite zur Zeit an einer Touchscreen-Steuerung womit ich z.B. Musik, Bilder usw. auswählen kann, sehen kann wer vor der Haustür steht wenn es klingelt usw. .

Auf der Hauptmaske werden unter anderem die neun aktuellsten/neuesten Musikverzeichnisse angezeigt. Das habe ich momentan mit einer Methode in meinem Controller gelöst:

public static ArrayList getNewAlbums()
        {
            if (newAlbums == null)
            {
                newAlbums = new ArrayList(9);
                DateTime newestDate = DateTime.MinValue;

                DirectoryInfo[] dis = GetAllDirs(@"z:\music");
                foreach (DirectoryInfo subDir in dis)
                {
                    if (subDir.GetFiles("*.mp3", SearchOption.TopDirectoryOnly).Length > 0)
                    {
                        if (newestDate < subDir.LastWriteTime)
                        {
                            newestDate = subDir.LastWriteTime;
                            if (newAlbums.Count < 9)
                            {
                                newAlbums.Insert(0, subDir);
                            }
                            else
                            {
                                newAlbums.RemoveAt(8);
                                newAlbums.Insert(0, subDir);
                            }
                        }

                    }
                }
            }
            return newAlbums;
        }

Die ArrayList wird also beim Start des Programmes initial befüllt. Danach überwache ich mittels FileSystemWatcher die Struktur und bei jedem neuen Ordner der z.B. hinzukommt, wird newAlbums angepasst.
Das Ganze scheint auch zu funktionieren allerdings kann es bei einer gewissen Anzahl von Verzeichnisse eine Weile dauern bis beim initialen Befüllen die neun aktuellsten ermittelt worden sind.
Gibt es für diese Idee vielleicht eine bessere Vorgehensweise oder könnte ich eventuell irgendwas verbessern?

Gruß, DonGyros

Normallerweise halte ich mich auch an das MVC-Prinzip und überlasse meinen Views nur die Darstellung und belaste Sie nicht mit irgendwelchen unnötigen Abläufen.
Hätte jetzt speziell in meinem erwähnten Fall nicht unbedingt erwartet das es da zu solchen Problemen kommt aber ich wurde eines besseren belehrt 😁

Werde in der Zukunft einfach noch mehr drauf achten müssen.
Vielen Dank an alle die Licht in die Angelegenheit gebracht haben 👍

Gruß, Panos

Also nur damit ich das richtig verstehe, eine zeitintensive Anweisung die in einer Methode erst nach einer nicht-zeitintensiven Anweisung folgt, kann dazu führen das die erste nicht-zeitintensive Anweisung blockiert?

Also wenn ich wie in meinem Fall einem Label Text zuweise, dann wird das Label also nicht sofort neu gezeichnet bzw. aktualisiert sondern erst zu einem späteren Zeitpunkt? Also in meinem Fall erst wenn auch die zeitintensive Anweisung durchgelaufen ist?

Wow, wenn das wirklich so ist dann nehm ich das mal so hin und muss mir in Zukunft noch mehr Gedanken bezüglich meines Codes machen.

Ja kann das aber wirklich sein? Ich mein die zeitintensive Abfolge und der von mir gezeigte Code (siehe oben) laufen ja nicht parallel sondern hintereinander ab.
Also wie könnte den Code der danach kommt eine Auswirkung haben?
Das würde doch ansich gegen jede Gesetzmässigkeit sprechen.

Hallo frisch,

die Verkettung mit += ist sicherlich keine gute Lösung (kenne die Problematik bereits aus der Java-Welt wo man für viele Verkettungen die StringBuffer Klasse verwenden sollte) allerdings sprechen wir in meinem Fall von gerade mal 3-4 Verkettungen.
Da sollte das eigentlich nicht ins Gewicht fallen. Der kompleet String besteht am Ende aus maximal 30 Zeichen.
Aber ich werde das auf jeden Fall mal ausprobieren.

UPDATE:
habe das soeben mit der StringBuilder Klasse probiert und konnte eine minimale Verbesserung feststellen. Das Problem besteht aber an sich weiterhin

Gruß, Panos

Hallo zusammen,

ich habe hier ein etwas merkwürdiges Problem und weis grad nicht wirklich weiter.
Eventuell kann mir ja der ein doer andere das Verhalten das ich gleich beschreibe erklären bzw. mir eine Lsöung für das Problem nennen.

Es existiert eine Methode die durch einen Button-Click aufgerufen wird.
Diese Methode kann tweilweise etwas zeitintensiv sein.
Allerdings wird gleich zu Begin folgender Code in dieser Methode ausgeführt:

//Way-Home ausgeben
this.labelWayHome.SuspendLayout();
this.labelWayHome.Text = "";
string actualWayhome = "";
for (int a = 0; a < wayHome.Count; a++)
{
   actualWayhome += "[ " + wayHome[a]+ " ]";
}
this.labelWayHome.Text += actualWayhome;
this.labelWayHome.ResumeLayout();

Erst nach diesem Teil kommt der etwas zeitintensivere Teil. Die Schleife in meinem Codeauschnitt macht ja wirklich nichts spektakuläres. Dennoch wird das komplette Label eine Zeit lang komplett mit einer grauen Farbe gefüllt bis man letztendlich den zugewiesenen Text zu sehen bekommt. BackGroundColor und ForeColor sind jeweils auf Transparent gesetzt. Habe es auch wie ihr oben sehen könnt über SuspendLayout und ResumeLayout versucht. Scheint aber nichts zu bringen.

Gruß, Panos

Mein Gott was soll ich dazu sagen 😄?
Es liegt wirklich da dran das ich meine neue Ansicht über einen eigenen Thread starte.
Nachdem ich das grad mal testweise über das erstellen einer neuen Instanz und den Aufruf von show() probiert habe, kann ich auch wieder die MCI-Instanz steuern.

Gruß, Panos

Hallo zusammen,

möchte mal diesen Thread aus gegebenem Anlass wieder zum Leben erwecken.
Ich habe ein wenig mein Programm umgestellt und stehe nun abermals vor dem oben genannten Problem "Gerät ist nicht geöffnet oder wird vom MCI nicht erkannt".

Die Ausgangssituation sieht dieses Mal folgendermaßen aus:

Auf der Main-GUI wird über ein Button-Click eine Aktion (Abspielen einer mp3-Datei) in meinem Controller gesetzt.
Der Controller triggert daraufhin eine seiner Methoden (mciStart()). Diese Methode erstellt eine MCI Instanz und startet die Wiedergabe.
Direkt im Anschluss daran wird auch über die Main-GUI einer neue Ansicht getriggert die ebenfalls in einem eigenen Thread läuft. Über diese neue Ansicht möchte ich nun sozusagen den Status (Stop, Pause, Resume) der MCI-Instanz kontrollieren.
Über einen entsprechenden Button-Click dieser neuen Ansicht, setze ich in meinem Controller eine neue Action und der Controller triggert daraufhin die mciStop()-Methode die in der Controller-Klasse definiert ist.

Und genau bei diesem Vorgang wird mir wieder oben erwähnte Fehlermeldung um die Ohren geworfen. Habe natürlich versucht mit der Invoke-Sache das Problem zu lösen aber irgendwie seh ich bei dieser Konstellation einfach kein Land.

Über einen Tipp der mich auf den richtigen Weg führt wäre ich sehr dankbar!

Gruß, Panos

Nein, ganz normale 3GHz Intel CPU mit 1GB RAM.
Das Notebook hat dazu im Vergleich ne 1,5GHz Centrino CPU mit 512MB RAM.

Hallo Golo Haas,

so etwa in die Richtung habe ich für eine saubere Lösung auch bereits angedacht.
Wollte wie gesagt nur mal ganz schnell schauen wie das aussehen könnte und hab das auf die beschriebene Art und Weise probiert.
Das die CPU-Last usw. ansteigt ist soweit ja auch klar.
Nur warum läuft das Ganze auf meinem Notebook praktisch ohne irgendwelche Probleme und ein anderer Rechner (hardwaretechnisch um ein vielfaches stärker) wird in die Knie gezwungen?

Hallo zusammen,

nachdem ich wieder angefangen an meiner HTPC Applikation weiterzuschreiben, bin ich inzwischen beim nächsten Problem angekommen.
Für das Abspielen von Videos benutze ich MCI-Funktionalität. Ich habe nun vor vor jedem Video-File eine Art Intro-Video abzuspielen.
Ich habe das mal auf die schnelle Qucik-And-Dirty-Methode folgendermaßen probiert:

mp.OpenFile("das Intro-Videofile");
mp.Play();

while (mp.Status.ToString().Equals("Playing"))//1=Playing
{
    Application.DoEvents();
}

mp.StopFile();
                    
mp.OpenFile("das eigentliche Videofile");
mp.Play();

Diese Zeilen Code haben auf meinem Notebook wunderbar funktioniert. Selbst ohne die Application.DoEvents()-Anweisung.
Auf meinem Rechner (wo die HTPC Anwendung laufen soll) funktioniert das Ganze nur unter sehr starker Verzögerung und Ruckeln (während des Abspielens des Introvideos).
Kann mir das jemand erklären? Der HTPC-Rechner ist auch was die Leistung angeht gut 2 Mal so mächtig wie mein Notebook.

Über Tipp und Hinweise wäre ich sehr dankbar!

Hallo Rainbird,

an sich hast du mich richtig verstanden.
Dazu sollte ich aber immer wissen welche Buttons sich um mich rum befinden damit ich bei dem KeyDown-Ereignis jeweils das richtige Control auswähle.

Nehmen wir mal folgendes an:

-ich befinde mich auf dem Button Mitte
-drücke ich die Pfeiltaste "Rechts" will ich auf dem Button Osten landen

oder

-ich befinde mich auf dem Button Süden
-drücke ich die Pfeiltaste "Rechts" will ich auch auf dem Button Osten landen

Dazu müsste ich ja beim KeyDown des Formulars erstmal generell überprüfen auf welchen Button ich mich befinde und dann anhand der gedrückten Taste entscheiden wo es lang geht. Komplizierter wird es dann ja wenn ich z.B. im Osten zwei oder mehr Buttons habe. Dann muss ich ja auch entscheiden auf welchen Button der Fokus gesetzt wird.

Eigentlich sollte ich doch für jeden Button ein KeyDown-Ereignis behandeln und für jeden Button explizit entscheiden wo es lang geht wenn eine entsprechende Taste gedrückt wird oder?

Aber was ist wenn zur Laufzeit dynamisch Buttons dazukommen?
Irgendwie ist das doch nicht so trivial wie ich gedacht habe 🙁

Hallo zusammen,

kann mir jemand einen Tipp geben wie ich am besten eine dynamische Reihenfolge erzeugen kann?
Ich kann zwar per TabIndex die Reihenfolge der Controls festlegen doch wie geh ich vor wenn ich das anspringen der Controls z.B. mit den Pfeil-Tasten der Tastatur lösen will?

Also nehmen wir mal an meine Form hat 5 Controls die in einer Art Kreuz angelegt sind.
Aso Control1 (Norden),Control2 (Osten),Control3 (Süden), Control4 (Westen) und Control5 (Mitte).

Jetzt nehmen wir mal an der Fokus sitzt auf Control5 (Mitte) und ich will jetzt in jede beliebige Richtung springen. Also entweder nach Norden, Osten, Süden oder Westen.

Welche Ansatzweise sollte ich für dieses Problem benutzen?
Für Tipps und Anregungen wäre ich sehr dankbar!

Falls es noch jemanden interessiert:

private const int portNum = 8765;//Defaultport des WinLirc
private const string hostName = "127.0.0.1";

try
{
TcpClient client = new TcpClient(hostName, portNum);
NetworkStream ns = client.GetStream();

byte[] bytes = new byte[1024];
int bytesRead = ns.Read(bytes, 0, bytes.Length);

Console.WriteLine(Encoding.ASCII.GetString(bytes, 0, bytesRead));

client.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}

Encoding.ASCII.GetString(bytes, 0, bytesRead) enthält die Antwort von WinLirc. In diesem String sollte unter anderem der Name der Taste drinstehen die bei der Konfiguration von WinLirc angegeben wurde.

Hallo zusammen,

es lag wirklich an der Invoke-Sache 🙂
Vielen Dank nochmal!

Ja,der Event läuft in nem anderen Thread.
Werde mir mal deinen Rat mit InvokeRequired genauer anschauen.
Danke für den Tipp!

Hallo zusammen,

mich plagt folgendes Problem. Ich habe vor einiger Zeit angefangen mir eine eigene HTPC Anwendung in C# zu schreiben.
Jetzt bin ich an den Punkt angekommen wo ich die ganze Applikation mit der Fernbedienung bedienen will. Das Abfragen der gesendeten Codes usw. funktioneirt auch ohne Probleme.

Mein Controller besitzt unter anderem Methoden zum starten,beenden und pausieren eines "MCI-Players". Die entsprechenden GUI's besitzen Buttons (Play,Stop,Pause) welche bei einem Click die entsprechenden Funktionen des Controllers aufrufen. Das funktioniert auch alles bestens.
Wenn meine GUI nun allerdings vom Controller benachrichtigt wird das eine Taste auf der Fernbedienung gedrückt wurde und ich dann auf diesen Tastendruck reagiere will indem ich z.B. die Funktion zum pausieren des MCI-Players aufrufe, erhalte ich folgende Meldung:

"Gerät ist nicht geöffnet oder wird vom MCI nicht erkannt"

Kann mir das jemand erklären? Das Gerät ist zu diesem Zeitpunkt aber definitv geöffnet. Es wird gerade etwas abgespielt. Pausiere ich das Ganze über den Button auf der GUI funktioniert das Ganze ja auch. Nur das Pausieren aus der EventHandler-Methode heraus funktioniert nicht.

Hallo herbivore,

gibt es eine Art und Weise die man als "richtig" ansehen würde? Ich mein ich kann auch einfach so losprogrammieren aber sauberer ist es ja wenn ich mich z.B. an ein Design-Pattern halte usw. .
Ich finde das Show und Hide Prinzip irgendwie nicht so prickelnd deswegen stell ich mir die Frage ob das generel (egal in welchem Umfang) sauberer Stil ist?

Also ich denke das ich auf Dauer mit den UserControls besser fahren werde.
Dazu stellt sich mir nun noch folgende Frage.

Momentan läuft es so das mein MainForm über einen Controller informiert wird welches UserControl im Hauptbereich dargestellt werden soll.
Was ich zur Zeit mache, ist das jeweils angezeigte UserControl von der MainForm zu entfernensobald ein neues angezeigt werden soll.
Ich habe auch schonmal hier im Forum gelesen das es wohl besser sein soll so Elemente eher zu "verstecken" und bei Bedarf einfach wieder einzublenden.
Denkt ihr auch das das in meinem Fall die bessere Lösung wäre? Abgesehen davon wäre das ja auch einje Optimierung in RIchtung Performance.

Also gut, dann werde ich mich mal an diese Vorgehensweise halten.
Danke für den Tipp!

Hallo zusammen,

nachdem mir dieses Forum schon das ein oder andere mal weitergeholfen hat, folgt nun mein erster eigener Beitrag 🙂

Ich bin gerade dabei eine eigene HTPC-Software zu schreiben. Da ich eigentlich aus der Java-Welt komme und mich momentan mehr oder weniger in C# einarbeite stellt sich mir folgende Frage.

Auf der MainForm habe ich diverse Buttons die einen bestimmten Bereich aufrufen (z.B. Musik,Filme usw.). Momentan habe ich es so gelöst das jeder dieser Punkte in einer eigenen Form implementiert ist. Bei Aufruf eines Punktes überlagere ich praktisch die MainForm mit einer neuen Form.
Ist das generell so sinnvoll oder sollte ich lieber das ganze mit Hilfe von UserControls entwickeln (habe bereits zwei die ich als sinnvoll erachte)? Warum ich mich das frage ist die Tatsache das die GUI an sich ja immer gleich aussieht (Hintergrundbild, Uhrzeit usw.) und durch die Art und Anzahl der jeweiligen Controls auf einer anderen Form (Musik,Filme usw.) sich unterscheidet.

Ich hoffe ihr versteht was ich meine? Also kann ich den eingeschlagenen Weg so weitergehen oder sollte ich doch für jeden Punkt (Musik,Filme, usw.) ein eigenes UserControl entwickeln und das je nach Auswahl der Buttons auf der MainForm einbinden?