InitializeComponent ? 😃

Edit: InitializeComponent aufrufen könnte helfen

[FAQ] Controls von Thread aktualisieren lassen (Control.Invoke/Dispatcher.Invoke)
Klasse die aus INotifyPropertyChanged erbt, läuft nicht im gleichen Thread

WindowsFormsSynchronizationContext muss natürlich im UI-Thread erstellt werden.. und nicht erst im Thread welcher den Event feuern will...

Überhaupt eine sehr eigenwillige Konstruktion hast Du da gebaut (EventArgs mit INotifyPropertyChange Halloooo ??)

Nur als Ergänzung... Wenn Du nur das Form brauchst... dann musst Du nicht durch die ganze Hierarchie... Control.FindForm ...

@Sebastian.Lange

Sehe ich auch so... deshalb auch mein Vorschlag zu Debuggen was im Designer abgeht... aber dem wollte er ja nicht folgen...

Ich klinke mich hier auch aus.

Mach mal das hier:

UserControl kann im Designer nicht hinzugefügt werden

Lade mal einen PrintScreen rauf

Wenn der Designer offen ist und alles angezeigt wird.
Dann zieh einen Button auf das Form.
Speichern
Button entfernen
Speichern
Alle Fenster schliessen
Solution bereinigen
VS schliessen
VS öffnen
Neu kompilieren
VS schliessen

So was hilft bei mir meistens (es erzwingt, dass der DesignerCode von VS neu geschrieben wird)... und die Bereinigung löscht ungültigen Schrott in Obj.

Wie sind die Variablen definiert in der Designer-Datei ?

@Abt: sehe ich auch so. Wir übertragen Daten an MDE (Win-CE/win-Mob) und zippen diese auch erst ab einer gewissen Grösse... (da es erst ab einer gewissen Grösse wirklich Vorteile bringt... vorher bringt es eher Nachteile)

Gruss
Programmierhans

Remove innerhalb foreach ist nict erlaubt.

Textboxen eines anderen Programmes füllen

[FAQ] TcpClient: einfaches Beispiel

Miss jedes mal die Zeit... dann den Durchschnitt + ein paar Prozent ... das ist die erwartete Laufzeit...

Je nachdem wie gross die Unterschiede von Tag zu Tag sind... triffst Du es dann besser oder schlechter.

FFMPEG sollte AMV können.

Google-Suche nach AMV ffmpeg .Net

in der Tat wäre eine Steuerung, die auf einem Benachrichtigungsmechanismus basiert, besser alles ein zeitgesteuertes Polling. Diesen Aspekt hatte ich in meiner ersten Antwort übersehen.

@herbivore

Allenfalls je nach Frequenz der Anpassungen wäre auch eine Kombination aus Event und Polling möglich.

--> Event setzt nur ein Flag dass sich irgendwelche Daten verändert haben
--> Timer holt dann die neue Darstellung

Dies hätte den Vorteil, dass häufige Anpassungen nicht zu allzu heftiger Auslastung führt und das Update besser geplant werden kann.

@camelord

Schau nochmal im Link welchen herbivore verlinkt hat... Da gibt es ein Update.

Interfaces liefern immer nur die direkt im Interface definierten Members.

Betrifft sowohl Type.GetProperties als auch TypeDescriptor.GetProperties.

Man kann sich aber eine eigene Implementierung der BindingList schreiben welche dann auch vererbte Interfaces implementiert.

Der folgende Code ist ein Prototype welcher für dieses Beispiel funktioniert... aber nicht zwingend für alle Fälle funktioniert.

    public class BindingListFullInterface<T>:BindingList<T>,ITypedList
    {
        private PropertyDescriptorCollection _PropertyDescriptorCollection = null;
        public BindingListFullInterface()
        {

        }
        public BindingListFullInterface(IList<T> pList):base(pList)
        {

        }

        private void CreatePropertyDescriptorCollection()
        {
            if (typeof(T).IsClass)
            {
                this._PropertyDescriptorCollection=TypeDescriptor.GetProperties(typeof(T));
                return;
            }

            Dictionary<string, PropertyDescriptor> dictPropDesc = new Dictionary<string, PropertyDescriptor>();
            List<Type> allTypes = new List<Type>();
            allTypes.Add(typeof(T));
            allTypes.AddRange(typeof(T).GetInterfaces());

            foreach (Type t in allTypes)
            {
                foreach (PropertyInfo pi in t.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy))
                {
                    dictPropDesc[pi.Name] = (TypeDescriptor.CreateProperty(t, pi.Name, pi.PropertyType));
                }
            }

            PropertyDescriptor[] arr = new PropertyDescriptor[dictPropDesc.Count];
            dictPropDesc.Values.CopyTo(arr, 0);
            this._PropertyDescriptorCollection= new PropertyDescriptorCollection(arr);
        }

        PropertyDescriptorCollection ITypedList.GetItemProperties(PropertyDescriptor[] listAccessors)
        {
            if (listAccessors == null || listAccessors.Length==0)
            {
                if (this._PropertyDescriptorCollection == null)
                {
                    this.CreatePropertyDescriptorCollection();
                }
                return this._PropertyDescriptorCollection;
            }
            return new PropertyDescriptorCollection(new PropertyDescriptor[] { });
        }

        string ITypedList.GetListName(PropertyDescriptor[] listAccessors)
        {
            if (listAccessors == null || listAccessors.Length == 0)
            {
                return typeof(T).Name;
            }
            else
            {
                return string.Empty;
            }
        }
    }

Edit:
-Added ctor's
-Added Caching
-Added missing return in CreatePropertyDescriptorCollection

Na dann debug mal... und schau ob Dein Code angesprungen wird... und ob er in den richtigen Case reingeht ...

Mach doch auf der DataTable eine Expression-Column

Ev. mit FlowLayoutPanels arbeiten... oder zwischen den Panels einen Splitter (Enabled=false) einfügen.

Als Anregung:

Rekursiver TreeView Save/Restore aufgrund des FullPaths

Wie wäre es mit:

Panels sichtbar lassen aber mit Höhe 0 ?

Wieso verwendest Du nicht Windows-Authentifizierung ?

Auswählen eines Authentifizierungsmodus

-Körpergrafik nicht speichern (die ist unveränderbar)
-Nur speichern welche Grafiken Du an welcher Stelle dazuzeichnen musst.
-Beim Repaint: 1 Körper zeichnen und dann alle zusätzlichen Grafiken

--> Es sieht dann so aus als wäre es eine Grafik... aber effektiv sieht es nur so aus

Verwendest Du einen Barcodescanner in Deiner Anwendung ? (Fokus auf dem Button / löst ev. Den Click aus)

@MailoKooiker

Poste doch bitte noch den nun angepassten Code... vielleicht wird es dir mal jemand verdanken der das selbe oder ein ähnliches Problem hat

Gruss
Programmierhans

@Bradley

Sieht doch schon mal nett aus... aber du solltest unbedingt auf die Rechtschreibung achten (ich bin da auch kein Hirsch...)... diverse Zeichendreher

z.B:
-menschliche Dummheit statt Menschliche Dummheit
-Metall statt Mentall
-Raketensperrfeuer statt Raktensperrfeuer

Naja mein Problem ist, das ich nicht ein ganzes Programm, dass evtl. mehrere 100-Zeilen Code umfasst, später die ganze Zeit in den Stringbuilder zu schreiben.

Lol ein paar hundert Zeilen ...Ich arbeite gerade an einer App in welcher 41000 Zeilen Code generiert sind... (und das ist nicht die grösste App).

CodeDom hat den Vorteil, dass Du Code in verschiedenen Sprachen generieren kannst (z.B: C# / VB / C)

Mit ein wenig Übung schreibt ist es mit der aktuellen Dokumentation ohne weiteres möglich fast alles zu generieren (wobei man nicht alles generieren kann... aber mit Umwegen ist es doch möglich). In meinem Job generiere ich jedenfalls jedenfalls ganze typisierte Proxies.

Wenn es damit Performance Probleme gibt, hast das Ganze mal gegen einen ganz klassischen rekursiven Ansatz getestet? Ohne großartig auf Linq zu setzen?

z.B: So: Rekursiver TreeView Save/Restore aufgrund des FullPaths

Such mal nach InvariantCulture

Mein SQL ist zwar schon stark eingerostet... aber wäre das nicht "Select TOP 100 From ....."

Was meinst du mit den DLL-Aufrufkonventionen?

CallingConvention-Enumeration

Mach Projekt zu... lösche OBJ-Verzeichnis

Ev. hifts ja

Lesen könnte helfen: DataGridViewComboBoxCell.DisplayStyle-Eigenschaft

Kleiner Trost : Vor VS2010 war das noch viel schlimmer.

In VS 2003 (.Net 1.1) musste man sogar die Designer-Fenster explizit vor dem Build schliessen... da der Designer gerne die Fenster zerschossen hat wenn beim Build ein Fehler auftrat.

Das geht doch kürzer 😃

public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
             string path=null;
             try
             {
                 path = value.ToString();
                 if (!m_ImageChache.ContainsKey(path) && File.Exists(path))
                 {
                     m_ImageChache.Add(path, LoadImage(path));
                 }
             }
             finally
             {
                 return m_ImageChache.ContainsKey(path) ? m_ImageChache[path] : m_ImageChache[NO_IMAGE];
             }
         } 

Nachtrag: Das hat zudem den Vorteil, dass Du bei einem Netzwerkunterbruch schon vorhandene Bilder sehen kannst.. nicht vorhandene werden als NO_IMAGE angezeigt... und sobald das Netz wieder verfügbar ist siehst Du das echte Bild.

Aber wo ist jetzt Dein Problem ?

Habe ich das richtig verstanden:

1.- Code X erstellt Instanz von A
2.- Code X erstellt Instanz von B
3.- A += Event von B
5.- Code X droppt A

Nun ist A nicht mehr aus X referenziert
Aber A ist aus B referenziert (über den Delegate)

Derjenige welcher ein Event abonniert muss es auch wieder löschen bevor er das Objekt wegschmeisst.

Somit einfach folgendes noch nachlegen

4.- Code X A-= Event von B

Events musst Du immer abhängen (ausser Du lässt beide Seiten gleichzeitig sterben (z.B: Form hat Events eines Controls... wenn Du da das Form wegschmeisst, dann werden auch die Controls weggeschmissen).

Mach Dir doch noch ein static Dictionary<string, BitmapImage> rein...

Jedes geladene Bild haust Du in das Dict rein... und wenn Du es schon drin hast, dann kannst Du es aus dem Dict holen statt vom Netzwerk.

Kannst Du nicht möglichst viele Objekte mit IDisposable implementieren ? Im Dispose ein GC.SuppressFinalizeThis...

--> So musst Du zwar selber aufräumen... aber dafür kommt dir der GC nicht in die Quere.

Und dann machst Du noch readonly

readonly (C# Reference)

So schützt Du Dich selber (du kannst den Wert nur bei der Deklaration oder aus dem Konstruktor setzen).

Gruss
Programmmierhans

@Fabian710

Ich zeichne sogar die Scrollbars selber (da z.B: die Breite der Scrollbars bei uns auch vom Kunden customizebar ist ) (Fette-Finger-Scrollbars)..

Daher weiss ich natürlich immer wie weit der User gescrollt hat.

Alles muss Touchscreen-fähig sein 😃

Gruss
programmierhans

Du brauchst Variablen für:

• ScrolledLines
• ScrolledColumns
• MaxVisibleLines
  usw.

MaxVisibleLines berechnest Du aus ClientSize.Heigt und Zeilenhöhe

Im OnPaint zeichnest Du dann nur das was auch sichtbar ist

(mit einem For... von ScrolledLines für eine Anzahl von MaxVisibleLines)

Das selbe für die Columns

Das kriegst Du schon hin 😃

Programmierhans

Ich würde sagen, dass Windows Forms dafür einfach nicht geeignet ist, es wird ja auch nicht mehr weiter entwickelt.

So ein Käse... wir setzen auch ein selber gezeichnetes Grid ein... Wenn man es richtig macht (und nur das zeichnet was auch sichtbar ist)... dann ist das mehr als nur genügend schnell.

Programmierhans

Hast Du mal mit ITypedList experimentiert (auf Customers implementieren)...

Dann fragt der BindingManager IMMER deine GetProperties-Methode ab... und DU kannst ihm übergeben welche TypeDescriptors er verwenden soll.

Zieh dir mal einen Serialport im Designer auf das Form und verwende diesen.

Ich vermute, dass der Designer:

1. einen anderen ctor aufruft
2. den ctor erst aufruft nachdem das Handle des Forms erstellt ist

Gruss
Programmierhans

Vertigo

BCD-Code