Laden...
D
Doltsche myCSharp.de - Member
Lernender Informatik Schweiz Dabei seit 21.08.2009 249 Beiträge
Benutzerbeschreibung

Forenbeiträge von Doltsche Ingesamt 249 Beiträge

29.10.2013 - 18:12 Uhr

Hallo Community

Bereits vor einem Jahr war ich damit beschäftigt, ein Chart-Control mit Silverlight zu realisieren. Knifflig wurde es beim dynamischen Beschriften der Achsen. Offenbar ist es nicht unbedingt die optimale Lösung, die Grösse des gerenderten Achsenlabels zu ermitteln und anschliessend zu berechnen, wie viele von diesen Labels auf einer Achse mit einer gegebenen Länge Platz haben. Zumal gerade in Silverlight das Ermitteln der Dimensionen eines gerenderten Labels/Strings nur mit Basteln während dem Layoutpass möglich ist. Meine Logik sagt mir deshalb, dass es auch andere Lösungsansätze geben muss.

Da ich wieder mit eigenen Chart-Controls konfrontiert bin (Schulprojekt, Funktionsgraph), suche ich nach einer gängigen Methode auf dynamische Weise zu bestimmen, wie viele Labels ich auf einer Achse zur Beschriftung verteilen kann. Das Ganze soll dabei Sprachunabhängig sein. Es geht mir um den generellen Lösungsansatz.
*Eine Möglichkeit wäre zum Beispiel eine vordefinierte Grösse für alle Labels. In diesem Fall wird es aber problematisch mit einer dynamischen Schriftgrösse. *Eine andere Idee wäre, auf gut Glück Labels zu platzieren, und diejenigen, die sich überlappen zu entfernen. Das würde aber wiederum zwei Renderdurchläufe benötigen.

Welche Ideen habt ihr zur Lösung dieses Problems?

Gruss

Samuel

10.07.2013 - 11:56 Uhr

Hallo ronny75

Probier mal folgendes:


Type officeType = Type.GetTypeFromProgID("Excel.Application");
if (officeType == null)
{
     // Excel ist installiert
}
else
{
     //Excel ist nicht installiert
}

Gruss

Samuel

Quelle: stackoverflow.com

10.07.2013 - 10:21 Uhr

Hallo Community

Eine Benutzeroberfläche auf seine Funktionalität zu testen ist ganz nett, muss aber nicht zwingend etwas über die Funktionalität des gesamten Systems sagen. Folgendes: Bei unserer internen Anwendung können über eine Benutzeroberfläche (Client/Web) Prozesse (BizTalk, Umsysteme) ausgelöst werden, deren Bearbeitung auch gut mehrere Stunden in Anspruch nehmen kann. Erst nach Ablauf dieser Zeit kann das Ergebnis wirklich verifiziert werden.

An diesem Punkt macht mir nun das Testframework von Microsoft etwas zu schaffen (ob jetzt Coded UI oder Unit Test). Die einfachste Lösung wäre in einer Testmethode einen entsprechenden Prozess auszulösen und anschliessend zu warten bis dieser fertig ist. Bei diesem Vorgehen und bei 30 - 40 weiteren Tests dauert dass dann schnell mal mehrere Tage bis alle Tests durch sind. Im täglichen Geschäft eher undenkbar.

Ich habe folgenden Workaround gemacht: Ich führe zuerst alle prozessauslösenden Tests hintereinander aus (Ordered Test) und speichere die Prozess-Id in einer Textdatei zwischen. Der Austausch über eine globale Variable ist scheinbar nicht möglich.

Nach dem alle diese eher nichts aussagenden Tests durch sind, kommen die auf das Prozessergebnis wartenden Tests an die Reihe. Hier wird dann wirklich gewartet bis der Prozess durch ist. Während dieser Zeit laufen nun aber auch die anderen Prozesse. Folglich hat nur die erste derartige Testmethode lange zu warten.

Diese Lösung ist aber gänzlich Ungünstig. Vorallem wenn man mit Microsofts Test Manager und dessen Statistiken arbeiten will. Denn die prozessauslösenden Tests werden immer erfolgreich sein, was dazu führt, dass der gesamte Test immer mindestens zu 50% erfolgreich ist, auch wenn das ganze Umsystem zu 100% versagt.

Ich hoffe ihr seht was ich meine. Sehr würde ich mich über Vorschläge für eine bessere Lösung freuen.

Zusammenfassend sei nochmals zu sagen: Es geht darum, mehrere Prozesse automatisiert über eine Benutzeroberfläche zu starten und anschliessend deren Ergebnis abzuwarten, was mehrere Stunden in anspruch nehmen kann. Letzteres sollte "Parallel" geschehen können weil die Tests ansonsten zu lange dauern.

Beste Grüsse

Samuel

05.07.2013 - 10:17 Uhr

Und kommerzielle "Best Practices" sehe ich immer sehr skeptisch an. Kann aber zum Inhalt nichts sagen.
Ich würds mir jedenfalls nicht kaufen.

Das sehe ich ebenfalls ein bisschen so. Daher auch die Frage.

05.07.2013 - 10:09 Uhr

Hallo community

Wenn man im Netz nach Design Patterns sucht, landet man in der Regel schnell auf der Site von dofactory.

Diese werben mit ihrem Produkt ".NET Desing Pattern Framework 4.0" welches sozusagen eine Sammlung von Referenzimplementierungen und Design Pattern umsetzungen ist. Meine Frage ist, ob sich das jemand von euch jemals gekauft hat oder etwas davon in einer Richtung hörte? Ist das etwas, oder ist das einfach eine "Sammlung von Internetartikeln", die verkauft wird?

Gruss

Samuel

03.06.2013 - 22:06 Uhr

Ok, da stimme ich dir voll und ganz zu. Der Schwerpunkt bei der Entwicklung für Computerspiele liegt dann wohl hald eher darin, dass Betriebssystem mit unkonventionellen Mitteln dazu zu "missbrauchen". Das wiederum macht dann für mich auch die technische Seite der Spieleindustrie insgesamt sehr spannend. Aber ich denke, wir schweifen nun doch zu sehr von der ursprünglichen Fragstellung ab.

03.06.2013 - 20:54 Uhr

Nun gut, aber gerade unter Computerspielern ist Windows die einzige wirkliche Wahl überhaupt. Es erscheinen ja nicht ohne Grund sämtliche Computerspiele für Windows und nicht für andere Plattformen wie iOS oder Linux.

Danke für den Link. Der scheint genau auf dieses Thema einzugehen 😉.

03.06.2013 - 20:31 Uhr

Vieleicht an dieser Stelle noch ein Link, der mich überahaupt auf dieses Thema gebracht hat: Threading and Your Game Loop. Der Author geht sogar noch weiter mit Batched Multithreading. Die Authoren, welche dort Ihre Beiträge veröffentlichen scheinen mir nicht unbedingt beschränkt. Es wird also sicherlich durchaus seinen Grund haben, die GameLoop auf mehrere Threads zu verteilen.

Das mehrere Threads genau das Gegenteil von Performance bewirken können wegen dem Kontextwechsel gab mich dann auch den Anstoss auf die Frage, ob es möglich ist, die Threads explizit auf verschiedene Cores zu verteilen. Weil sonst hat man, wie Abt sagt, nur einen Performanceverlust.

Gruss

Samuel

03.06.2013 - 15:51 Uhr

Der Fakt, dass die Anzahl an Cores bei der Xbox vorneherein bekannt ist, ist da sicherlich hilfreich. Aber ehrlich gesagt, findet man auf dem Markt für den Home-User kaum noch ein Computer mit einem Single Core Prozessor.

Wäre es in dem Fall unschön, selber zu prüfen, ob die CPU mindestens zwei Kerne hat und dann anhand dieses Wertes die Verteilung der Threads auf die Cores manuell vorzunehmen?

Gruss

Samuel

01.06.2013 - 16:12 Uhr

Das Rendern und Updaten auf verschiedene Cores zu verlagern macht schon Sinn.
Das Prinzip ist sehr ähnlich dem Image Buffer in einer Grafikkarte. Sowohl Render als auch Update werden letztendlich sequentiell ausgeführt. Nur das hald während dem Rendern vom letzten Update bereits das nächste Update berechnet wird usw.

Edit: Auch id Software verwendet eine ähnliche Stratgie: Doom BFG Multithreading Dort ist allerdings zu beachten, dass dort beim Rendering zwischen Frontend und Backend rendering unterschieden wird. Das Frontend rendering wird zwar in der Tat auf dem gleichen Thread wie das Gameupdate ausgeführt, nicht aber das Backend rendering. Dieses hat einen anderen Thread zu Verfügung.

01.06.2013 - 01:18 Uhr

Hallo Community

Die Klassische GameLoop bei einem Computerspiel sieht vor, dass sequentiell eine Updatemethode, gefolgt von einer Rendermethode in einer Endlosschleife ausgeführt wird. Diese Technik unterstützt aber nicht wirklich die Verfügbarkeit von mehreren Prozessorkernen, da sowohl das Rendering als auch das Update im gleichen Thread ausgeführt werden.

Ein Ansatz wäre nun ein separater Render-Thread und ein Update-Thread, welche in Form einer Pipeline parallel ausgeführt werden. Das erlaubt die Berechnung des Spielstatus auf dem einen Kern während der vorhergehende Status noch auf dem anderen Kern gerendert wird.

Ein ähnliches Modell zur Realisierung einer GameLoop sieht auch Microsoft vor: Coding For Multiple Cores on Xbox 360 and Microsoft Windows

An dieser Stelle kommt aber meine Frage ins Spiel: Warum wird nur auf der Xbox eine Aufteilung der GameLoop in ein Render und Update-Thread vorgesehen, nicht aber bei Windows (abgesehen von zusätzlichen Berechnungsthreads)?

Gruss

Samuel

Edit: Ein Grund für den gemeinsamen Render-Update-Thread bei Windows mag die Tatsache sein, dass die Anzahl Kerne von Computer zu Computer variiert. Und die Anzahl der Kerne zu ermitteln und dann eine manuelle Threadverteilung zu machen wäre zu komplex. Ist das aber nicht sowieso die Aufgabe des Betriebssystems? Respektive, wenn die Update und Render-Methoden in einem Thread ausgeführt werden, hat das Betriebssystem gar nicht erst eine Chance, die Threads auf mehrere Kerne zu verteilen.

Das angehängte Bild zeig die Threadaufteilung einer GameLoop im Falle der Xbox 360. Im Fall von Windows sind die ersten beiden Threads (Game Update und Render) zu einem Thread zusammengefasst.

30.05.2013 - 13:36 Uhr

Hallo Community

Als ich mir die .NET Klasse StopWatch anschaute, bin ich auf den High-Resoultion Timer gestossen, welcher Hardware unterstützt ist, sofern denn überhaupt vorhanden.

Auf meinem Computer ist zum Glück die entsprechende Hardware unterstützung vorhanden und ich habe mit QueryPerformanceFrequency die entsprechende Frequenz-"Konstante" abgefragt. Zu meiner Verwunderung ware deren Auflösung aber ca. 3 Mal kleiner, als der Wert TimeSpan.TicksPerSecond. Wieso ist nun hier die Rede von High Resoultion, wenn doch DateTime.Now.Ticks eine viel grössere Auflösung liefert?

Mit Sicherheit habe ich etwas falsch verstanden, aber mir ist an dieser Stelle nicht klar, was genau. Daher hoffe ich auf eure Richtigstellung.

Gruss

Samuel

29.05.2013 - 09:33 Uhr

Ich werde meinen Lösungsansatz noch aufbereiten und anschliessend im Start-Thread posten 😉.

Gruss

Samuel

28.05.2013 - 16:52 Uhr

Der ASP.NET ViewState ist bei der WebForms Technologie ein elementares Grundkonzept. Ohne dich angreifen zu wollen ist meine Meinung, dass wenn man sicht nicht selbstständig in solche Konzepte einarbeiten kann, es keinen Sinn macht, überhaupt etwas mit ASP.NET anfangen zu wollen.

Am besten du liest die folgende Einführung zum Thema ViewState auf folgender MSDN Site durch: ViewState

Sobald du das wirklich verstanden hast, solltest du auch selbstständig auf die Lösung deiner Problematik kommen.

Gruss

Samuel

28.05.2013 - 16:45 Uhr

Hallo Abt

Danke für deine Antwort. Das wird wohl in der Software-Entwicklung immer ein Problem bleiben, dass fortlaufend neue Features zu einem System hinzugefügt werden müssen, die nicht vorabsehbar waren.

Wie dem auch sei habe ich nun ein ganz anderen Lösungsweg gefunden, das jQuery DataTables Plugin in ASP.NET WebForms vollumfänglich zu integrieren.

Beste Grüsse

Samuel

28.05.2013 - 11:00 Uhr

Hallo community

Ich verwende das jQuery Plugin dataTables für eine ASP.NET WebForms Site, stosse aber auf recht viele konflikte mit ASP.NET.

Ein aktuelle Problem, wo ich such und suche, und bisher keine Lösung fand ist folgendes: In einer durch das jQuery Plugin generierten Spalte will ich ein Edit-Button pro Zeile einfügen, der ein ASP.NET Event auf der Server-Seite aufruft. Ohne gross zu basteln geht das nur, wenn ich in der .aspx Datei auch ein konkretes Server Control verwende. Das Rendern der dataTables Zeilen muss allerdings über JavaScript geschehen.

Folglich habe ich mein Button auf diese Weise erstellt:


var editButton = '<asp:ImageButton runat="server" ID="EditButton" OnClick="MenuImageEdit_OnClick" ImageUrl="../Images/edit_icon_large.png" />';
                    editButton.setAttribute('name', 'gugus');
                    return editButton;

Gerendert sieht das dann so aus:


var editButton = '<input type="image" name="ctl00$DefaultContent$EditButton" id="DefaultContent_EditButton" src="../Images/edit_icon_large.png" />';
                    return editButton;

Ich erhalte damit ein input element, dass beim Anklicken ein PostBack auslöst und auf der Server-Seite ein entsprechendes Click-Event aufruft. Was aber scheinbar nicht möglich zu sein scheint, ist dieses gerenderte html element auf irgend eine weise zu modifizieren. Egal, was ich auch versuche. Ich habe mit den jQuery-Methode .attr(), .val() und .prop() versucht, ein Attribut (vorzugsweise das Value und Id Attribut) zu ändern. Ohne Erfolg:


$(editButton).val(data);

oder

$(editButton).attr({"value": data});

Das Attribut selber wird nicht modifiziert.

Daher lautet meine Frage, wie ich mit JavaScript ein HTML Element mit dynamischen Attributen generieren kann, dass ein PostBack auslöst und auf der Server-Seite ein Event wirft.

Gruss

Samuel

30.04.2013 - 18:46 Uhr

Besten Dank für eure Auskunft. Das mit dem FxCop ist interessant zu wissen.

30.04.2013 - 09:31 Uhr

Hallo Community

In einem Projekt habe ich den Fall, dass abstrakte Elemente in einer Liste abgearbeitet werden. Hierzu werden die Elemente durch iteriert und pro Iteration wird jeweils eine oder mehrere abstrakte Methoden aufgerufen.

Meine Frage an dieser Stelle ist, ob es angebracht ist, bei jeder Itertion zu prüfen, ob das abstrakte Element zusätzlich ein spezifisches Interface implementiert und gegebenen falls dann diese Methode aufzurufen?


foreach(AbstractElement elem in _abstractElements)
{
     elem.AbstractMethod();

     if(elem is IAdditional)
     {
          ((IAdditional)elem).AdditionalMethod();
     }
}

Freundliche Grüsse

Samuel

19.09.2012 - 20:32 Uhr

Hallo

Danke für die Antworten.
Das mit dem Random Walk ist genau das, was ich gesucht habe.

Gruss

Samuel

19.09.2012 - 11:32 Uhr

Hallo community.

Angenommen, ich möchte zum Beispiel eine Börsensimulation realisieren, verwende ich die Random Klasse und lasse dann in einer Schleife einige Zufallszahlen generieren um diese anschliessend mit einem Chart zu realisieren.

Wenn ich das aber auf diese Weise mache, erhalte ich ein eher regelmässiges Ergebnis. Ich suche daher einen Algorithmus mit welchem ich die Wahrscheinlichkeit von positiven und negativen Peaks beeinflussen kann.

Gruss

Samuel

17.09.2012 - 20:38 Uhr

Danke für den Hinweis. Ich habe ganz vergessen zu erwähnen, dass ich das Projekt in Silverlight realisieren will. Dort ist leider alles etwas zensiert. Die Klasse FormattedText gibt es dort leider nicht.

Edit:

Bei einem erneuten Versuch, einen TextBlock unplugged zu instanzieren und initialisieren hat sich gezeigt, dass die ActualWidth und ActualHeight properties gesetzt sind. Das finde ich an dieser Stelle allerdings mehr als unlogisch. Wie kommt das?

17.09.2012 - 14:16 Uhr

Hallo Community

Ich habe begonnen ein eigenes Chart control in Silverlight zu bauen, was bisher sehr erfolgreich verlief. Allerdings bin ich mit dem Beschriften der Achsen auf ein Problem gestossen.

Auf der Achse (DateTime) soll in regelmässigen Abständen ein Datum mittels eines TextBlocks angezeigt werden. Um das zu erreichen muss ich wissen wie viele TextBlöcke ich auf der Achse platzieren kann. Das ist im Grunde eine simple Rechnung: Achsen-Länge / Textblock-Länge.
Anschliessend habe ich geplant eine entsprechende Anzahl an TextBlock zu instanzen und diese der Achse hinzuzufügen.

Das Problem an dieser Stelle ist allerdings, dass ich die Länge des TextBlocks nicht abfragen kann. Ich habe versucht, die Methode InvalidateMeasure() oder UpdateLayout() einer neuen TextBlock-Instanz mit Text aufzurufen. Beide führen zu keinem Ergebnis, sprich das DesiredSize-property und auch alle andere Grössen-properties des TextBlocks sind 0 oder NaN.

Daher ist meine Frage: Wie kann ich in Silverlight zur Laufzeit herausfinden, wie viele Textblöcke ich in einem Panel mit einer bekannten Grösse platzieren kann, wobei die Grösse des TextBlocks dynamisch errechnet werden soll?

Gruss

Samuel

12.09.2012 - 11:14 Uhr

Hallo

Da kann ich dir folgenden Artikel zum MVVM Pattern von Thomas Claudius Huber sehr empfehlen:

http://www.thomasclaudiushuber.com/articles/200710_ModelViewViewModelArticle.pdf

Gruss

Samuel

12.09.2012 - 11:11 Uhr

Hallo Community

Im Source Code vom Silverlight Toolkit bin ich auf ein interessantes Konstrukt gestossen, dass zumindest für mich neu ist:


protected virtual void UpdateFormattedContent()
{
    this.SetBinding(FormattedContentProperty, new Binding { Converter = new StringFormatConverter(), ConverterParameter = StringFormat ?? "{0}" });
}

Die Methode stammt aus einem Label Control, dessen Text sich über das StringFormat Dependency Property formatieren lässt. Der zu formatierende Text befindet sich im Dependency Property FormattedContent. Dessen Wert ist im Styling an einen TextBlock gebunden:


<TextBlock Text="{TemplateBinding FormattedContent}" />

Der StringFormatConverter wendet den StringFormat Wert auf den Parameter value des Converters an und gibt den daraus resultierenden Wert zurück:


public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
    if (value as string == null)
          return "The parameter 'value' must be of type 'System.String'.";

    return String.Format(culture, (parameter as string) ?? "{0}", value);
}

Unverständlich an dieser Stelle ist mir allerdings, wieso beim Binding das Property Source nicht auf das DependencyProperty FormattedContent gesetzt wurde. Als ich das Control selber nachgebaut habe, erhielt der Converter im Parameter value einfach eine Referenz auf den aktuellen DataContext des LogicalTree.

Könnt Ihr mir erklären, wieso beim Binding das Source Property im original Source Code nicht gesetzt wurde?

Gruss Samuel

12.09.2012 - 10:58 Uhr

Hast du die Binding.Mode Eigenschaft bei dem Binding auf TwoWay gesetzt? Falls nicht, probier das mal aus.

Ansonsten poste bitte den relevanten Code hier.

Gruss

Samuel

08.09.2012 - 20:27 Uhr

Besten Dank für die Antwort.

Zugegebenermassen werde ich für das Projekt letztlich definitiv nicht 1000 Punkte benötigen.
Und auch die Aktualisierung soll in einem viel grösseren Abstand als nur 20 m/s erfolgen.

Trotzdem bin ich etwas überrascht, dass einem bei Silverlight eine derartige Grenze gesetzt ist, was die Grafikperformance betrifft. Meiner Ansicht nach sollte es für einen heutigen Computer nicht wirklich ein Problem sein, eine Polyline mit 1000 Punkten zu rendern.

VISIBLOX zeigt, dass das sogar mit 30000 Datenpunkten geht: Example
In diesem Beispiel gibt es zwar kein Liveupdate, aber man kann die Linien zoomen. Und meiner Meinung nach müssten bei jeder Änderung des Zoomwertes die Polylines neu berechnet und gerendert werden 🤔.
Wie haben sie diese Performance erreicht?

Freundliche Grüsse

Samuel

07.09.2012 - 17:44 Uhr

Hallo StelZenlaeufer

Kannst du den Code mit dem bisherigen Versuch, das Abziehen zu implementieren hier posten?

Gruss Samuel

07.09.2012 - 14:28 Uhr

Hallo Community

Um ein einfaches Chartcontrol zu realisieren habe ich in einem Canvas objekt ein Polyline objekt untergebracht:


<Canvas Name="PART_PlotArea">
       <Polyline Name="PART_Polyline" Points="{TemplateBinding Points}" 
              Stroke="{TemplateBinding Background}" Style="{TemplateBinding PolylineStyle}" />
</Canvas>

Hinten dran wird das Points property alle 20ms aktualisiert:


PointCollection tmp = new PointCollection();
points.ToList().ForEach(p => tmp.Add(p));
Points = tmp;

Das IEnumerable objekt points umfasst 1000 Point objekte.

Das Ganze funktiontiert im Grunde sehr gut, jedoch mit einem leichten Flackern. Leider kann ich in Silverlight nicht wie bei WPF auf den DrawingContext zugreifen um selber eine Polyline zu zeichnen.

Ich suche daher nach Vorschlägen, um mehr Performance beim Zeichenen einer Polyline in Silverlight zu erreichen.

Freundliche Grüsse

Samuel

03.09.2012 - 13:06 Uhr

Evtl. hat es etwas zu tun, dass ich in einem Silverlight Projekt arbeite. Für mich macht das allerdings nicht sehr viel Sinn.

03.09.2012 - 12:59 Uhr

Hallo community.

In der Klasse ObservableCollection<T> gibt es eine protected Methode BlockReentrancy. In einer eigenen Klasse erbe ich von dieser Klasse und sollte eigentlich auf die Methode BlockReentrancy zugreifen können.


public class CockpitObservableCollection<T> : ObservableCollection<T>
{
     protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
     {
         using (BlockReentrancy()) // Does not exist in the current context
         {
              ...
         }
     }
}

Ich erhalte allerdings die Meldung, dass diese Methode im aktuellen Kontext nicht existiert. Woran liegt das?

Gruss

Samuel

11.06.2012 - 16:55 Uhr

Hallo community

Ich studiere gerade eine Beispielapplikation von Infragistics zur Verwendung von ihren controlls. Das Projekt wurde in WPF erstellt.
Nun ist mir aufgefallen, dass sie nicht den klassischen Weg zu Verwendung eines ViewModels gewählt haben. Normalerweise wird im Code-behind ein neues ViewModel instanziert und dem Propertie DataContext von Window übergeben.

In ihrem Falle haben sie die ViewModels in der App.xaml registiert. Ist es sinnvoll diesen Weg für eigene Projekt zu verwenden oder ist eher davon abzuraten?

Gruss

Samuel

31.05.2012 - 11:10 Uhr

Hi MarcC611

Wenn du das Fenster schliesst, läuft zwar wie du richtig bemerkt hast, der Thread weiter, du verlierst aber die Referenz auf den Thread.

Ich denke, du solltest dasThreadhandling oder zumindest die Referenz auf den Thread in eine separate Singleton-Klasse auslagern. Auf diese Weise bleibt dir die Referenz erhalten, auch wenn du das Fenster schliesst.

Ich habe dir ein simples Beispiel erstellt:

MyServer.cs

public class MyServer
    {
        private static MyServer _instance = new MyServer();
        private Thread _myThread;

        public static MyServer Instance
        {
            get { return _instance; }
        }

        private MyServer() { /* Singleton */ }

        private void Listen()
        {
            while (true)
            {
                 // Hier kommt deine Listener-Prozedur hin
            }
        }

        public void Start()
        {
            try
            {
                _myThread = new Thread(new ThreadStart(Listen));
                _myThread.Start();
            }
            catch (Exception ex)
            {
                // Handle exception...
            }
        }

        public void Stop()
        {
            if (_myThread.IsAlive == true)   //Objektverweis fehlt NICHT MEHR!
            {
                _myThread.Abort(); //Objektverweis fehlt NICHT MEHR!
            }
        }
    }

Form1.cs

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            MyServer.Instance.Start();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            MyServer.Instance.Stop();
        }
    }

Es gibt sicherlich noch weitere Lösungen. Diese hier funktioniert aber schon mal 😉.

Gruss Samuel

29.05.2012 - 16:04 Uhr

Hallo Community

Ich habe mit dem WPFToolkit ein Line-Chart aufgestellt. Das Chart verwendet eine entsprechende ItemsSource mit Daten (im Sinne von Datum 😉) und numerischen Werten. Wenn Ihr euch das angefügte Bild anseht, ist recht schnell ersichtlich, dass es mit der Beschriftung der X-Achse etwas schwierigkeiten gibt.

Ich will daher, sagen wir Bsp. nur jeden fünften Datenpunkt auf der X-Achse beschrieben haben. Ich suche daher etwas wie ein Interval oder dergleichen, den man für diese Achse setzen kann.

Freundliche Grüsse

Samuel

25.05.2012 - 16:31 Uhr

Hallo Community

Ich will einen WPF Wrapper schreiben für ein WinForms-Element (Chart).
Dieses beinhaltet eine Collection von spezifischen Elementen. Die Elemente dieser Collection will ich über XAML definieren können, was eigentlich auch ganz gut klappt:

        <this:WinFormsChart>
            <this:WinFormsChart.Series>
                <c:Series Name="Test-Series 1" />
                <c:Series Name="Test-Series 2" />
            </this:WinFormsChart.Series>
        </this:WinFormsChart>

Die Methode, wie ich das mache ist aber nicht sehr schön:

        public readonly static DependencyProperty SeriesSourceProperty =
            DependencyProperty.Register("SeriesSource", typeof(IEnumerable),
            typeof(WinFormsChart), new PropertyMetadata(new PropertyChangedCallback(SeriesSourcePropertyChanged)));

        private static void SeriesSourcePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            MySeriesCollection collection = ((WinFormsChart)d).mySeriesCollection;
            collection.Clear();
            foreach (var item in (IEnumerable)e.NewValue)
            {
                collection.Add((Series)item);
            }
        }

Sobald dem Wrapper (WinFormsChart) ein neues Element hinzugefügt wird, wird im DependencyPropertyCallback der neue Wert in das eigentliche Chart-Controll kopiert.
Die Collection dieses Chart-Controlls kann leider nicht gesetzt werden (Get only). Daher entferne ich alle Elemente und füge sie wieder hinzu inkl. den Neuen.

In diesem Fall kann diese Performance einbusse zwar vernachlässigt werden, weil die Elemente nicht andauernd wechseln. Trotzdem bin ich mit dieser Lösung unzufrieden und ersuche euch nun um euren Rat.

Beste Grüsse

Samuel

22.05.2012 - 08:59 Uhr

Danke für die Antwort =).

Dieses Toolkit wurde seit über 2 Jahren nicht mehr weiterentwickelt...
Eigentlich wollte ich es nicht verwenden. Aber es gibt vermutlich keine bessere Option X(.

Gruss

Samuel

21.05.2012 - 17:18 Uhr

Hi ck123

Ich habe das Problem schnell rekonstruiert.
Die genaue Ursache ist mir nicht bekannt, du kannst das Problem aber wie folgt lösen:

foreach (var item in MyDataGrid.Columns)
                item.Width = 0; // reset width manually
                item.Width = DataGridLength.SizeToHeader;

Diese Lösung hat bei mir wunderbar geklappt 😉.

Gruss

Samuel

21.05.2012 - 15:47 Uhr

Hallo Community

Mit .NET 4.0 hat Microsoft ein Chart Control für Windows Forms geliefert, nicht aber für WPF.
Dieses Control würde ich nun gerne mit dem Features von WPF kombinieren um das MVVM Pattern mit dem DataBinding korrekt anwenden zu können.

Technisch stellt die Verwendung dieses ChartControls in WPF keine Herausforderung dar: WindowsFormsHost. Nur muss ich dann aber auch alles im Codebehinde festlegen und Propertyänderungen manuell behandeln.

Ich habe dann versucht, ein eigenes UserControl zu schreiben, dass ein solches ChartControl hosted. Spätestens aber beim Versuch, Wrapper in Form von DependencyProperties um die Chart Properties herum zu bauen, bin ich ziemlich oft gestolpert und weis nicht so recht wie vorgehen.

Ich würde mich über Vorschläge betreffend einer geeigneten Architektur zur Verwendung des WinForms ChartControls in WPF sehr freuen.

Freundliche Grüsse

Samuel Egger

Beispiel meine Vorgehens:


public static DependencyProperty SeriesProperty =
            DependencyProperty.Register("SeriesProperty", typeof(SeriesWrapper[]), typeof(Chart),
            new PropertyMetadata(new PropertyChangedCallback(OnSeriesPropertyChanged)));

        /// <summary>
        /// Sets the Series property of the Chart object _chartData.
        /// </summary>
        /// <remarks>Represents the callback that is invoked when 
        /// the DependencyProperty SeriesProperty changes.</remarks>
        public static void OnSeriesPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            SeriesCollection col = ((Chart)d)._chartData.Series;
            if (col != null)
                col.Clear();

            foreach (SeriesWrapper item in (SeriesWrapper[])e.NewValue)
                if (item.Series != null)
                    col.Add(item.Series);
        }

Spätestens beim Wrappen des Series Objekts gab es Schwierigkeiten. Beispielsweise verfügt das Series Objekt über keinen Konstruktor, wodurch es nicht direkt in XAML verwendet werden kann.
Der SeriesWrapper ist im Grunde eine Klasse, die von DependencyObject erbt und ein Series objekt kapselt. Dessen Properties wiederum sind anschliessend über DependencyProperties zugänglich. Aber wirklich erfolgreich war das nicht...

08.05.2012 - 13:23 Uhr

Hi

Danke für die Antwort.

Ich finde es zwar etwas unschön designed, wenn man gewisses Verhalten/Eigenschaften nur über die DataSource ansprechen kann. Aber wie dem auch sei, es funktioniert.

Gruss Samuel

07.05.2012 - 16:04 Uhr

Hallo cummunity

Mit .NET 4.0 hat Microsoft ein neues Chart-Control für WinForms eingeführt. Leider nicht für WPF.
Wie dem auch sei. Ich will auf einem Linechart Werte über eine Zeitspanne hinweg anzeigen.
Demenstprechend ist die X-Achse vom Typ DateTime. Der IntervalTyp ist Houres.

_chartData.Series[0].XValueType = ChartValueType.DateTime;
_chartData.ChartAreas[0].AxisX.IntervalType = DateTimeIntervalType.Hours;

Der Interval auf der X-Achse selber ist 24.

Zum Testen habe ich dem Chart einige Werte hinzugefügt:

Series series = new Series("TestSeries");
            
            series.Points.AddY(50);
            series.Points.AddY(79);
            series.Points.AddY(80);
            series.Points.AddY(60);

Wenn ich das Chart nun anzeigen lasse, funktioniert alles bestens. Bis auf die Tatsache, dass das erste Datum auf der X-Achse an der Position 0 der 30.12.1899 ist. Wie kann ich das Startdatum für das Chart verändern?

Gruss Samuel

01.05.2012 - 13:50 Uhr

Hi

Danke für die Antwort, gfoidl.

Allerdings offenbart dieser Link nicht wirklich die internen Mechanismen, die ich suche.
Alle bisherigen Artikel, die ich fand, gabe lediglich Auskunft über die Verwendung von RoutedEvents.

Mich würde allerdings interessieren wie diese RoutedEvents technisch realisiert sind. Wo ist beispielsweise die Schleife, die durch den VisualTree iteriert?

Gruss

Samuel

30.04.2012 - 17:23 Uhr

Hallo community

Ich habe versuche über die .NET Referenz Source und über den Stack Trace etwas mehr über die interne Implementierung des Event Routing herauszufinden.

Mittlerweile weis ich, dass zum Beispiel bei einem Klick auf ein Button über die WndProc ein InputManager aufgerufen wird. Dieser wiederum führt die Methode RaiseEvent() des entsprechenden UIElements aus, welches anschliessend eine Methode (InvokeHandlersImp) der Klasse EventRoute aufruft. Diese Methode iteriert über alle RoutedEvents in der EventRoute-Klasse.

Völlig unklar ist mir allerdings, wie diese Events in diese EventRoute hineinkommen?
Zumal scheinbar jedes UIElement seine eigene Liste von diesen Events hat. Es müsste ja wenn schon eine globale Liste geben...

Für mich spricht die Klasse EventRoute ausserdem dagegen, dass einfach der VisualTree durchiteriert wird und alle gefundenen EventHandler aufgerufen werden.

Gruss Samuel

27.04.2012 - 16:52 Uhr

Hm, ich lag doch richtig mit meinem OnRender().
Ich habe erst später im VisualTree entdeckt, dass sich unterhalb des Buttons ein ButtonChrome ansiedelt. Der Quellcode dieser Klasse wiederum beinhaltet sämtliche prozeduralen Methoden, daneben OnRender() zum Zeichnen des Buttons 😉.

Gruss Samuel

27.04.2012 - 14:43 Uhr

Hm, es lag in der tat daran. Danke für den Hinweis.
Allerdings bin ich jetzt etwas verwundert, denn in devenv.exe.config hatte ich das Property

<loadFromRemoteSources enabled="true"/>

gesetzt gehabt.

Gruss Samuel

27.04.2012 - 13:46 Uhr

Anbei befindet sich ein Screenshot der Situation.

27.04.2012 - 12:09 Uhr

Danke für den Hinweis =)

In dem XAML Code füge ich dem Property Source von Image ein Objekt vom Typ DawingImage hinzu. Das Property Source erwartet aber offensichtlich eine URI. Das DrawingImage Objekt wird nicht als korrekte URI erkannt und daher wird eine Exception geworfen. Gemäss dem Buch WPF Unleashed sollte es aber auch möglich sein, diesem Property Source anstelle einer URI ein DrawingImage objekt zu übergeben.

Die Aussage, dass ich versuchte das Codebeispiel in einem Grid-Panel zu übernehmen meinte einfach, dass ich das Codebeispiel in einem Grid eingefügte hatte:


<Grid>
   <!-- Das Codebeispiel -->
</Grid>

Gruss

Samuel

27.04.2012 - 09:05 Uhr

Hallo community

Das Buch WPF 4 Unleashed von Adam Nathan beinhaltet unter anderem folgendes Codebeispiel:


<Image>
    <Image.Source>
         <DrawingImage>
             <DrawingImage.Drawing>
                 <GeometryDrawing Brush="Red">
                     <GeometryDrawing.Pen>
                         <Pen Brush="Black" Thickness="10" />
                      </GeometryDrawing.Pen>
                      <GeometryDrawing.Geometry>
                          <EllipseGeometry RadiusX="100" RadiusY="50" />
                      </GeometryDrawing.Geometry>
                  </GeometryDrawing>
             </DrawingImage.Drawing>
        </DrawingImage>
    </Image.Source>
</Image>

Der Versuch, dieses Codebeispiel in einem Grid-Panel zu übernehmen ist mir bisher nicht gelungen. Es erscheint die Meldung: Invalid URI: The Autohority/Host could not be parsed.

Wo könnte hier der Fehler liegen?

Gruss

Samuel

27.04.2012 - 08:58 Uhr

Hallo

Besten Dank für euere Antworten 😉.

Freundliche Grüsse

Samuel

24.04.2012 - 16:58 Uhr

Hallo Community

Ich würde gerne versuchen selber ein Chart control in WPF zu entwickeln.
Welche Art von Chart es sein soll spielt zur Zeit keine Rolle. Meine Frfage betrifft eher das Zeichnen.

Das Chart control würde ich gerne direkt unter System.Windows.Controls.Control ansetzen. Mir ist allerdings gänzlich unklar, wie ich dort etwas grafisch darstellen kann. Ich habe über den Sourcecode der vorhandenen WPF Controls geschaut (Referenz Sourcecode) in der Hoffnung, etwas zu finden. Da wurde ich leider endtäuscht.

In den *.cs Dateien der WPF controls is absolut nichts von Rendering oder dergleichen zu finden. Ich hätte beispielsweise beim Buttoncontrol sowas wie eine OnRender-Methode erwartet, wo der Hintergrundverlauf für den Button erstellt wird. Offenbar müssen sich diese Angaben in einer *.XAML-Datei befinden, die im Referenz Sourcecode allerdings nicht vorhanden sind. Daraus folgt aber wiederum die Frage, wo diese XAML-Datei geladen wird?

Meine Frage lautet daher, wo der visuelle Teil von WPF controls definiert und geladen wird?

Freundliche Grüsse

Samuel

19.04.2012 - 17:18 Uhr

Hallo

Danke für die Antworten.

Der Performance Counter hat nicht wirklich viel mit den Message Queues zu tun.

Die Events der System.Messaging.MessageQueue Klasse beschränken sich nur auf eingehende Events. Wird von ausserhalb eine Message entfernt, wirft die MessageQueue Klasse keine Events.

WMI klingt interessant. Ich gehe auch davon aus, dass entsprechende Meldungen aus der Message Queue für Systemnachrichten zu entnehmen sind. Wo ich da allerdings ansetzten muss bin ich überfragt.

Ich habe mich zwar nun dafür entschieden, es mit Polling zu machen. Eine Abfrage alle 10 - 15 Minuten reicht ja. Es wäre aber trotzdem interessant herauszufinden, wie man das ohne Polling realisieren könnte (WMI).

Gruss

Samuel