Hallo LonelyPixel,

ja klar, wenn du das IDisposable-Pattern implementierst, dann ist es bequemer (und wahrscheinlich auch performanter) alle unmanaged Ressourcen am Stück freizugeben. Wenn man z.B. diese "Windowless"-Strategie verfolgen wollte, könnte man die Pens und Brushes einmalig an einer zentralen Stelle erzeugen und in einem eigenen PaintEventArgs an alle Elemente verschicken, die sich gerade zeichnen wollen. Diese bräuchten nur die Properties der mitgelieferten Objekte anzupassen (Color, Width ...), und müssten sich nicht mehr ums Aufräumen kümmern.

Hallo Scorpion,

das was du da vor hast ist eine ziemlich auffendige Angelegenheit. Im grunde versuchst du eine eigene Bibliothek mit Oberflächenelementen zu erstellen. Ich würde dir davon abraten, weil ich vor Jahren auch schon mal eine eigene UI-Library geschrieben habe und weiss wie viel Arbeit das macht. Schau dir lieber das neue WPF ab .NET3.0 an. Es ist sehr mächtig und da kannst du einiges konfigurieren. Wenn du es dir trotzdem antun willst, solltest du vielleicht auf folgende Punkte achten:

• Überschreibe lieber die OnPaint-Methode der Original-Controls, anstatt diese (wie z.B. deine Labels) einfach nur auf ein Bitmap zu pinseln.
• Die Umrisse eines Controls lassen sich durch die Eigenschaft "Region" manipulieren.
• Die Transparenz lässt sich mit gewissen Einstellungen in Control.SetStyle(...) und CreateParams erreichen. Google mal danach.
• Verwende grundsätzlich bei selbstgezeichneten Controls das DoubleBuffering.
• Vergiss nicht alle Resourcen wie Pens, Brushes, GraphicPaths, Timer und Graphics-Objecte durch Aufruf von "Dispose" asap freizugeben.
• Wenn du mehr Controls in einer Anwendung haben willst, kriegst du ab max. 2000 Stück Probleme mit der Performance, und solltest dir lieber das Konzept von sog. "WindowlessControls" (bekannt vor allem aus VB) anschauen.

Viel Spass

Hallo Andreas@Tricept,

ich wollte dich weder erniedrigen noch mit irgendetwas abstempeln sondern nur knapp und präzise auf mögliche Fehlerquellen hinweisen. Mir ist auch klar dass jeder Mensch den gleichen Text unterschiedlich interpretiert bzw. darauf reagiert. Anscheinend gehörst du in dieser Hinsicht zu den empfindlicheren...

Wenn ich Doublebuffered auf true setze habe ich keinen Gewinn.

Die betreffende Passage in deinem Beitrag hat sich für mich (rein subjektiv) so angehört als wolltest du DoubleBuffering, trotz eines berechtigten Ratschlages vom progger gar nicht ausprobieren, weil du aufgrund irgendwelcher logischen Überlegungen überzeugt warst, dass es nichts bringen kann. Wahrscheinlich habe ich ab dieser Stelle auch nicht mehr gründlich genug weitergelesen...

PS: Ich persönlich habe mich schon längst daran gewöhnt dass in Foren sehr oft missverstanden, überlesen und falsch
interpretiert wird und versuche da möglichst nicht zu dünnhäutig zu sein.

Gut dass wir darüber gesprochen haben🙂

Erstens sollst du im überschriebenen OnPaint ausschliesslich das Graphics-Object aus den PaintEventArgs verwenden. Zweitens, alle verwendeten Pens und Brushes vor verlassen der OnPaint-Methode disposen. Und Drittens, solltest du den Vorschlag vom progger wenigstens mal ausprobieren, bevor du behauptest dass es nicht funktioniert. Er kennt sich mit GDI+ bestens aus und hat mit DoubleBuffering höchstwarscheinlich Recht.

PS: Im Forum gibt es von herbifore ein gutes Tutorial zu diesem Thema.

Hallo Markus86,

probiere doch einfach deine Messdaten in eine Datenhaltung zu packen, die auf einem Quadtree basiert (muss prinzipiel gehen, da deine Messdaten X und Y Coordinaten bereits enthalten). Damit lassen sich sehr performant Abfragen realisieren wie: "Gib mir alle Messdaten die gerade sichtbar sind" (also in einem Rechteck liegen, welches dein sog. ViewPort representiert). Und nur diese Messdaten werden dann in den ViewPort reingepinselt. Das machst du bei jedem Scrollen, und auch beim Zoomen. Das ist alles. Suche mal im Forum nach "Quadtree", ich glaube jemand hatte schon mal eine fertige Implementierung gepostet.

Gruß

Suche mal im Forum nach dem Stichwort "Quadtree". Ich glaube sogar dass jemand bereits eine fertige Implementierung gepostet hat.

meinst du sowas wie das da

Hallo EggaPauli,

ich habe mir diesen interessanten Artikel kurz angeschaut. Es scheint dass darin das Thema "wie kann ich sehr schnell auf ein Bitmap zeichnen" behandelt wird, aber es geht anscheinend nicht um das Zeichnen auf den Desktop direkt🙁 Oder habe ich da was übersehen?

Gruß

Weiss vielleicht jemand wie Windows es hin kriegt? Ich meine bei Icons werden ja auch nur bestimmte Regionen des Desktops neugezeichnet, und das ohne das Flackern...

Vielleicht habe ich mich nicht ganz verständlich ausgedrückt, aber die Situation ist wie folgt:

1.) Rectangle rect = new Rectangle(0,0,100,100);
2.) Zeichne rect auf Desktop
3.) rect = new Rectangle(0,0,100,50);
4.) Eine RECT-Struktur erstellen und diese mit rect initializieren.
5.) Rufe InvalidateRect (IntPtr.Zero, ref RECT, true);
6.) rect ist nach Schritt 3 nur halb so hoch, also soll InvalidateRect nur die obere Hälfte davon wegsäbeln und muß die untere Hälfte aber stehen lassen.

leider ist es nicht der Fall, zudem flackert das ganze auch noch...

Hallo dr4g0n76,

Kann momentan sehr komfortabel auf den Desktop zeichnen und mit InvalidateRect wieder löschen. Leider flackert das Bild beim InvalidateRect-Aufruf. Ich habe so den Eindruck dass das RECT-Parameter ignoriert wird und stattdessen das gesamte Screen neugezeichnet wird. Ich mache das so:

    public struct RECT
    {
        #region Fields

        public int Top;
        public int Left;
        public int Right;
        public int Bottom;

        #endregion Fields

        #region Operators

        /// <summary>
        /// Operator to convert a RECT to Drawing.Rectangle.
        /// </summary>
        /// <param name="rect">Rectangle to convert.</param>
        /// <returns>A Drawing.Rectangle</returns>
        public static implicit operator Rectangle(RECT rect)
        {
            return Rectangle.FromLTRB(rect.Left, rect.Top, rect.Right, rect.Bottom);
        }

        /// <summary>
        /// Operator to convert Drawing.Rectangle to a RECT.
        /// </summary>
        /// <param name="rect">Rectangle to convert.</param>
        /// <returns>RECT rectangle.</returns>
        public static implicit operator RECT(Rectangle rect)
        {
            return new RECT(rect.Left, rect.Top, rect.Right, rect.Bottom);
        }

        #endregion Operators

        #region Constructor

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="left">Horizontal position.</param>
        /// <param name="top">Vertical position.</param>
        /// <param name="right">Right most side.</param>
        /// <param name="bottom">Bottom most side.</param>
        public RECT(int left, int top, int right, int bottom)
        {
            this.Top = top;
            this.Left = left;
            this.Right = right;
            this.Bottom = bottom;
        }

        #endregion Constructor

    }
        [DllImport("User32.dll")]
        internal static extern bool InvalidateRect(IntPtr hWnd, ref RECT rect, bool erase);   

        private void PaintToScreen()
        {
            Graphics graphics = Graphics.FromHdc(GetDC(IntPtr.Zero));

            if (null != graphics)
            {
                Rectangle rect = new Rectangle(100, 100, 100, 100);
                Color backColor = (false == this.m_ErasePainting) ? Color.Red : Color.Transparent;

                if (false == this.m_ErasePainting)
                {
                    using (Brush br = new SolidBrush(backColor))
                    {
                        graphics.FillRectangle(br, rect);
                    }
                }
                else
                {
                    RECT screenRect = ((RECT)rect);
                    InvalidateRect(IntPtr.Zero, ref screenRect, true);
                }
            }

            int releaseResult = ReleaseDC(this.DesktopHandle, this.DesktopDC);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            this.PaintToScreen();
            this.m_ErasePainting = !this.m_ErasePainting;
        }

Dieser Code zeichent auf ein Buttonclick hin einen roten Rechteck auf den Desktop und radiert diesen beim zweiten Buttonclick wieder weg. Wenn ich z.B. die Größe des roten Rechtecks vor dem InvalidateRect-Aufruf verringere, müsste ja nur ein Teil der Rechteckes wegradiert werden. Stattdessen verschwindet das gesammte Rechteck komplett und es flackert. Hast du etwas änliches gehabt ?

Hallo herbivore,

so wie ich dass sehe ist die wesentliche Aussage von der verlinkten Diskussion, dass es ohne DierectX nicht möglich ist auf den Desktop direkt zu zeichnen... Ist es aber nicht so dass schon uralte C++ Programme es auch ohne DirectX hingekriegt haben? Vielleicht mit Hilfe von WinAPI?

    public partial class Form1 : Form
    {
        #region Fields

        Graphics m_DesktopGrahics = null;
        IntPtr m_DesktopHandle = IntPtr.Zero;
        private bool m_ErasePainting = false;

        #endregion Fields

        #region Extern Methods

        [DllImport("User32.dll")]
        internal static extern IntPtr GetDesktopWindow();

        [DllImport("user32")]
        internal static extern IntPtr GetDC(IntPtr hWnd);

        [DllImport("User32.dll")]
        internal static extern int ReleaseDC(IntPtr hWnd, IntPtr dC);

        [DllImport("User32.dll")]
        internal static extern IntPtr GetWindowDC(IntPtr hWnd);

        [DllImport("User32.dll")]
        internal static extern bool UpdateWindow(IntPtr hWnd);

        #endregion Extern Methods

        public Form1()
        {
            InitializeComponent();
        }

        #region Properties

        private IntPtr DesktopDC
        {
            get
            {
                return GetDC(IntPtr.Zero);
            }
        }

        private IntPtr DesktopHandle
        {
            get
            {
                if (IntPtr.Zero == this.m_DesktopHandle)
                {
                    this.m_DesktopHandle = GetDesktopWindow();
                }
                return this.m_DesktopHandle;
            }
        }

        private Control DesktopControl
        {
            get
            {
                Control desktop = null;

                try
                {
                    desktop = Control.FromHandle(this.DesktopHandle);
                }
                catch
                { 
                }
                return desktop;
            }
        }

        private Graphics DesktopGraphics
        {
            get
            {
                if (null == this.m_DesktopGrahics)
                {
                    IntPtr desktopDC = this.DesktopDC;

                    if (IntPtr.Zero != desktopDC)
                    {
                        this.m_DesktopGrahics = Graphics.FromHdc(desktopDC);
                    }
                }
                return this.m_DesktopGrahics;
            }
        }

        #endregion Properties

        private void PaintToScreen()
        {
            Graphics graphics = this.DesktopGraphics;

            if (null != graphics)
            {
                Rectangle rect = new Rectangle(100, 100, 100, 100);

                Color backColor = (false == this.m_ErasePainting) ? Color.Red : Color.Transparent;

                using (Brush br = new SolidBrush(backColor))
                {
                    graphics.FillRectangle(br, rect);
                    bool updateResult = UpdateWindow(this.DesktopHandle);
                }
            }

            int releaseResult = ReleaseDC(this.DesktopHandle, this.DesktopDC);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            this.PaintToScreen();
            this.m_ErasePainting = !this.m_ErasePainting;
        }
    }

Die Probleme dabei sind:

• das Wegradieren ( weil UpdateWindow(this.DesktopHandle) bringt nichts )
• das Zeichnen mit DoubeBuffering-Support, also ohne flackern.

Hat da jemand mal eine Idee wie das realisiert werden kann?

EDIT: Anscheinend ist Desktop kein Control und Control.FromHandle(this.DesktopHandle); liefert immer null zurück... Schade

Hallo Community,

wie kann man mit GDI+ direkt auf den Desktop zeichnen, bzw. das Gezeichnete wieder löschen? Gibt es dafür auch eine DoubleBuffer Untestützung?

Gruß

Oder du wartest bis Microsoft sich entschliesst den "Bartok"-Compiler mit "Singularity" kommerziell zu vertreiben 🙂

Danke feadur,

im angegebenen MSDN-Artikel steht genau dass was ich nicht gewusst habe:

Wenn Sie unter Verwendung der expliziten Implementierung Ihre eigenen benutzerdefinierten add- und remove-Accessoren schreiben, kennt der Compiler den dem Ereignis zugrunde liegenden Datenspeicher jedoch nicht. Daher können Sie das Ereignis nicht mehr mit seinem Namen aufrufen, sondern müssen direkt auf den Delegaten verweisen.

Noch mal Danke.

Habe ich schon, aber das bringt es nicht. Ausserdem wundert es mich dass der Compiler über die Zeile:

this.OnObjectChanged(this, EventArgs.Empty)

mit gleicher Fehlermeldung schimpft, und ich denke dass der ware Grund da irgendwo liegt...

Hallo Community,

hat vielleicht jemand eine Idee warum dieser Code nicht kompiliert:

public delegate void EventHandler(object sender, EventArgs e);

public class MyClass
{
    //...
    
    public event EventHandler ObjectChanged
    {
        add { throw new NotImplementedException(); }
        remove { throw new NotImplementedException(); }
    }

    protected virtual void OnObjectChanged()
    {
        if (null != this.ObjectChanged)
        {
            this.ObjectChanged(this, EventArgs.Empty);
        }
    }
}

und dieser schon:

public delegate void EventHandler(object sender, EventArgs e);

public class MyClass
{
    //...
    
    public event EventHandler ObjectChanged;

    protected virtual void OnObjectChanged()
    {
        if (null != this.ObjectChanged)
        {
            this.ObjectChanged(this, EventArgs.Empty);
        }
    }
}

Der Compiler geht auf die OnObjectChanged-Methode los (auf die if-Abfrage und auf this.ObjectChanged(this, EventArgs.Empty)) und gibt folgende Meldung aus:
"The event 'Test.MyClass.ObjectChanged' can only appear on the left hand side of += or -="

OK, ihr habt Recht, dieses Beispiel-Array ist zum Komprimieren wirklich zu klein... Mich würde mal trotzdem interessieren ob es im Framework schon fertige Implementierungen von solch einem "ganz normalen Komprimierungsalgorithmus" gibt ?

Gruß

Komprimieren im herkömmlichen Sinne ist hier hicht. Ich habe ein Dictionary, welches als Keys int-Arrays (auch relativ grosse) benutzt. Da es sich um sehr viele Einträge bei solch einer Dictionary handeln kann, würde es durchaus Sinn machen solch ein Key-Array auf einen einzigen int-Wert "zusammenzuschrumpfen". So könnte ich effektiv Speicherplatz sparen und die Values trotzdem eineindeutig identifizieren. Ich meine so ein int-Array hat Nx32Byte und davon kann es unter Umständen mal 500000 und mehr geben...

Hallo Community,

Heute sind besonders die Mathematiker und "Algoritmiker"🙂 zu folgender Aufgabenstellung gefragt:

Ein Array int[] someArray = new [] { 1, 8, 17, 0, 2 }; soll durch einem möglichst kleinen Int-Wert "X" dargestellt werden. Dabei soll es anhand irgendwelcher wilden mathematischen Operationen möglich sein, aus X das Array wieder zu rekonstruierten.

Eine Lösung ist someArray in einer Schleife durchzulaufen und einfach eine Zahl zu bilden, die aus "Verkettung" aller Arraywerte besteht: int X = 181702; Das Problem dabei ist dass ich bei dieser Darstellungsweise keine Information über die Anzahl der Elemente im Array habe und gerade bei zweistelligen Zahlen wie z.B someArray[2] = 17 ein Problem hätte diese zu rekonstruieren. Das andere Problem dabei ist dass diese Zahl auch sehr hoch ist und somit der integer-Bereich schon bei Arrays mit Länge ≥ 10 Elementen erschöpft sein würde.

Freue mich über jede Idee und jeden Ansatz wie man so etwas lösen kann.

Hallo herbivore,

meinst du mit "sekundär oder Hintergrund-Speicher" die Festplatte? Gibt es da gute Erfahrungswerte bzw. Kriterien ab welcher Undo-Stackgröße und in welchen Blöcken man die Daten auf die Platte rausschreiben soll? Ist bestimmt eine häufige Problemstellung...

Gruß

Hallo Community,

nach dem ersten Blick auf Undo/Redo Pattern fiehl mir auf dass beim Löschen von Objekten, diese nur als gelöscht markiert werden und es immer noch eine Referenz darauf im Undo-Stack gehalten werden muss. Dies würde bei größeren Löschaktionen, sowie bei intensiv genutzten, langlebigen Applikationen viel Speicher belegen. Kennt jemand vielleicht einen Weg den Undo-Stack zu komprimieren? Ist es möglich dass man vor dem Löschen des Objektes einfach nur die Werte seiner Properties ausliesst und diese bei der Restauration des Objektes reinschreibt? Sowas wie ein "DeepCopy"... Gibt es da bereits Mechanismen die möglichst performant und generisch funktionieren?

Danke für jeden konstruktiven Hilfebeitrag

Danke WinSharp93 ,

genau das habe ich gesucht (hat übrigens den Wert 0x001E)

Gruß

Hallo CrazyPlaya,

Microsoft empfiehlt JaggedArrays den mehrdimensionalen Arrays aus performancegründen vorzuziehen.

Hallo svenson,

für die Zeitabfrage würde ich DateTime.Now verwenden. Wie kann ich die TimeZone abfragen?

Hallo Community,

kennt jemand einen Weg wie man eine Benachrichtigung kriegen kann wenn die Systemzeit verstellt wurde? Ich meine gibt es in .NET einen Event was gefeuert wird wenn jemand an der Uhr in der Taskleiste gedreht hat? Ev. auch für die Änderungen der TimeZone-Einstellungen?

Gruß

Das funktioniert einwandfrei:

int num = 5;
IntPtr ptr = new IntPtr((void*)&num);

aber wieso klappt es nicht mit Funktionen?

IntPtr ptr = new IntPtr((void*)&SomeFunction);

public static void SomeFunction()
{
}

Der Compiler schimpft und sagt:
"Cannot take the address of the given expression"

Hallo Community,

wie kann ich in C# die Adresse einer Funktion, also einen Pointer darauf, herkriegen?

PS: ja ich weiss das es dafür delegates gibt, aber ich brauche eben einen Pointer...

Danke Borg, das ist genau das Stichwort was mir gefehlt hat.

Hier ist eine fertige Implementierung

Hallo Community,

jeder kennt es, wenn eine Anwendung (bzw. ihr Hauptfenster) in die Taskleiste minimiert wurde und dem Benutzer irgendwann mal signalisieren will dass sie ihre Arbeit beendet hat, fängt der 'Taskleisten-Button' an zu blinken (3-4 mal). Wie kann man das
in eigener Anwendung (nach)machen, muss ich dafür ein bestimmtes Property setzen oder ein Event feuern?

@ JAck30lena:

1. Dannach = danach
2. pilder = bilder
3. "...wird wie ein kartenhaus bald zusammenbrechen" => HÄÄ ??? Bin mal auf die Begründung von dieser Aussage sehr gespannt...

PS: Wie war das noch mal: "Wer ohne Sünde ist, der werfe den ersten Stein". Hast wohl zu früh geworfen🙂

Hallo Community,

die Klasse Control und alle ihre Derivate besitzt unter anderem Eigenschften Size und Locaiton. Ausschliesslich diese Eigenschaften interessieren auch mich und alle anderen würde ich gerne "ausblenden", indem ich ein Interface definiere und ein beliebiges Control darauf caste. Das Interface ist sehr einfach und sieht so aus:

    public interface ISimpleGraphicalObject
    {
        System.Drawing.Size Size { get; set; }
        System.Drawing.Point Location { get; set; }
    }

Wenn ich aber nun versuche ein beliebiges Control darauf zu casten:

            System.Windows.Forms.Button btn = new System.Windows.Forms.Button();
            ISimpleGraphicalObject graphObj = ((ISimpleGraphicalObject)btn);

kriege ich immer eine InvalidCastException. Ich weiss zwar dass ein Control das Interface ISimpleGraphicalObject nicht explicit implementiert, aber implizit hat es doch alle geforderten Eigenschaften (Size und Location). Gibt es eine Möglichkeit den Cast doch noch zustande zu bringen oder geht da was grundsätzlich schief ???

Danke

Hallo Programmierhans,

wie bereits oben erwähnt ist meine Komponenete leider kein Control...

von Kinderfenstern auf das Mainform zuzugreifen ist allerdings keine gute Idee

@herbivore:
Da gebe ich dir vollkommen Recht. Genau darum lädt die Application irgendeine Komponente und soll auch überhaupt nicht wissen was sie da geladen hat. Das heisst, die Komponente soll die Application kennen (bzw. hier ihr Hauptfenster) aber nicht umgekehrt.

@dr4g0n76
Genau aus diesem Grund wird auch das setzen eines statischen Properties "Form" keine saubere Lösung sein. Weil dann die Hauptanwendung von irgendwelchen spezifischen Properties einer jeden frisch erzeugten Komponente Kenntnis haben muss. Sprich es muss dann irgend wocher wissen dass die "KomponenteBla" ein Property "Form" besitzt...was aber meiner Meinung nach nicht gut ist...

Ich hatte eher an eine Art "Reflection-Magic" gedacht, womit ich als KomponenteBla rausfinden kann:

• Wo lebe ich gerade?
• Wer ist mein ParentProccess?
• Wie kriege ich eine Referenz auf das Hauptfenster?

Irgendwelche Ideen dazu?

Hallo Community,

folgendes Scenario liegt vor:

die Instanz einer Komponente (externe dll) wird von einer WindowsApplication via Activator.CreateInstance ins Leben gerufen. In dieser Komponente möchte ich gerne gleich im Constructor eine gültige Referenz auf die Form der WindowsApplicaton holen. Also sowas wie:

private System.Windows.Forms.Form m_MainForm;

// hier werde ich in einer Anwendung via Activator erzeugt...
public KomponenteBla()
{
    // und hier brauche ich eine Referenz auf das Hauptfenster 
    // der Anwendung, in der ich momentan lebe
    this.m_MainForm = GetItSomeHow...
} 

Da der Constructor meiner Komponente zwingend ohne Parameter sein muss, kann ich mir diese Referenz beim Erzeugen mit dem Activator nicht übergeben lassen 🙁
Diese Komponente ist auch kein Control. Ich habe zwar gesehen dass ich mir den aktuellen Process geben lassen kann, der seinerseits einen Pointer zum MainWindow hält, weiss aber nicht wie ich mir daraus eine Form "schnitzen" kann.

Hat jemand eine Idee wie sowas gemacht wird?

Hallo Easyrider,

Muss zugeben dass ich nicht alle Posts richtig tief durchgelesen habe, aber es klingt für mich nach einer Art "Platform", die alles mögliche beinhalten kann. Diese müsste dann quasi ihren einzelnen Blöcken/Plugins eine Möglichkeit für die Kommunikation (miteinander und nach außen) bieten und auch ein erweiterberes Pool an Services bereitstellen. Vielleicht währe das von Microsoft vorgestellte CAB (CompositeUIApplicationBlock) "Pattern" was für dich. Dieses ist in einer der letzteren Ausgaben von "DotNetPro" beschrieben und ich glaube sogar in der EnterpriseLibrary als Framework enthalten...

Viel Erfolg noch

Hallo community,

bin mir zwar nicht ganz sicher ob dies hier thematisch rein passt, weiss aber einfach nicht wohin sonst mit dieser Frage...

Was genau richtet man mit dem Befehl "regsvr32 IrgendEineDll.dll" an? Ist das aus der COM-Ecke, was geschieht da im Hintergrund? Was ist wenn man eine neue Version dieser dll registrieren will, bleibt die Alte noch erhalten oder wird sie gleich "überbügelt"? Gibt es da eine Möglichkeit sich alle registrierten dll's vom System anzeigen zu lassen (Um vielleicht später mit regsvr32 /u die eine oder die andere zu entfernen) ???

Bin für jede konstruktive Hilfe dankbar.

Hallo Community,

ich möchte gerne mittels Reflection den Wert einer Variable auslesen. Das Problem dabei ist dass der betreffende Typ bzw. Klasse als "internal" markiert ist. Selbst wenn ich mit Reflection an diese Variable ran komme, kann ich keine Instanz davon erstellen, weil der Compiler diesen Typ nicht kennt, bzw. wegen des protection levels der Variablen ...

Beispiel:

Aus einer Instanz der Klasse "System.Windows.Forms.ToolStripItem" möchte ich gerne die Variable namens "toolStripItemInternalLayout" auslesen und diese etwas genauer unter die Lupe nehmen. Dies mache ich so:

                object obj = this.GetField(typeof(ToolStripItem), "toolStripItemInternalLayout");

                if (obj != null)
                {
                    ToolStripItemInternalLayout internalLayout = obj as ToolStripItemInternalLayout;
                }

        private object GetField(Type type, string fieldName)
        {
            BindingFlags flags = BindingFlags.CreateInstance | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            object field = type.GetField(fieldName, flags);
            return field;
        }

Die Klasse "ToolStripItemInternalLayout" ist als internal deklariert und deswegen läuft der obige cast schief.

Weiss vielleicht jemand wie ich sonst eine Instanz davon erzeugen bzw. auf die "Innereien" dieser Klasse zugreifen kann ???

Danke für jede konstruktive Hilfe

Habe gerade die SP1-Beta erfolgreich installiert und wieder deinstalliert, aber das Release lässt sich nach wie vor nicht intallieren 🙁

Habe beides (VS2005 und SP1) in English...

Hallo tom-essen,

ich habe diese hier
Denke schon dass es die richtige Version für mein "VisualStudio2005 Professional Edition" ist...

Hallo Community,

habe mir von Microsoft den ServicePack1 für VisualStudio2005 runtergeladen und kann es nun nicht installieren. Gleich zu Beginn bekomme ich vom WindowsInstaller folgende Fehlermeldung:

"Das Upgradepatch kann vom Windows-Installer-Dienst nicht installiert werden, weil das Programm, das aktualisiert werden soll, möglicherweise fehlt, oder weil das Upgradepatch eine andere Version des Programms aktualisieren würde. Stellen Sie sicher, dass das zu aktualisierende Programm auf dem Computer installiert ist, und das Sie den richtigen Upgradepatch installieren."

VisualStudio2005 ist natürlich vorhanden/installiert und machte bis jetzt kein Probleme. Beim googeln ist mir aufgefallen dass bei vielen Menschen dieses Problem durch die Beta-Version des SP1 verursacht wurde. Ich kann mich aber nicht entsinnen BetaSP1 jemals installiert zu haben... und unter Systemsteuerung/Software taucht es bei mir auch nicht auf (habe das Häckchen bei "Updates anzeigen" natürlich auch gesetzt).

Hat jemand vielleicht dafür eine Lösung?

Gruß

Hallo Community,

weiss jemand vielleicht eine Möglichkeit wie man mit .NET-Mitteln an den stackpointer rankommt? Suche nach einem Weg den Namen des aktuellen Assemblerbefehls abzufragen und eine Notifikation zu erhalten wenn der stackpointer seine Position geändert hat. Bin für Codeschnippsel in C oder Assembler natürlich auch dankbar.

Hallo Community,
wie kann ich es mitkriegen wenn eine Methode gestartet (wenn gerade in die erste line of code gesprungen wurde) bzw wenn sie abgearbeitet wurde (unmittelbar bevor die letzte line of code verlassen wird)? Gibt es im Framework dafür vielleicht spezielle Attribute? Natürlich könnte ich am Anfang und Ende jeder Methode die mich interessiert selbstdefinierte Events feuern (z.B OnMethodEntered & OnMethodExited) aber ich suche nach einer mehr oder weniger "generischen" Lösung... d.h. ohne den Code der betreffenden Methode direkt zu manipulieren. Weiss da jemand Rat?

Danke

Es gab mal bei sourceforge die kostenlose NetronGraphLibrary (nicht mit "Nevron" zu verwechseln). Allerdings hat der Gründer das Projekt vor ein paar Monaten verlassen und jemand anderes versucht es weiter zu führen...keine Ahnung mit wie viel Erfolg.

PS: Wenn du keine Kohle ausgeben willst kannst du ja mal so ein Java-Produkt nach C# portieren 🙂 Lernst dabei bestimmt eine Menge über C#...

Hallo cluening,

habe von der Graphentheorie nur sehr oberflächliches Verständnis und weiss darum nicht ob das was du brauchst exact diesen Tools entspricht oder nicht, aber ich denke daß manche davon "unter der Haube" auf die GraphenTheorie aufsetzen:

-GoDiagram
-ERD Diagram
-FlowChart.NET
-NevronDiagram
-CorgentDiagram

Die Graphen zeichnen kann man mit jedem dieser Produkte allemal, wobei es deutliche Unterschiede bezüglich der Ausstattung und Performance gibt. Z.B. hat NevronDiagram meiner Meinung nach die üppigste Ausstattung, ist aber was die Geschwindigkeit angeht bei größeren Graphen (so ab 1500 Vertices) GoDiagram hoffnungslos unterlegen... Einfach mal der Reihe nach ausprobieren 🙂

Gruß

Hallo TNDAri,

wenn du so eine Art selection rectangle haben willst und das Teil mit der Maus ziehen möchtest, dann google einfach nach "rubberband".

Gruß

@Traumzauberbaum:

da gebe ich dir völlig recht, denn fast alle meine Vorschläge sind eher "Minioptimierungen" und würden nur bei großen Dictionaries eine messbare Performancesteigerung ergeben.

@v1vec
Was also wirklich den Unterschied ausmacht, ist der verwendete Algorithmus und weil ich die Problemstellung nicht wirklich verstanden habe kann ich momentan zum Algorithmus keine brauchbaren Verbesserungsvorschläge machen 🙂
Versuche doch bitte dein Problem etwas genauer zu formulieren und mehr Detail-Info zu posten, dann kann dir effektiver geholfen werden...

Gruß

Hallo v1vec,

1.) mir ist aufgefallen dass du den Schlüssel aus

preis.Value + einkauf.Key

relativ oft verwendest. D.h. er muss jedes mal aus zwei Dictionary-Einträgen zusammengebaut werden. Baue ihn doch lieber nur ein mal am Anfang und benutze ihn weiter:

int someKey = preis.Value + einkauf.Key

2.) Was ist der Unterschied zw. "_Einkäufe" und "Einkäufe"?
Kannst du dir vielleicht eines davon sparen, bzw. zu überlegen ob die ContainsKey-Abfrage in einer der beiden Dictionaries nicht überflüssig ist?

3.)Versuche Keyzugriffe möglichst zu reduzieren, (wie bereits unter 1 erwähnt) indem du z.B. diesen Code:

    _Einkäufe.Add(preis.Value + einkauf.Key, new List<int>(einkauf.Value));
    _Einkäufe[preis.Value + einkauf.Key].Add(preis.Key);

so änderst:

    valueList = new List<int>(einkauf.Value));
    valueList.Add(preis.Key);
    _Einkäufe.Add(preis.Value + einkauf.Key, valueList);

Dann musst du nicht den selben Key noch ein mal suchen um auf seinen Inhalt zuzugreifen.

4.) So wie ich das sehe läufst du jedes mal durch die gesammte Dictionary und alle ihre Value-Listen durch um das Vorhandensein eines Wertes zu überprüfen. Diese Lösung kann ab einer gewissen Anzahl an Einträgen nicht mehr performant sein.

PS: ist zwar in diesem konkretten Fall nicht relevant, aber in manchen Szenarien kann bei der Arbeit mit Dictionaries die Methode TryGetValue() recht performancesteigernd sein.

Hallo Community,

ich will eine Klasse, die im grunde ein graphisches Objekt representiert, serializieren.
Die wesentlichen Informationen über das aussehen dieser grafischen Objekte werden von den zwei privaten Variablen vom Typ System.Drawing.Drawing2D.Matrix und System.Drawing.Drawing2D.GraphicsPath gehalten. Nun ist es leider so dass sowohl die Klasse Matrix als auch GraphicsPath von Microsoft nicht mit dem [Serializable]-Attribut versehen wurden. Immer wenn ich versuche diese Klasse zu serialisieren schimpft der Compiler. Diese Variablen mit [NonSerialized]-Attribut zu markieren macht keinen Sinn, weil sie so zu sagen das Herzstück der ganzen Klasse sind und existentiell wichtige Informationen beinhalten...
Hat vielleicht jemand dieses Problem auch schon gehabt bzw. erfolgreich gelöst?

Danke für jeden konstruktieven Vorschlag.