Hi!

Ich bin mir nicht ganz sicher, aber es koennte sein, dass Du die Anzeige der Beschreibung im PG explizit ein- und ausschalten kannst. Schau mal nach einem entsprechenden Property, welches so etwas ermoeglicht.

Gruss,
Moe

um genauer zu wissen ob es die Temperatur der Graka ist dann teste deine GraKa mal
mit Funmark

Was ich aus diesen Posts herauslese ist, dass vermutet wird, dass die Graka ueberhitzt. Wuerde Sinn machen, wenn im inneren des Gehaeuses unheimlich hoche Temperaturen gelten. Ob es wirklich aber nur an einer alten Waermeleitpaste zu liegen scheint oder kaputten Luefter wage ich zu bezweifeln, wenn wie Dux sagt, er die Graka gegen eine andere bereits ausgetauscht hat und dieselben Probleme auftretten. Im schlimmsten Fall kann auch das Mainboard einen Schlag haben bzw. der Graka Port.

Die Idee mal einen Benchmark zu verwenden ist allerdings nicht schlecht, um zu schauen, wie es sich da verhaelt. Kannst ja mal beobachten, ob du mittels eines Benchmarks aehnliches Verhalten immer wieder nachstellen kannst.

Gruss,
Moe

Hi THQ!

Ich wuerde gar nicht erst die Instanz austauschen wollen. Warum denn nicht einfach eine Instanz der Personal Klasse mit Daten auffuellen, wenn diese benoetigt werden?
Verwendest Du einen OR-Mapper fuer die Persistierung?

Gruss,
Moe

Moin!

Z.B. mittels Generics

Gruss,
Moe

Wenn Du *.docx Dateien meinst, dann schau mal hier:

Manipulate Docx with C# without Microsoft Word installed with OpenXML SDK

Vielleicht hilft es Dir weiter.

Word XML erstellt

Meinst Du *.docx?

Kann ich das gesamte Array übergeben?

Ja, solltest Du koennen (ohne sich jetzt Deinen Code im Detail angeschaut zu haben).

Ich habe mal folgende Methode geschrieben, die mir ein zweidimensionales Array in eine Excel Tabelle wegschreibt:

        private void WriteDataToWorksheet<T>(T[,] data, Worksheet workSheet)
        {
            // ... some error handling
            var range = workSheet.Range["A1", Type.Missing];

            // ... some error handling

            range = range.Resize[data.GetLength(0), data.GetLength(1)];
            range.Value = data;
        }

Kann mir das kurz nochmal jemand erklären?

Schau mal in unsere Rubrik "Resource". Dort findest Du u.A. openbook: C#

Dort wirst Du auch etwas ueber Events finden.

Gruss,
DaMoe

Kleiner Tipp zum Dictionary, aber auch in der MSDN nachzulesen:

var testPlayer = new Player("Moe");
var testPictureBox = ...;

var playerControlAssociation = new Dictionary<Player, PictureBox>();
playerControlAssociation[testPlayer] = testPictureBox;

Gruss,
DaMoe

Hi!

Ich hatte ein aehnliches Problem zwar unter Forms, aber eventuell ist es unter WPF aehnlich unhandlich bzw. schwierig ein bestimmtes Coloring-Verhalten hervorzurufen. Schau Dir doch mal an, wie es in dem nachfolgenden Beispiel gemacht wurde (es ist nicht der einfachste Weg):

Syntax Highlighting RTB

Gruss,
DaMoe

Hallo!

Auch wenn Du schon eine Loesung besitzt, folgende Anmerkung habe ich noch:

element.DescendantNodesAndSelf().Cast<XComment>();

Nette Idee, aber so wie ich es verstanden habe, machst Du keinen Cast, sondern fuehrst eine Konvertierung durch, weshalb der oben aufgefuehrte Versuch auch nicht funktioniert hat. Du solltest Folgendes schreiben koennen:

var comments = element.DescendantNodesAndSelf().Select<XNode>(node => new XComment(node.ToString());

Gruss,
Moe

1. Exception in eine andere Assembly ausgelagert
2. Ctor Paramter an Exception per "base" weiterdelegiert

Resultat: Funktioniert weiterhin im Test.

Hi!

Stattdessen tauchen Fragezeichen ( also "?" ) oder diese Vierecken bzw. Balken auf

Das laesst meistens auf ein Encoding Problem schliessen.

Ich habe auch bereits dem Streamreader Encodings mitgegeben. Das führt interessanterweise aber immer zum Absturz der ganzen Anwendung. Leider ohne irgendeine Meldung.

Du sollest schon eine Fehlermeldung herausbekommen. Zumindest kannst Du einen try-catch Block um die auslesende Methode setzen, sodass der Fehler behandelt wird und es Dir moeglich ist die Exception zu analysieren.

Gruss,
Moe

Hi!

Ich habe Folgendes ausprobiert und es funktioniert einwandfrei:

    [Serializable]
    public class ApiMisuseException : Exception
    {
        public ApiMisuseException(string message, Exception innerEx)
        {
        }

        public ApiMisuseException(string message)
        {
        }

        public ApiMisuseException()
        {
        }

        protected ApiMisuseException(SerializationInfo info, StreamingContext ctx)
        {
        }

    }

    [TestFixture]
    public class TestClass
    {
        [Test]
        public void Deserialize_ExceptionSerializeWithBinaryFormatter_ExceptionIsDeserialized()
        {
            ApiMisuseException e = new ApiMisuseException();
            using (Stream s = new MemoryStream())
            {
                var formatter = new BinaryFormatter();
                formatter.Serialize(s, e);
                s.Position = 0;
                e = (ApiMisuseException)formatter.Deserialize(s);

                Assert.That(e, Is.Not.Null);
            } 
        }
    }

Gruss,
Moe

Hallo Tux!

Ein gutes Stichwort an dieser Stelle, um eine Aufgabe wie hier, das Oeffnen und Schliessen einer Session, zu bewerkstelligen, ist AOP. Man kann das Session/Transaktionshandling schoen in einen Aspekt auslagern. Du erstellst Dir ein DAO, welches nur die "eigentliche" Funktionalitaet enthaelt wie bspw. das Holen von Entities anhand eines Namen.

Nur dazu muss ich irgendwie informiert werden, wenn ein Zugriff auf diese Objekte erfolgt.

Sobald irgendeine Methode des DAOs betretten wird, wird eine Session/Transaktion geoffnet und Deine Information aus der Datenbank geholt.

Ich möchte ungern im GUI überall die Session wieder öffnen müssen, sondern das ganze auf eine niedrigere Schicht auslagern

Du solltest nicht nur das Sessionhandling auslagern, sondern wie oben beschrieben auch die eigentliche Businesslogik.

Gruss,
DaMoe

Warum denn neu schreiben? Mittels eines Addin fuer den .Net Reflector laesst sich bspw. gleich eine ganze Assembly dekompilieren und direkt als VS Projekt speichern.

Gruss,
DaMoe

cars.Select((Func<Car,string>)Program.GetId)  

Klar, das geht natuerlich auch. Hier sieht man es, wie ich finde noch schoener, dass der unter VS2008 verwendete Compiler den Typen nicht automatisch aufloesen, was aber mit dem Compiler unter VS2010 funktioniert.

Viel mehr interessiert mich, gibt es irgendwo eine Liste zu den Unterschieden zw. den Compilern Versionen? Ich selber habe leider nichts gefunden.

Gruss,
Christoph

Wenn Du keine Instanz erzeugen willst, solltest du deinen Event als static definieren.

Mit statischen Events waere ich vorsichtig. Auch wenn man es nicht glauben mag, kann es zu "Memory Leaks" fuehren, da Objekte von der Garbage Collection nicht abgeraeumt werden. Obwohl sie nicht mehr benoetigt werden, bestehen die Objekte weiter im Speicher, weil sie sich noch an einem statischen Event angemeldet haben. Diese Gefahr besteht auch bei nicht-statischen Events, aber noch eher bei statischen Events.

Gruss,
DaMoe

Hallo zusammen,

kuerzlich bin ich auf folgende Unterschied bei der Kompilierung von Code im VS2010 und VS 2008 gestossen. Ich fuehre das einmal auf die unterschiedliche Version des C# Compilers zurueck.
Nachfolgend ein stark vereinfachtes Beispiel, welches mit beiden Compilern fuer .Net 3.5 kompiliert wurde/ werden sollte:

internal class Program
    {
        public static void Main(string[] args)
        {
            var audiId = Guid.NewGuid();
            var bmwId = Guid.NewGuid();
            var porscheId = Guid.NewGuid();

            var cars = new List<Car>
                           {
                               new Car { Id = audiId, Name = "Audi A3" },
                               new Car { Id = bmwId, Name = "BMW" },
                               new Car { Id = audiId, Name = "Audi A4" },
                               new Car { Id = porscheId, Name = "Porsche" },
                               new Car { Id = audiId, Name = "Audi A5" }
                           };

            // Hier greift die Type Inference. Diese Zeile kann problemlos von
            // VS2010 kompiliert werden. VS2008 erkennt hier ein Problem und sagt,
            // dass es mit der Type Inference Probleme hat. Mann muss stattdessen schreiben:
            // ... cars.Select(car => Program.GetId(car))....
            string carIds = cars.Select(Program.GetId).Aggregate((current, next) => string.Format("{0},\n{1}", current, next));

            Console.WriteLine(carIds);
            Console.ReadLine();
        }

        public static string GetId(Car car)
        {
            return car.Id.ToString();
        }
    }

    internal class Car
    {
        public Guid Id { get; set; }

        public string Name { get; set; }
    }

Mir war nicht klar, dass es diesen Unterschied gibt. Ich habe ein wenig recherchiert, habe aber zu den Unterschieden nichts gefunden. Habt Ihr zu den Unterschieden in den Compilern irgendwelche Quellen?

Gruss,
DaMoe

Schau Dir mal die vorhandenen Extension Methoden an, eventuell hilft Dir schon die Distinct Methode weiter:

Distinct Extension Method

Gruss,
DaMoe

Hi!

Dir wird wohl nichts anderes uebrig bleiben, als auf WinAPI zurueckzugreifen.
Ich vermute mal, dass Application.OpenForms deshalb leer sein wird, da der modale Dialog nicht aus der GUI MessageLoop gestartet wurde, also indirekt irgendwo Application.Run(...) und somit in in OpenForms enthalten ist.

Vielleicht hilft Dir Folgendes weiter. Ich habe kuerzlich eine Konsolenapplikation geschrieben, die nach einem Fenster pollt und es schliesst, sobald es auftaucht.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace Utils
{
    internal class User32
    {
        // Fields
        public static readonly int ScClose = 0xf060;
        public static readonly uint WmSyscommand = 0x112;

        [DllImport("user32.dll", SetLastError = true)]
        public static extern IntPtr FindWindowEx(IntPtr windowHandle, IntPtr windowHandleChildAfter, string lpszClass, string lpszWindow);

        [DllImport("user32.dll")]
        public static extern int SendMessage(int windowHandle, uint message, int rightParameter, int leftParameter);

        // Find window by Caption only. Note you must pass IntPtr.Zero as the first parameter.
        [DllImport("user32.dll", EntryPoint = "FindWindow", SetLastError = true)]
        public static extern IntPtr FindWindowByCaption(IntPtr zeroOnly, string windowName);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace Utils
{
    internal class Program
    {
        public static void Main(string[] args)
        {
             ThreadPool.QueueUserWorkItem(state =>
            {
                for (;;)
                {
                    var windowPtr = User32.FindWindowByCaption(IntPtr.Zero, "Information");

                    if (windowPtr != IntPtr.Zero)
                    {
                        User32.SendMessage(windowPtr.ToInt32(), User32.WmSyscommand, User32.ScClose, 0);
                        Console.WriteLine("Dialog closed\n");
                    }

                    Thread.Sleep(500);
                }
            });

            Console.ReadLine();
        }
    }
}

Moin!

Laeuft die Applikation in einem anderem Prozess oder befindest Du Dich im gleichen Prozess?
Ich habe noch nicht genau verstanden, warum Du an das Fenster herankommen musst. Blockiert der modale Dialog Deinen Algorithmus oder was ist das eigentliche Problem?

Gruss,
DaMoe

Moin Froggie!

zu 1. Ich kann die DLLs nicht mit meiner Signatur neu signieren:

Als erstes faellt mir die Frage ein, ob es Dir rechtlich ueberhaupt erlaubt ist, Fremdassemblies zu mergen und anschliessend neu zu signieren.

zu 2. Ohne Weiteres ist das mergen von Resource/Satelliten-Assemblies nicht moeglich. Hierzu kann ich Dir folgenden Link geben: Single-assembly multi language

Aus meiner Erfahrung muss man ausserdem noch auf Dinge wie Reflection oder DI Container wie Spring.Net etc. verzichten, wenn man ILMerge einsetzt.
Du wirst sicherlich Deine Gruende habe, wieso Du eine einzige Assembly haben moechtest, aber ich sehe solch eine Anforderung stets mit ein wenig Skepsis.

Gruss,
Moe

Hi!

Habe hier im Forum nach SplashScreen gesucht und folgendes gefunden:

SplashScreen

Und noch viele mehr Eintraege. Wurde schon oefters behandelt. Schau noch einmal.

Anmerkung: Den Splashscreener, der in dem Beitrag aufgefuehrt wird, finde ich nicht so gut, weil dieser mit Application.DoEvents() arbeitet, was man nach allgemeiner Ansicht tunlichst vermeiden sollte.

Gruss,
Moe

Moin!

Nun würde ich gerne die Klasse durch neue Funktionen in einer neuen Assembly erweitern, ist das möglich

Ja, auch durch Extension Methods.

Aber warum verwendest du nicht Vererbung?

Bitte nur Vererbung dann verwenden, wenn es Sinn macht und das Liskov'sche Substitionsprinzip nicht verletzt wird.

Gruss,
DaMoe

Moin Lucky!

Es gibt die Moeglichkeit lokalisierte Resource in einer Datenbank abzulegen, indem Du einen eigenen ResourceManager erstellst, der auf eine Datenbank zugreift. Sehr ansehnlich hat das der Author Guy Smith-Ferrier in seinem Buch .Net Internationalization gemacht. Die Beispiele kannst Du unter I18N einsehen. Du musst etwas auf der Seite suchen. Dort sollte auf jeden Fall ein Beispiel zu Deiner Problematik existieren.

Gruss,
DaMoe

Moin!

Das Pendant zu KeyPress in Forms findest Du hier:
Control.OnKeyPress Method

Das kann Dir eventuell weiterhelfen fuer Deine WPF Problematik.

Schau auch mal hier im Forum, dieses Thema gabe es schon haeufiger.

Ausserdem, wenn Du etwas systemweit "loggen" moechtest, dann wirst Du um Hooks nicht herumkommen bzw. wird Dir das OnKeyPress event nur in Deiner Applikation selber etwas bringen.

Gruss,
DaMoe

Moin!

Warum hat es Dir nichts gebracht? Was hast Du ausprobiert?

Gruss,
DaMoe

Benoetigst Du einen Screenshot der Auflistung aller Apps so wie gfoidl es vorgeschlagen hat oder moechtest Du erst einmal selber von jeder App einen Screenshot haben und diese dann selber weiterverarbeiten?

Gruss,
DaMoe

Hallo!

An deiner Stelle würde ich als Basisklasse die Klasse Tabelle nehmen. Die Klassen Zelle und Spalte erben dann von dieser.

Vererbung sollte man fuer das hier beschriebene Problem nicht verwenden. Es ist gar falsch Vererbung zu verwenden. Verwendet man Vererbung ist das Subsitionsprinzip verletzt. Man kann sich das schnell bereits an den Namen bzw. durch den normalen Sprachgebrauch klar machen. Wenn Zelle und Spalte von Tabelle ableiten, dann heisst das, dass Zelle und Spalte eine Spezialisierung von Tabelle sind bzw. noch kuerzer ausgedrueckt: Eine Zelle/Spalte ist eine Tabelle. Und das ist m.E. nach eine falsche Aussage.

Schau Dir doch einfach mal die DataView Klasse aus dem .NetFramework an. Da kannst Du Dir sicherlich einige Dinge abschauen bzgl. Rows and Columns.
DataView

Um eine kurze Antwort zu Deiner Frage zu geben:
Im einfachsten Fall, wenn Du von der Klasse Zelle/Spalte auf die Klasse Spalte zugreifen moechest, genuegt es dass die entsprechenden Klassen Zelle/Spalte eine Instanz der Klasse Tabelle enthalten.

Gruss,
DaMoe

Moin!

Normalerweise haette ich, falls es keinen Weg ueber die Web.config gibt, von dem Attribute abgeleitet und eine entsprechende Moeglichkeit des Auslesens zusaetzlich angeboten. Da aber die von Dir angesprochene Attributt Klasse sealed ist, ist es denklich schwer davon abzuleiten. Es sollte trotzdem die Moeglichkeit bestehen eine eigene Attribut Klasse zu erstellen, die Ihre Konfiguration aus irgendeiner Quelle (hier vornehmlich eine Datei) zu ziehen und anschliessend eine Instanz des EnableClientAccess Attributes erstellt und "im System" registriert (soweit die erste Ueberlegung).
Eine weitere, nicht schoene Moeglichkeit besteht darin, if - Defs zu verwenden (Beispiel mittels eines bestehenden Debug-Define):

#if DEBUG
           [EnableClientAccess(RequiresSecureEndpoint = true)]
#else
           [EnableClientAccess(RequiresSecureEndpoint = false)]
#endif
public class AuthenticationDomainService : AuthenticationBase<User> 

In diesem Beispiel bedeutet es nun, dass SSL aktiviert ist, wenn die Solution im Debug Modus kompiliert wird, ansonsten ist SSL deaktiviert.

Gruss,
DaMoe

Hallo blasterwurm,

was ist Dein Wissensschwerpunkt? Hast Du vorher schon einmal programmiert? Ich habe lediglich gelesen, dass Du vorher noch nie mit Eclipse oder VS gearbeitet hast.
Deiner Beschreibung nach, schliesse ich, dass Dir noch viele grundlegende Programmierkenntnisse fehlen.
Sicherlich kannst Du, wie mein Vorredner gfoidl, schneller mit MatLab und Co zu Deinem Ziel kommen. Es ist nun an dieser Stelle wichtig, was Deine Ziele der Projektarbeit sind. Die Aufgabe, die Du beschrieben hast, ist umfangreich, gerade fuer Anfaenger, wenn man sich noch mit vielen grundlegenden Dingen beschaeftigen muss. Aber dafuer ist doch auch eine Projektarbeit, dass man sich in bestimmte Themengebiete einarbeitet. Drei Monate hoert sich initial lang an, aber da kommen neben der eigentlichten Programmierung, Konzeption, Auseinandersetzen mit neuen Techniken, Grundlegende Einarbeitung in die Programmierung/ Recherche und wahrscheinlich Dokumentation hinzu.

Du musst Dich an dieser Stelle sehr gut selber einschaetzen. Hast Du den Biss Dich ueber einen laengeren Zeitraum permanent mit einem Thema auseinanderzusetzen und wohlmoeglich ueber den Freitag hinaus einzusetzen?
Fuer einen Anfaenger ist es eine Herausforderung, selbst fuer einen erfahrenen Programmierer ist so etwas nicht eben implementiert. Ich sehe das so, dass es schaffbar ist, aber mit viel Ehrgeiz. Du musst Dir permanent im klaren sein, dass es ein hoch gestecktes Ziel ist.

Gruss,
DaMoe

Hallo!

Innerhalb eines VS Projekts hat man die Moeglichkeit in den Eigentschaften/Properties Referenzpfade anzugeben. Im VS 2008 hat man nun beim Hinzufuegen einer Referenz zu einem Projekt im "Add Reference"-Dialog die Assemblies gesehen, die sich in/hinter dem angegebenen Referenzpfad in den Eigentschaften befinden.

Beispiel:
In den Eigentschaften meines Projekt habe ich als Referenzpfad angegeben: "\MyPc\Builds\Framework&quot;. In diesem Verzeichnis befinden sich nun die Assemblies A.dll, B.dll und C.dll. Nun moechte ich meinem Projekt eine Referenz hinzufuegen, oeffne den "Add Reference" Dialog und sehe im VS2008 die Assemblies A.dll, B.dll und C.dll unter dem Reiter .Net Assemblies aufgefuehrt.

Versuche ich das oben aufgefuehrte Beispiel mit VS2010 nachzuspielen, sehe ich in dem "Add Reference" Dialog nicht die entsprechenden Assemblies, obwohl sie in den Projekteigenschaften ein Refernzpfad eingetragen ist.
Ich habe zu dieser Problematik leider keine brauchbaren Informationen gefunden. Ich habe die Productivity-Tools fuer VS2010 ausgetestet, wodurch der "Add-Reference" Dialog ausgetauscht wird, um zu schauen ob das Verhalten sich veraendert hat. Es war nicht der Fall.

Wird man wirklich diese Funktionalitaet fuer das VS2010 selber nachprogrammieren muessen? Hat jemand von Euch eine Loesung dafuer bzw. ist dieses Problem auch aufgefallen?

Gruss,
DaMoe

Hi!

Grundsaetzlich wuerde ich mich erst fragen, ob wirklich alle Objekte ueber das entsprechende Property verfuegen. Besitzen denn wirklich alle Typen ein Foto, wie z.B. Association, League oder Stadium? Sollte eine Klasse ImageFile nicht nur bei Bedarf anbieten (YAGNI)?

Was natuerlich nicht schoen ist, dass Du bspw. in der Klasse Club, dann zwei Properties besitzt, die das gleiche zurueckliefern (ImageFile und Emblem). Hier kannst Du gut mit Interfaces arbeiten, um die Belange zu trennen und somit die "Sichtbarkeit" der Properties zu veraendern.

Gruss,
DaMoe

...natürlich kann man auch das abschalten - mit einem Javascript, das alle Tastatureingaben abfängt und "Enter" ignoriert:...

Ist es nicht ein leichtes Javascript abzuschalten? Soweit ich mich erinnere ist das bspw. beim Firefox mit ein paar Klicks erledigt. Ist es somit nicht leichtfertig eine grundlegende Funktionalitaet in Javascript umzusetzen?
Ich will hier keine Grundsatzdiskussion ueber den Sinn und Unsinn von Javascript lostreten, sondern ich bin lediglich daran interessiert, ob mein Gedankengang an dieser Stelle in die falsche Richtung fuehrt.

Gruss,
DaMoe

Nachtrag:

Es ist nicht das beste Beispiel, aber zeigt das Problem eines Deadlock in Kombination mit lock(this):

Evial lock(this)

Gruss,
DaMoe

Moin!

Ein Lock auf das eigentliche Objekt kann schneller zu einem Deadlock fuehren, weshalb es ratsam ist ein separates Lockobjekt zu verwenden.

Gruss,
DaMoe

Moin!

Ein aehnliches Verhalten habe ich mit DropDown Controls auch bei WinForms beobachten koennen. Ich meine mich erinnern zu koennen, dass dieses Problem auftaucht, wenn die DataSource der DropDown-Listen dieselben sind, d.h. die gesetzten DataSources verweisen beide auf bspw. dieselbe Liste. Schau mal in diese Richtung, ob es Dein Problem loest.

Gruss,
DaMoe

Alternativ kann man Folgendes verwenden, wenn auch nicht so elegant wie mit dem SynchronizationContext:

if ((Application.OpenForms.Count > 0) && Application.OpenForms[0].InvokeRequired)
{
    returnValue = Application.OpenForms[0].Invoke(method, args);
}

Gruss,
DaMoe

Moin,

ein Stichwort ist an dieser Stelle SynchronizationContext.

Gruss,
DaMoe

Ich sehe gerade, dass Dir auch ein GraphicsPath eventuell genuegt. Auch dieser verfuegt ueber eine Methode wie IsVisiblePoint.

Gruss,
DaMoe

Moin!

Wenn es um beliebig geformte Objekte geht, dann wuerde ich persoenlich zum eigenen Zeichnen tendieren (natuerlich kann es da auch schon Bibliotheken geben). Im System.Drawing Namespace findest Du alles, was das "Zeichnerherz" begehrt. Ich spreche konkret von der Region Klasse. Du kannst diese mittels eines GraphicsPath initialisieren. Der GraphicsPaths wiederum benoetigt ein Array von Punkten, der diesen beschreibt. Somit erhaelst Du eine Region, die Dein "Objekt" beschreibt. Die Region enhaelt eine Funktion, die IsVisiblePoint(Point) enhaelt. Damit kannst Du ueberpruefen, ob ein Punkt in der Region enhalten ist.
Natuerlich musst Du Dir die Regions merken und sobald auf Deine Bildflaeche geklickt wird, muss die Liste der Regions durchlaufen und geschaut werden, ob der "Klickpunkt" in einer der von Dir definierten Regions liegt usw.

Gruss,
DaMoe

Moin!

Ich erweitere momentan das VS 2010 ueber ein vsix-Package. Ein Teil der Erweiterung beinhaltet einen Eintrag im Optionsmenu von VS (Tools->Options). Soweit ist das relativ schnell bewerkstelligt, wenn man von der Klasse Microsoft.VisualStudio.Shell.DialogPage ableitet. Alle oeffentlichen Properties werden standardmaessig abgespeichert. Sobald aber ein Property nicht von einem integralen Typen ist, muss man dies mittels eines TypConverters bewerkstelligen. Selbst das ist schnell implementiert und das entsprechende Property deklarativ mittels [TypeConverter(typeof(...))] markiert. Das Problem, was hierbei entsteht ist, dass sobald der TypeConverter sich nicht in der eigentlichen "Hauptassembly", in der die Options-Page implementiert ist, befindet, wird der eigene TypConverter **nicht **geladen und der Default Converter wird verwendet. Somit kann wird das Property nicht abgespeichert.
Ich kann mir vorstellen, dass es etwas mit Berechtigungen auf sich hat, konnte das aber leider bis jetzt nicht verifizieren. In der Dokumentation (DialogPage) bin ich leider auch nicht fuendig geworden. Die Assemblies sind beide mittels eines SNK's signiert.

Hat jemand von Euch aehnliche Erfahrung gemacht? Gibt es dafuer eine Loesung? Sicherlich kann ich den Converter in das andere Projekt verschieben, logisch passt er aber nicht an die Stelle.

Gruss,
DaMoe

Moin tkrasinger!

Wie gesagt, ich kenne mich nicht mit Silverlight aus, aber gibt es nicht eine Art OnPaint Methode, die man ueberschreiben kann? Oder ist gar Reflection moeglich?
Ist denn dieser vermeindliche Fehler mal irgendwo durch andere reportiert worden? Oder ist es ein Breaking Change, der nur auftritt, wenn man etwas unter 3.0 kompiliert und unter 4.0 ausfuehrt?

Gruss,
DaMoe

Moin!

Ohne jetzt sich zu genau mit Silverlight beschaeftigt zu haben, aber meistens sind solche Problem "Auf den Entwicklerrechnern funktioniert alles, nur beim Kunden tritt der Fehler auf" darin begruendet, dass doch irgendwelche Patches, Dlls o. Ae. fehlen. Schau Dir mal genau die Version von Silverlight an, d.h. nicht nur zu schauen, ob 3.0 installiert ist, sondern ob es 3.0.XXXX ist und nicht 3.0.XXXY.

Gruss,
DaMoe

Secure String

Note that SecureString has no members that inspect, compare, or convert the value of a SecureString. The absence of such members helps protect the value of the instance from accidental or malicious exposure.

Moin!

Ich denke nicht, dass man SecureString direkt miteinander vergleichen sollen koennte, da es meiner Ansicht nach zu Sicherheitsproblemen fuehren kann.
Angenommen Du bist derjenige, der den SecureString knacken moechte. Sollten die SecureStrings vergleichbar sein, dann koennstest Du theoretisch per BruteForce immer einen unverschluesselten String hernehmen, zu einem SecureString umwandeln und anschliessend mit dem zu kanckenden SecureString vergleichen. Wenn diese dann gleich sind, dann hast du den String geknackt. Also eine denkbar schlechte Funktionalitaet, wenn es diese gaebe.

Gruss,
DaMoe

Ich finde es interessant wie vehement hier doch ueber TDD diskutiert wird.

Wir sind in unserem Unternehmen gerade an einer Stelle angelangt in der ein Umbruch stattfindet und wir vermehrt auf TDD setzen. Was ich feststellen kann, ist dass einige theoretisch TDD gut finden, allerdings selber eher zaghaft bis gar nicht TD-entwickeln und einige es noch gar nicht anwenden. Sie haben gemein, dass Sie als Argument anbringen, dass TDD die Entwicklung verlangsamt und "Mal eben ein Bugfix am Framework" nicht durchgefuehrt werden kann. Sicherlich verlangsamt TDD anfangs die Entwicklung, denn, wie Ralph bereits erwaehnt hat, bedeutet TDD ein Umdenken, ein anderes, nicht vertrautes Vorgehen sich aneignen, was fuer Unbehagen sorgt.
Aber es gibt auch Entwickler, die mittels intrinsischer Motivation sich auf Unit Test, Insolations-Frameworks, TDD und Co. einlassen und schnell die Vorteile sehen.
Ich kann aus eigener Erfahrung sagen, dass man sich auf TDD einfach mal einlassen sollte und zwar ueber die Schwelle einfacher TextFixtures hinaus. Einlassen deshalb, weil es genug Leute gibt, die viel Zeit haben sich mit solchen Dingen zu beschaeftigen und ein gutes Urteil abgeben koennen. Warum diesen nicht mal vertrauen und selber in einem Feldtest ausprobieren. Nach einiger Zeit (das kann gut mal ein Monat sein) stellt sich ein gewisser AHA-Effekt ein und das ist der Punkt, der erreicht werden muss. Fuer mich waren AHA-Effekte:

"...Wow, den Fehler haette ich glatt uebersehen, wenn ich nicht den Test dafuer geschrieben haette.." (und das nicht nur einmal)

"...das Interface ist doch ein wenig zu kompiziert geschnitten, sodass ich es ueberarbeiten muss..."

"...ich kann beruhigt Aenderungen vornehmen, weil ich nicht viel kaputt machen kann, obwohl den Code ein Kollege geschrieben hat..."

"...ich brauche erst einmal meine gesamte App nicht mehr zu starten, um gewisse Logik nur kurz zu testen. Das Entwickeln geht viel schneller von der Hand..."

Testgetrieben vorzugehen sehe ich als unabhaengig von der Teamgroesse, egal wie "kommunikativ" jemand ist (wie in einem Vorpost als Argument gegen TDD zu lesen war). Selbst ich weiss manchmal nach ein paar Wochen nicht mehr genau, war an dieser oder jenen Stelle im Code explizit gemacht wurde und ich denke, dass ich nicht der einizige bin, der vor so einem Problem steht. Und da helfen UnitTests ungemein den Code wieder zu verstehen und auch das Gefuehl zu geben, dass ich andere Dinge nicht zerstoere, vor allem bei grossen Projekten, die man als Durchschnittsmensch aufgrund der Komplexitaet nicht mehr fassen kann. Und da ist TDD genau das richtige Mittel, denn hinterher schreibt man die Test nicht mehr oder nur noch sehr ungern und macht diese nur oberflaechlich, sodass man sie gleich weglassen kann.

Gruss,
DaMoe

Hi!

Ich werde mal nachfolgend versuchen ein wenig Code darstellen. Dieser ist nicht getestet, aber sollte Dir helfen auf eine Loesung zu kommen. Dieser Code iteriert ueber alle Gruppen und gibt die Benutzer zu der jeweiligen Gruppe aus:

var directorySearcher = new DirectorySearcher { SearchRoot = new new DirectoryEntry(...), Filter = "(&(objectClass=group))" };
// Define filters to determine which group's properties will be shown
directorySearcher.PropertiesToLoad.Add("name");
directorySearcher.PropertiesToLoad.Add("objectsid");

// Sets the number of groups who will be listed to the maximum of an Int32
// If no value will be specified the default number of shown users will be 1000
directorySearcher.PageSize = Int32.MaxValue;
directorySearcher.SizeLimit = Int32.MaxValue;
directorySearcher.CacheResults = true;

SearchResultCollection results = directorySearcher.FindAll();

// Iterate through all groups
foreach (SearchResult searchResult in results)
{
   // anonymous type is used only for better understanding in
   // this mycsharp sample. Create a concrete enity
   var group = new
   {
      Name = GetPropertyValue(searchResult, "name"), 
      SID = GetSIDValue(searchResult)
   };

   // Invoke method Members to get all members i.e. users assigned to the current group
   object members = new DirectoryEntry(searchResult.Path).Invoke("Members", null);

   // anonymous type is used only for better understanding in
   // this mycsharp sample. Create a concrete enity
   // Iterate through all users
   var users = (from object user in (IEnumerable)members
                                      select new DirectoryEntry(user)
                                      into userDirectoryEntry
                                      select new
                                                 {
                                                     SID = this.GetSIDValue(userDirectoryEntry),
                                                     Name = this.GetPropertyValue(userDirectoryEntry, "name")
                                                 }).ToList();

   // Do something with the group and its assigned users

}

private string GetPropertyValue(DirectoryEntry directoryEntry, string propertyName)
{
   PropertyValueCollection pvc = directoryEntry.Properties[propertyName];
            
   if ((pvc != null) && (pvc.Count > 0))
   {
      return pvc[0].ToString();
   }

   return string.Empty;
}

private string GetSIDValue(DirectoryEntry directoryEntry)
{
   PropertyValueCollection pvc = directoryEntry.Properties["objectsid"];
   if ((pvc != null) && (pvc.Count > 0))
   {
      var sid = new SecurityIdentifier((byte[])pvc[0], 0);
      return sid.Value;
   }

   return string.Empty;
}

Gruss,
DaMoe