Wir haben selbst viele Converter im Einsatz ich selbst verwende einen von Digitus, täglich 8 stunden über ein Jahr lang und mir ist dein Problem nicht bekannt.
Ich würde deswegen nicht pauschal sagen das USB/Serial Converter nichts taugen und man auf nativ tauschen muss.

Nur um sicher zu gehen du hast es auch mit einer nativen versucht und es liegt definitiv am Adapter?

Möglicher weiße löst sich dein Problem schon wenn du einen anderen Adapter verwendest, wir selbst unterschützen nur ein paar Adapter (da manche Probleme mit Handshake oder sonst irgendwas haben).

Wenn der Benutzer die Kategorien ebenfalls über Reflection angeboten bekommt, sehe ich kein Problem mit Reflection zu arbeiten.

in etwa so:

 public static Dictionary<string, Dictionary<string, List<T>>> GroupByProperties<T>(this IEnumerable<T> source, params string[] categories)
        {
            var properties = typeof(T).GetProperties().ToDictionary(keySelector => keySelector.Name);
            return categories.Where(properties.ContainsKey).ToDictionary(item => item, item => source
                .GroupBy(selector => properties[item].GetValue(selector, null))
                .ToDictionary(keySelector => keySelector.Key.ToString(), elementSelector => elementSelector.ToList()));
        }

Gibt dann ein Dictionary zurück das pro Kategorie einen Eintrag enthält, welcher wieder rum pro Gruppierung einen Eintrag und eine Liste vom Typ T enthält.
In meinem Beispiel habe ich die Gruppierungen auf String gecastet da du sie ja nur im Baum anzeigen willst.

Irgendwie hab ich das noch nicht ganz verstanden, willst du eine Gruppe nach Namen jedes Element in der Gruppierung nochmal Gruppiert in Altersgruppen oder willst du einmal eine Gruppierung nach namen und einmal eine Gruppierung nach Altersgruppen?

Verwechselst du vl GroupBy mit OrderBy, für mich macht eine so verschaltete Gruppierung mit unbekannter Tiefe kaum Sinn

Dann war darin kein PNG enthalten (Warum sollte man auch dem generierenden Tool glauben, das es wirklich reinsteckt, was es sagt das es reinsteckt..). Es war eine Simple BitMatrix.

ist nicht eine PNG-Datei sowieso schon mit LZ77 codiert

du hast dein PNG zuweit entpackt.

Aber ich bekomme es nicht hin, die Elemente nach ihren Typen zu untersuchen.

Nur der Vollständigkeit halber, der Operator den du suchst: is (c#)

t.Count(predicate => predicate is TestA)

OfType funktioniert natürlich auch.

Du kannst die Priority vom SerialPort DataReceived event nicht beeinflussen, das funktioniert nur wenn du mit den Methoden serialPort.Read / serialPort.Write arbeitest. Dabei kannst du die Priority des Threads der die Methoden aufruft erhöhen.

Ich kann mir jedoch auch nicht vorstellen das das dein Problem löst, Ich selbst habe damit schon einmal herum gespielt und konnte keinen unterschied feststellen. Bzw in meinem Fall konnte ich damit keine TimeOuts/Verschwundene Packete die durch hohe CPU last entstehen verhindern. (Falls das auch in etwa dein anliegen ist)

32 Bit Betriebssysteme können ca 3,5 GB RAM verwalten da Windows mit 2^32 nur 4G Addresseieren kann, minus Adressen von anderer Hardware bleiben etwas über 3,5GB für RAM (ca), wie auch immer eine 32bit .net Applikation hat ein Limit von 2GB pro Prozess. eine 64 bit Applikation hat ein Limit von einem TB und ein Limit von 2GB pro Object.

Ich glaube eine Applikation hat ein fixes Limit von 10.000 Window Handles,
Ich kenne deine Struktur nicht aber meine vermutung ist das du alle Handels/Controls am leben hältst, was bei großen seiten das Limit überschreitet.

Du solltest versuchen die Controls zu erstellen wenn sie benötigt werden, und dannach wieder freizugeben.

Die OutOfMemoryException begrundet das aber nicht. Hier kann ich nur raten. Vielleicht hast du irgendwo ein Memory Leak, erzeugst in den Controlls große Objekte die unnötig am Leben bleiben, oder etwas ähnliches.

Was gefällt dir an Process.Start nicht?
bzw Was ist dein genaues Problem dabei?

Jedoch kann ich mir nicht vorstellen das es ein Problem sein soll "mehrmals die sekunde" einige Controls zu aktualisieren. Wie oft ist bei dir mehrmals?

Bei mir funktionieren bis zu 30 Updates die Sekunde bei ~ 15 Controls die eine Änderung zeigen ohne Probleme / flackern (auch bei einem SingleCore Prozessor mit unter 1Ghz/Energiesparmodus)

if(!data.HasRows)
return false;

system.data.sqlclient.sqldatareader.hasrows

Das sind jedoch grundlagen, bitte beachte in Zukunft
[Hinweis] Wie poste ich richtig? 1.1, 1.1.1 und 2.1

Nochdazu fragst du in der Query schon ab ob ein Eintrag mit übereinstimmenden namen und passwort vorhanden ist, somit sind die If abfragen umsonst. Kurz könnte das so aussehen:

            using (SqlDataReader reader = mSql.query("SELECT * FROM Benutzer WHERE Benutzername='" + Benutzername + "' and Passwort='" + Passwort + "'"))
            {
                return reader.HasRows;
            }

Auch wenn man einen Login nicht als plain text in einer DB Speichern sollte

Hallo herbivore,

den unterscheid zwischen implicit und explicit kenne ich nicht. auch findet man zu den begriffen explicit captured closure / implicit captured closure nicht viel (nur bei implicit ein paar threads zu der R# warnung)

Ich muss gestehen, ich habe die Warnung von R# auch missverstanden, diese hat nämlich nichts mit dem gemeinsamen verwenden von variablen über mehrere Lambda Expressions zu tun(was ja durchaus gewollt sein kann), sondern mit dem ungewollten am leben halten von Großen Objekte / Potenziellen Memory Leaks.

Somit hat sich meine frage auch erübrigt ob es in Ordnung ist variablen über mehrere Lambdas gemeinsam zu verwenden. Ich stand wohl irgendwie auf dem schlauch.

Hallo Community,

Ich bin gerade dabei ein übernommenes Project zu Refactoren, dabei kommt mir des öfteren die R# Warnung: "Implicite Captured Closure: ...." unter,

Nun ist mir klar was das bedeutet, jedoch bin ich mir nicht sicher ob das ganze so gewollt ist. Unabhängig davon ob es gewollt ist oder nicht, wollte ich fragen ob es Probleme geben kann wenn man das Compiler verhalten ausnutzt um die gleichen Variablen zwischen verschiedenen Lambda Expressions zu verwenden, oder ob man auf klassen variablen umsteigen soll, wenn die man mit den selben variablen arbeiten will?

mfg Console

Ich kenne ein ähnliches Problem, warum das auftritt kann ich nicht sagen.

jedoch kommt es zu seltsamen verhalten wenn ich in einem Form per BeginInvoke versuche die aktuelle Operation nach hinten zu schieben bis ein UserControl in dem Form ein Invoke ausgeführt hat. Dabei ist es auch so das das Invoke nie ausgeführt wird während mein Form immer wieder mit BeginInvoke die selbe Methode aufruft.

Versuch einfach mal das Invoke auf das Form und nicht auf die Picturebox aufzurufen.

Okay der Grund warum der ursprünglich code nicht funktioniert ist hier beschrieben: starting-remote-desktop-client-no-control-over-pid-kill-pid-changes-after-star

Es ist auch ein Lösungsansatz beschrieben der wesentlich schöner ist als meiner 😉.

Das Problem ist das mstsc.exe trotz WaitForExit() sofort zurückkehrt (auch wenn das Remote Fenster noch offen ist). Kannst du mit folgendem Code ausporbieren:

Process.Start(@"C:\Windows\System32\mstsc.exe").WaitForExit();

Das Programm läuft ungebremst weiter.

Mit folgendem Code hat es funktioniert:

                Process.Start(@"C:\Windows\System32\mstsc.exe").WaitForExit();
                Process.GetProcessesByName("mstsc")[0].WaitForExit();

Wirklich schön ist das nicht und wenn bereits ein "mstsc" läuft müsste man irgendwie sicherstellen das der richtige Prozess von GetProcessesByName verwendet wird.

Kannst du den entsprechenden Code posten?

Mit deiner Beschreibung kann man leider nur Raten warum es nicht funktioniert.

Hallo meldano,

So etwas ähnliches gab es schon mal
UserControl mit Objekt als Property im Designer anpassen

Wenn du ein UserControl als Container Control haben willst (sprich Controlls von der Toolbox daraufziehen möchtest) genügt dieses Atribute bei deiner UserControl Klasse

    [Designer("System.Windows.Forms.Design.ParentControlDesigner, System.Design", typeof(IDesigner))]

Das liegt daran das es keinen + Operator für bytes gibt, da diese nicht für Rechenoperationen gedacht sind. Das Problem ist also das dein byte zu einem int convertiert wird (nicht nur weil die Zahl als int interpretiert wird).

Du kannst keine 2 bytes addieren und einem byte zuweisen.

Warum jedoch += funktioniert weis ich nicht.

Das Mapping von KeyValue (dem tatsächlichen input wert) auf einen KeyChar gibt es leider nicht im Framework.
Wenn du im KeyDown bereits den aus der KeyValue resultierenden Char willst hilft dir vielleicht dieser Beitrag weiter: Get the char on Control.KeyDown?

PS: @CoLo nein KeyValue ist nicht KeyChar du bekommst für KeyValue immer den selben Wert für die taste Z unabhängig vom Tastaturlayout / Shift Taste etc.

Du solltest für events immer EventHandler delegates verwenden / eine eigene EventArgs Klasse definieren.

Und das Prefix "On" steht für die Methode dein ein event feuert nicht für das event Selbst.

 public static event EventHandler<EventNameEventArgs> EventName;

        public class EventNameEventArgs : EventArgs
        {
            private bool visible;

            public bool Visible
            {
                get { return visible; }
                set { visible = value; }
            }
        }

        public void OnEventName(bool visible)
        {
           var handle = EventName;
            if(handle != null)
                handle(this,new EventNameEventArgs { Visible = visible };
        }

sprachen mischen finde ich Persönlich immer furchtbar hässlich 😉

Ich kenne das Problem als Workaround kannst du dir eine Kleine exe schreiben die die aktuelle DLL umbenennt und das ganze als Prebuild per cmd Parameter aufrufen.

visual-studio-2010-build-file-lock-issues

Hallo das ist relativ einfach du musst doch nur über alle Reihen iterieren sehen ob die Id anderes ist als beim letzten Durchlauf und dann die Farbe setzten.

Da es sich um eine ComboBox handelt arbeitet man mit dem aktuellen Item, nicht mit dem Text (ebenso wie bei einem ListView)

Das man immer Casten muss liegt daran das man den Items auch Komplexe Klassen zuweißen kann die ComboBox ruft dann immer das ToString des objects auf. Warum es keine Generische Version von ComboBox gibt bei der du den Typ der Items festlegen kannst weiß ich nicht.

comboBox1.SelectedItem

gibt dir nicht das richtige zurück?

Was ist der Unterschied zur Framework Klasse ?

MessageBox Class

BackgroundWorker Class enthält ein Event für Complete.

Möglichkeiten das zu Realisieren gibt es viele, jedoch sind das alles Grundlagen. Bitte Beachte [Hinweis] Wie poste ich richtig? 1.1 und 1.1.1.

Grundsätzlich gilt für Finalizer (afaik):

Finalize nur impementieren wenn deine Klasse direkt unmanaged Resources hält.
wenn diese bereits in einem Wrapper vorhanden sind, sollte der Wrapper im Finalize bereits alles nötige erledigen.

In diesem Fall nur bei disposing = true, das Dispose des Wrappers aufrufen.

warum musst du auf zahlen überprüfen du kannst doch einfach auch auf das Zeichen prüfen ??

if(!string.IsNullOrEmpty(textBox.Text) && textBox.Text[0] == '0')
    textBox.Text = textBox.Text.Substring(1);

Dein Interface sollte auch als interface definiert sein. wenn du es richtig gemcht hättest wäre es nicht möglich die Property als public zu definieren (da interface member immer public sind und der compiler das public nicht akzeptiert).

wenn ich das ganze nachbau mit simplen klassen, funktioniert es so wie es sollte.

       public interface ITest
    {
        ComplexClass ComplexClass { get; set; }
    }

    public class ComplexClass
    {
        public int Id { get; set; }
    }

    public class Form2 : Form, ITest
    {
        public ComplexClass ComplexClass { get; set; }
    }

    public class Form3 : Form, ITest
    {
        public ComplexClass ComplexClass { get; set; }
    }

So das ganze nochmal überarebietet:

 
    public class Lock : IDisposable
    {
        private readonly object lockObject;
        private static readonly ConcurrentDictionary<object, Ticket> Tickets = new ConcurrentDictionary<object, Ticket>();

        public Lock(object lockObject)
        {
            if (lockObject.GetType() != typeof(object))
                throw new ArgumentException("lockObject");

            this.lockObject = lockObject;
            Ticket ticket = Tickets.GetOrAdd(this.lockObject, (key) => new Ticket() { TicketCount = 0, CurrentTicket = 1 });

            int myTicket = Interlocked.Increment(ref ticket.TicketCount);
            Monitor.Enter(this.lockObject);

            while (true)
            {
                if (myTicket == ticket.CurrentTicket)
                    return;

                Monitor.Wait(this.lockObject);
            }
        }

        public void Dispose()
        {
            if (this.lockObject != null)
            {
                Interlocked.Increment(ref Tickets[this.lockObject].CurrentTicket);
                Monitor.PulseAll(this.lockObject);
                Monitor.Exit(this.lockObject);
            }
        }

        private class Ticket
        {
            public volatile int CurrentTicket;
            public volatile int TicketCount;
        }
    }

Dafür habe ich einen weiteren, noch nicht genannten Punkt. Wenn Monitor tatsächlich nicht FIFO wäre, dann könnte dein Code Stravation verursachen, wenn immer wieder der gleiche Thread, der eigentlich noch nicht dran ist, sich vordrängelt und als erster die Sperre bekommt, nur um festzustellen, dass er noch nicht dran ist und damit den Ablauf neu in Gang zu setzen, bis in alle Ewigkeit.

Das sollte nicht Passieren, da die vorgedrängelten Threads auf das Wait laufen, und dort solange stehen bis ein Thread im Dispose() das PulseAll() aufruft. Zumindest nach meinem Verständniss.

Danke, ich kenne die Optimale implementierung von Dispose, ändert jedoch nichts an der Funktionalität (und kann man ja gerne selber auf ein private Dispose(bool disposing) umschreiben).

Das einfügen ins Dictionary muss synchronisiert sein (habe ich oben eingefügt), danke für den hinweiß, die Integer Operation sind durch das Interlock threadsicher. (ich habe trotzdem die felder auf volatile geändert).

Das die Felder public sind liegt am ref der Increment Methode, da es sich um eine private Klasse handelt die nur zwei Zahlen kapselt habe ich beide als felder deklariert. Kann man auch ändern wenn es stört.

Hallo herbivore,

Die Aussage das es keine .NET Klasse gibt die wartende Threads in FIFO Reihenflolge abarbeitet stammt ebenfalls aus der Antwort im genannten Thread. Natürlich kann ich nicht sicherstellen das diese Richtig ist...

Mutex Objects (Windows) schreibt ebenfalls:

If more than one thread is waiting on a mutex, a waiting thread is selected. Do not assume a first-in, first-out (FIFO) order. External events such as kernel-mode APCs can change the wait order.

Die Funktionalität selbst implementieren kann man natürlich immer.
Könnte so aussehen: Funktioniert nur mit instanzen von object als lockObject! (da ich es nur so brauche)(

    public class Lock : IDisposable
    {
        private readonly object lockObject;
        private static readonly Dictionary<object, Ticket> Tickets = new Dictionary<object, Ticket>();
        private static readonly object TicketLock = new object;

        public Lock(object lockObject)
        {
            if (!lockObject.GetType().Name.Equals("Object", StringComparison.InvariantCultureIgnoreCase))
                throw new ArgumentException("lockObject");

            this.lockObject = lockObject;

            if (!Tickets.ContainsKey(this.lockObject))
            {
                lock (ticketLock)
                {
                    if (!Tickets.ContainsKey(this.lockObject))
                        Tickets.Add(this.lockObject, new Ticket() { TicketCount = 0, CurrentTicket = 1 });
                }
            }

            int myTicket = Interlocked.Increment(ref Tickets[this.lockObject].TicketCount);
            Monitor.Enter(this.lockObject);
            while (true)
            {
                if (myTicket == Tickets[this.lockObject].CurrentTicket)
                    return;
                else
                    Monitor.Wait(this.lockObject);
            }
        }

        public void Dispose()
        {
            if (this.lockObject != null)
            {
                Interlocked.Increment(ref Tickets[this.lockObject].CurrentTicket);
                Monitor.PulseAll(this.lockObject);
                Monitor.Exit(this.lockObject);
            }
        }

        private class Ticket
        {
            public volatile int CurrentTicket;
            public volatile int TicketCount;
        }
    }

using (new Lock(this.myLock))
{
     ///....
}

diese Aussage wird in
> gemacht.

Nein meine Aussage basiert auf der Antwort in diesem Thread Is there a synchronization class that guarantee FIFO order in C#?
die ebenfalls einen verweiß auf das von abt genannte buch/den genannten Absatz enthält.

Es gibt in .Net keine Synchronisationsklasse die die Wartenden Threads garantiert in FIFO Reihenfolge abarbeitet.

Bytes: 5, 6, 3, 4
66, 19, 78, 99
Hex 42, 13, 48, 63

Also bei mir ist 66, 19, 78, 99
als hex: 0x42134E63.
mit folgendem Code:

                float test = BitConverter.ToSingle(new byte[] {99,78,19,66}, 0);

bekomme ich: 36.82655

genau wie mit diesem Converter http://gregstoll.dyndns.org/~gregstoll/floattohex/

Bzw deine bytes sind falsch, laut IEEE 754 ist 36,8 als bytes:
0x421B3333 als hex bzw
66, 27, 51, 51 oder in verkehrter Reihenfolge..

eigentlich nichts, ich bekomme meine float als String mit Hexzeichen, sieht ähnlich aus:

                    uint floatAsInteger = uint.Parse(value.hexString, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
                    byte[] floatAsBytes = BitConverter.GetBytes(floatAsInteger);
                    return BitConverter.ToSingle(floatAsBytes, 0);

und funktioniert einwandfrei, muss an deiner Reihenfolge liegen.

Warum setzt du überhaupt die Priority vom Dispatcher, bzw ich kenn mich mit WPF nicht aus aber was hat das für einen Sinn?
Du solltest auch nicht bei jedem Element ein Label neu zeichnen lassen, vl alle 50 Elemente. Oder du verwendest einen Timer der alle x Millisekunden den aktuellen status anzeigt.

                this.myData.Add(currentItem);
                if (this.myData.Count % 50 == 0)
                    this.BeginInvoke(new Action(() =>
                        {
                            this.myResultCounterLabel.Content = this.myData.Count + " / " + this.count;
                        }));

Da man deinen aufbau nicht kennt kann dir wahrscheinlich niemand sagen ob es mit 4.5 besser geht. Grundsätzlich gibt es mit 4.5 ein paar neue Synchronisations Features. Async and await

Ob und wie Sinnvoll diese für dein Problem sind kann ich leider nicht sagen, aber grundsätzlich kann man das ganze bestimmt auch ohne .Net 4.5 sauber lösen.

Hallo Community,

Ich habe ein kleines Problem beim setzten eines Tooltips für ein ContainerControl(Panel)

Das Panel enthält ein Icon und zwei Textfelder, nichts aufregendes also.
Wenn ich jetzt den ToolTip auf das Panel setzte erscheint dieser nur wenn ich nicht über Icon / Textbox bin.

Wenn ich für alle Controls des Panels ebenfalls einen ToolTip setzte wird dieser immer angezeigt egal über welchem Control er gerade ist. Jedoch verschwindet er wenn ich das Control (im Panel) wechsle , und genau das will ich nicht.

Gibt es eine Möglichkeit den ToolTip für das Panel anzuzeigen unabhängig von dem Control im Panel über dem die Maus gerade steht?.

Richtig, das ginge. Allerdings gibt es nicht nur einen solchen "Teilungspunkt", sondern viele - so ein Spielzug besteht aus einer Serie von Aktionen. Jede dieser Aktionen ermöglicht eine gewisse Menge von Folgeaktionen, sodass eine Baumstruktur entsteht. Jeder dieser Baumknoten bräuchte dann seine eigene Instanz des Random-Generators. Möglich, aber ineffizient, vor allem bei vielen (1000 - 10000) Knoten.

Warum kann der Gesamte Baum nicht mit einem Random Generator aufgebaut werden? (Bzw 2 wenn du einen Preview und einen Spielzug haben willst, oder einer Queue anstelle des 2ten.)

Ich kann mir auch nicht vorstellen das 1000-10000 Random Objekte ein Problem sind,
Selbst wenn eine Instanz 1kbyte Speicher braucht (was sie nicht tut) wären das nur 20Mb wenn du jeden doppelt hast.

Du kannst dir einfach zwei Random-Generatoren mit dem Selben Seed erstellen somit sind die Ergebnisse des "vorraus schauens" die gleichen wie im Spielzug selbst.

Du kannst auch den Fokus bei jedem ToolStripItem einfach auf ein Panel oder was auch immer (ein Control das eben den Fokus erhalten kann) setzten dann wird das Leave automatisch ausgeführt.

... und bitte auch darauf achten, dass sowas wie Tausend-Trenner auch existieren, z.B.

Deutsch: 1.000.111,12
US: 1,000,111.12

Bei uns gibt es keine Tausender-Trenner.
Auch soll die Ausgabe zwar nach der Aktuellen Systemeinstellung erfolgen, die Eingabe von Zahlen jedoch unabhängig von Land und Sprache immer '.' und ',' als Dezimal Trennzeichen sehen. Bitte fragt mich nicht wieso ich mache diese Anforderungen nicht.

Ich weiß auch wie man Zahlen mit '.' als dezimal Trennzeichen akzeptiert jedoch war meine Frage ob man per NumberFormatInfo beide erlauben kann, ohne das ich eine eigene Methode schreiben muss die beide Bedingungen prüft.

EDIT: Wurde ja auch schon beantwortet...

Danke,

OKay 😉

Hallo Community,

gibt es eine Möglichkeit beim parsen von Text beide Dezimal Trennzeichen zu erlauben (via CultureInfo oder NumberFormatInfo) ? Oder muss ich mir dazu selbst etwas Basteln?

Bei Google hab ich jetzt nichts gefunden außer hundert Posts das man das nicht machen sollte.

Siehe:
[FAQ] Warum blockiert mein GUI? und
[FAQ] Controls von Thread aktualisieren lassen (Control.Invoke/Dispatcher.Invoke)

Bitte beachte in Zukunft [Hinweis] Wie poste ich richtig? Punkt 1.1.1