Hm habs mal Probiert...scheinbar "spruckt" das Bubbling drauf wenns an nem Panel hängt, sobald man das auf ein überliegendes Control legt, klappts wieder. Könntest rein theoretisch auf nen Container gehen...also ContentPresenter oder so, hab ich noch nicht probiert...müsste aber gehen...

Du kannst über die InputBindings Tastenkombinationen mit einem Command verbinden, das Command kann zb in einer statischen Klasse oder deinem ViewModel hinterlegt sein:

    <Grid>
        <Grid.InputBindings>
            <KeyBinding Command="{x:Static MyCommandCollection.MyCommand}" Key="A" Modifiers="Control" ></KeyBinding>
        </Grid.InputBindings>
    </Grid>

CommandBinding war daher nicht ganz korrekt...ist immer ne Sache was man meint und was man sagt, bzw schreibt 😉

Dann reicht ein einfaches CommandBinding voll aus..deine Tastaturkombi wird, wenn es vom fokusierten Control nicht ausgewertet wird, an das Parent geschickt...bis es entweder beim Fenster ankommt oder auf einen "auswerter" trifft...

Geht also auch ohne "häggerei" im Code-Behind

vg

Hallo,

ich frag mal ganz provokant, wieso habt ihr eine textbox in einer textbox ? das das ist eine etwas ... holprige lösung...wenn ihr ne textbox selbst macht, dann erbt doch von textbox und baut das template korrekt, dann treten solche probleme gar nicht auf (gibt n trick sich die kompletten styles per reflection aus der controls zu ziehen, gibt sicherlich einige beispiele wenn man sucht)

das selbe spielchen mit der checkbox...

Es gibt da einen unterschied, zwischen customcontrol und usercontrol, willst du ein steuerelement auf einer "atomaren" ebene so erweitern dass sich das vererben lohnt, dann vererbe. Wenn die Anforderung ein "kombiniertes" steuerelement ist, benutz ein Usercontrol.

Bei den Bindings muss man immer darauf achten, dass die Bindingkette von A nach B konsequent durchzieht...ist wie mit so domino-steinchen..das eine schubst das andere an.

In der Custom-CheckBox verwendest du einen TextBlock als Content für eine Checkbox, sowas sollte man vielleicht noch mal überlegen, das geht auf dauer stark in die performance, da du anstatt einem controll auf einmal 3 hast .. deins, die checkbox und die textbox.

wenn ihr nur bestimmte fähigkeiten eines controls erweitern wollt, könnt ihr attached properties verwenden oder behaviors, das ist wesentlich einfacher.

Noch ein kleiner Hinweis...Blend ist ein sehr gutes werkzeug für das zusammenstellen von UI's und ziemlich einfach zu benutzen, das gibt seltsamerweise viele firmen die versuchen sowas nachzuprogrammieren...sich ins programm einarbeiten geht 1000 mal schneller.

vg

Hallo,

wofür brauchst du das denn ? ... du kannst das ganze auch wesentlich eleganter lösen, je nach anwendungsfall hast du verschiedene möglichkeiten.

grundsätzlich sind der logische fokus und tastaturfokus was ganz anderes, das eine ist wirklich für benutzereingaben gedacht, am logischen fokus hängt wesentlich mehr, als einfache eingaben...

du kannst mit behaviours arbeiten, bietet sich in manchen fällen an...wenn du einfach nur auf tastendruck innerhalb eines controls arbeiten willst, kannst du auch commandbindings verwenden...(bubbling/tunneling), je nach dem wie komplex dein ui-aufbau ist.

events zu abonnieren ist immer etwas "risky" ... events sind, wenn man nicht damit aufpasst, sehr schwer zu debuggen, da man mit denen ganz leicht einen zirkulären aufruf erzeugen kann, für die man wiederrum einen hack braucht um sie zu umgehen.

Du könntest, es wäre aber wesentlich leichter die Höhe des Controls so einzustellen, dass du keine "halbsichtbaren" elemente hast...

Versuchs mal mit Public 😉 Natürlich unter der Voraussetzung dass du entweder die Assembly korrekt referenziert hast oder die Klasse in der selben Assembly liegt wie dein MainWindow

Hallo, was willst du denn mit den Key-Downs bezwecken ?

Hallihallo, das mit dem Repeat hab ich offensichtlich überlesen 😉 mea culpa

Das wird so nicht funktionieren, die Eigenschaft gegen die du reflektierst, ist vom Typ Type und entsprechend wirst du nur Eigschaften der Klasse Type bekommen.

Dafür gibt es Generics, die werden aber von WPF nicht wirklich unterstützt...leider...Ich vermisse es auch manchmal.

Hallo,

des Rätsels Lösung ist einfach .... ein Klick ist ein Klick ... das bedeutet runter und wieder rauf...du wirst bei einem Click-Event niemals ein MouseUp oder ähnliches erhalten, da dieser schon passiert ist.

MouseDown event suchen, Zeitstempel speichern und dann kannst du im MouseUp die differenzzeit zwischen mousedown und mouseup verwenden. Zumal dein Ansatz, es in einer Funktion synchron zum UI-Thread zu verarbeiten eh nicht funktionieren wird, du müsstest die Zeitprüfung in einen Task/Thread auslagern.

Hallöchen,

warum so kompliziert. Für 2 Leute die vorher keine Versionsverwaltung verwendet haben - muss auf der anderen Seite ja genauso sein, sonst würde die Frage nicht aufkommen - braucht man keine umfangreiche Lösung, nur um seine Quellcodes zu sichern.

VisualSVN Server und AnkSVN reichen da vollkommen aus und die Installation und Bedienung sind nicht unbedingt Stoff für eine Doktorarbeit und der Zeitaufwand ist relativ gering für die Einrichtung.

Ich kann dir nur raten dir das einfach mal zu installieren und auszuprobieren. Die TFS VS-Integration kostet ziemlich viel Resourcen, macht das VS unterm Strich langsamer...biete dagegen einige nette Features mehr, die man im SVN ne Weile suchen muss oder gar nicht hat, ein bisschen Neugierde hat noch niemandem geschadet 😉

Nur solltet ihr immer n Backup machen, egal welche Versionsverwaltung ihr verwendet, irgendwann geht alles mal kaputt...

vg

Hallo,
es gibt in Wpf auch ein DataGridView...ist nur in nem ListView versteckt.

Aber das Thema Binding ist wirklich elementar was wpf angeht, dort arbeitet man normalerweise nicht mit den steuerelementen, sondern überträge daten vom Steuerlement zum ViewModel und wieder zurück. Dann musst du nicht parallel mit zwei Objekthierarchien arbeiten, sondern nur mit deinem Viewmodel. Das spart dir viel dusselige Arbeit(a=a' oder so ähnlich).

Beispiele findest du zu diesem Thema genug.

vg

Hallo,

die Appsettings werden normalerweise automatisch mit dem Programmstart geladen, wenn du die Datenbankeinstellungen zentral ablegen willst, musst du dir 'ne alternative Lösung ausdenken, eine Datei auf einem Netzwerkpfad wäre sehr einfache Option.

Geht natürlich auch komplizierter 😃 Je nach Geschmack und Anforderung

Hallo,

ich war mal neugierig und bin wahrscheinlich über selben Fehler gestolpert.

Bei der Auswahl der Sprache, wenn man irgend eine Eingabe macht, die nicht in der Liste der Sprachen verfügbar ist, wird dein Watermarktext nicht versteckt.

Also Trigger anpassen.

vg

Hallo,

versuchs mal damit :http://www.c-sharpcorner.com/UploadFile/mahesh/wpf-richtextbox/

Das musst du nicht selbst machen, das gibts schon im WPF

Hallo,

jedes UI-Element hat sein eigenes Koordinatensystem das bei 0,0 anfängt, die Koordinaten eines UI-Elements sind immer relativ zu seinem parent.

Hallo,

http unterstützt glaub keine größeren pakete, dafür müsstest du entsprechend andere protokolle verwenden...net.tcp könnte dir helfen und ist schneller.

Hallo,

die entitäten direkt an die ansicht weiter zu geben, bringt einige schwierigkeiten mit sich, wenn es um anzeigen geht. ich verwende für solche fälle eine einfache wrapper-klasse, welches mein datenobjekt und einige eigenschaften enthält, die ich an die entsprechenden controls binden kann, damit habe ich die möglichkeit bestimmte verhaltensweisen zu steuern ... zb IsSelected oder ähnliches.

die manipulation des treeview-controls aus dem code behind ist sehr stark eingeschränkt, da wpf auf einer andere technischen idee basiert, als winforms, die alternative ist du verwendest entsprechend trigger in deinem datatemplate.

Hast du das in deiner AssemblyInfo.cs drin ?

[assembly:ThemeInfo(
    ResourceDictionaryLocation.None, //Speicherort der designspezifischen Ressourcenwörterbücher
                             //(wird verwendet, wenn eine Ressource auf der Seite 
                             // oder in den Anwendungsressourcen-Wörterbüchern nicht gefunden werden kann.)
    ResourceDictionaryLocation.SourceAssembly //Speicherort des generischen Ressourcenwörterbuchs
                                      //(wird verwendet, wenn eine Ressource auf der Seite, in der Anwendung oder einem 
                                      // designspezifischen Ressourcenwörterbuch nicht gefunden werden kann.)
)]

Hallo,

also erstmal die Lösung deines Problems :

0x0-F sind Hexadezimalwerte...wenn du Flags definieren möchtest und nicht die Zahlenwerte der entsprechenden Bitmuster reinklamüsern möchtest benutze die folgende Schreibweise:

public enum FlagEnum
{
    None = 0,

    Flag1 = 1 << 0,

    Flag2 = 1 << 1,

    Flag3 = 1 << 2,

    Flag4 = 1 << 3,
}

1 << 0 = 0
1 << 1 = 1
1 << 2 = 2
1 << 3 = 4

Das sagt: verschiebe das 1. bit (Wert 1 ist immer bit 1 gesetzt alle anderen 0) um n stellen nach links...findest du im internet unter dem Begriff: bit-shift. wichtig ist das nicht >> verwendet wird...das geht nur auf prozessoren die das intel-byte format verwenden...apple macht es glaub ich anders rum.

Abfragen kannst du das ganze mit Enum.HasFlag(...)

Das Flags - Attribut benötigst du dafür nicht, das hat einen anderen Zweck.

Aber wie schon oben geschrieben wurde, ist ein Rechtesystem damit doch sehr eingeschränkt, du wirst merken das 64 bit zu wenig sind -mehr kannst du momentan nicht adressieren, jedenfalls nicht mit den Handelsüblichen prozessoren und compilern. Für einfache Anwendungsfälle, wo es nicht mehr als 64 Rechte gibt kann man sowas als Tüftellösung verwenden. Für größere Sachen finden sich bessere Lösungen. Es ist auf jeden Fall die perfomanteste aller Lösungen, da bit-operationen die schnellsten operationen auf deinem Prozessor sind - schneller gehts also nicht mehr 😉

vg

Auf der Seite wpftutorials.net findest du ansätze dafür, falls du das noch nicht kennst, dort stehen viele grundlagen fürs wpf drin.

das thema ist wie gesagt sehr komplex, ich hab auch ne weile gebraucht und ne anleitung von a-z wirst du wahrscheinlich nicht finden, sonst hätte ich dir nen link gegeben.

Hallo,

theming ist ein recht komplexes thema, das du nicht so einfach lösen kannst. du wirst eine klasse benötigen, die deine themenauswahl entsprechend in einen dateinamen umwandelt und das xaml/baml lädt. der schlüssel zum ganzen dabei sind die richtigen x:key-werte für die styles...das ist ein ganz schönes gewusel.

ich würde dir raten, um dich in das thema einzuarbeiten, ein einfaches projekt zu suchen, dafür gibts sicherlich viele beispiele. versuch dabei solche zu finden die keine hacks verwenden...davon gibts auf codeplex und co genug...

Das mag sein, aber mal ganz abgesehen davon dass ich nicht behauptet habe, dass man das nicht testen kann...macht es meines erachtens gar keinen Sinn nen Farbwert zu testen oder eine Schriftgröße oder sonst irgendwas in der Richtung. Soviel zu deiner kindisch provokanten Formulierung. Einmal ein Buch gelesen, schon ein Experte 😉

Mein Hauptargument war eher die Ausartung des Code, die sowas mit sich bringt. Ein schönes Beispiel wäre die Sichtbarkeit von Objekten, abhängig von bestimmten Zuständen deines ViewModels. Natürlich kannst du das in ein vm packen, aber ich finde es persönlich extrem nervig, Code zu warten, der über mehrere Funktionen verteilt einen UI-Wert setzt, das ist einfach schwer nachzuvollziehen. Hingegen bist du mit Triggern gezwungen, solche Zustände über Eigenschaften entsprechend zu ermitteln. Das ist wesentlich einfacher nachzuvollziehen und vor allem sauberer.

Ich weiß nicht wie stark deine Tests ausformuliert sind, aber ich würde nicht auf die Idee kommen, Farben oder Schriftgrößen zu testen, ich kenn ehrlich gesagt auch niemanden der das macht...mir ist die Funktionalität einer Anwendung wichtiger als das Aussehen.

Nicht immer arbeiten Entwickler und Designer im selben Büro, geschweige denn im selben Raum oder sind ein und dieselbe Person. Bei Miniprojekten von ein paar tausend Zeilen Code ist das alles noch überschaubar, das sieht bei 10 Leuten schon ganz anders aus.

Ein ViewModel ist natürlich auch ein Model...nur nicht für dein BL...daraus ergibt sich folgendes :
View+VM != UI weil View = UI...oder hat dein ViewModel n Knopf zum draufdrücken.

10 Leute ... 10 Meinungen ... und jeder weiß es besser als der andere...meine muss ja nicht richtig sein. also nen schönen tag noch.

Hallöchen,

einen Konverter zu verwenden ist der richtigere Weg. Ui-Werte haben in einem Viewmodel eigentlich nix zu suchen, da man damit die Trennung von Oberfläche und Funktionaltität durchbricht.

Der Grund für eine Trennung von View und Model ist recht einfach erklärt : Testbarkeit. In einem Viewmodel definierst du, was mit Benutzerinteraktionen passieren sollen, also wie sich ein System durch eine Benutzereingabe verhält. Zb:

Du hast ein Eingabefeld, dass bei bestimmten Werten unterschiedliche Verhaltensweisen hat. Über einen Integrations/Unittest kannst du das Viewmodel testen ohne selbst einen Finger krumm zu machen. Dadurch ist es dir möglich, die funktionale Lauffähigkeit eines System zu stärken oder anders ausgedrückt, ein sichereres Gefühl bei Änderungen zu bekommen. Durch diese Tests ist, je nach Vollständigkeit, garantiert, dass du nicht ausversehen einen unerwünschten Seiteneffekt erzeugst.

Ich habe grundsätzlich alles im XAML was das GUI betrifft. Gerade solche Sachen wie Fonts, Farben, Sichtbarkeit und Größen lassen sich sehr gut über Trigger/Converter/Styles lösen. Denn das Resultat bei Komplexen ViewModels wäre:10 Methoden ändern 20 Properties die nur die UI betreffen und jeder gibt seinen Senf dazu. Das im späteren Projektverlauf bei neuen Anforderungen ohne irgendwelche unerwünschten Verhaltensweisen zu Ändern...dürfte spannend sein, also so gut wie unmöglich. Code wird nicht nur einmal geschrieben, sondern immer wieder angepasst und Fehler suchen ist ne unschöne Aufgabe, die Zeit kostet.

Am Ende ist es dir überlassen, wie du damit umgehst, 10 Leute ... 10 Meinungen.

vg

Hallo,

stell beim Anwendungsstart einfach dein CurrentCulture um...dann ist dein Problem gelöst. Die ist standardmäßig nicht de-de.

Hallo,

du kannst dir das manuelle laden von Xml-Dateien sparen, wenn du die Serialisierung verwendest.

Dann hast du nachher 1 Zeile Code für den Ladeaufruf und ein entsprechendes Klassemodell für den Inhalt der Xml-Datei.

vg

Holla,

also ich muss mal raten, weil aus deiner Fragestellung heraus vermute ich dass du dein memento testen möchtest ? Oder gehts dir nu um die reihenfolge?

Wenn du nen UnitTest für dein event invoke schreibst, wird nix passieren...der/die/das/the event wird zwar ausgelöst, aber hat keine abonnenten, die bekommst du erst beim Binding...mich wunderts wozu du da ne Reihenfolge brauchst, da kannst du nur Trace .WriteLine machen...jedenfalls wär alles andere sinnfrei.

Falls dein Code auf ner Reihenfolge deiner Property-Setter basiert 😃 solltest du ggf mal deinen Code refaktorieren...du kannst später schlecht vorschreiben Property A vor Property B...hält sich kein Mensch dran und man selbst denkt 2 Wochen später auch nicht mehr dran - ist auch ganz uncool, wenn du mit reflection arbeitst oder komponenten benutzt, die mit reflection arbeiten...

vg

Hallo,

du kannst das mit ner ViewBox lösen. Mach die als Container um deinen Eigentlichen Button.Content

vg

Vielleicht mal anders ausgedrückt:

Assembly A - Typ A

Assembly B - Typ B

Container enthält deine geladenen Typen (plugins, etc)

public class A 
{
   public class A()
   {
       B  = Container.Get<B>();
   }
   public B {get;set;}
}

B = Container.Get<B>(); <<--- B existiert nicht weil B noch nicht geladen wurde, also der Typ unbekannt ist, auch wenn du dort interfaces dran machst, kann das interface nur ein Schlüssel sein um an B zu kommen, nicht aber B selbst...kausalität...anders ausgedrückt: geht nicht, weil ist nicht da.

Nun kannst du die Reihenfolge deiner Assemblies in der Konfig ändern, aber das funktioniert auch nur eine Weile, bis irgendwas gemacht werden soll, wo die Reihenfolge nicht mehr reicht.

Es wird immer eine Komponente geben, die andere verwendet, im schlimmsten Fall über Kreuz, das tut nicht weh und sollte auch funktionieren(solange man in der selben "Architektur-Schicht" ist)

Das Laden von Assemblies und Typen ist leicht, die untereinander zu verbinden, eine andere Geschichte, wie gesagt, der Teufel liegt im Detail.

Jups, so isses richtig, nur was machst du wenn einer deiner Typen einen andere verwendet ?

Also Typ A wird instanziert und verwendet Typ B ... dann hast du erstmal ein Problem. Es ist ratsam den Activator in eine Klasse zu kapseln und erst beim Zugriff zu instanzieren.

Ah ich hatte vermutet, dass du die referenziert fest eingebunden hast. ich hab schon ein wenig erfahrung in der entwicklung von IOC-Framework-Sachen, die Grundidee ist einfach, aber der Teufel steckt wirklich im Detail, irgendwann musst du mal deine Typen Instanzieren, dann möchtest du verschiedene Instanzierung-Verhaltensweisen, dann Injection, dann noch ein paar delegaten beim instanzieren ausführen...hach da bist ne weile mit beschäftigt 😉 Ist ganz interessant sowas als Forschungsprojekt zu machen, aber wenns eilig ist, sollte man das nicht tun, Die MS - Doku ist ... lückenhaft 😉

Du bringst mich damit auf eine Idee: Theoretisch könnte ich den Workspace selbst zusammen mit allem anderen auch in einem eigenen Konstrukt speichern. Ein neues Objekt quasi. Dann könnte ich die Bindung entsprechend deiner Kritik in nur eine Richtung ausprägen. Dadurch hätte ich konzeptionell aber sicher noch einiges zu tun...

Hier hast du nen Keks 😉 So könnte man es ausversehen machen...wenn du es jetzt noch schaffst kein "new ()" für deine ganzen einstiegsobjekte zu verwenden (das macht das IOC Framework für dich), bist du schon auf nem guten weg.

Hallo,

für "Undo" gibt es mehrere Möglichkeiten, die einfachste ist : Klonen...klone das Objekt deiner Begierde und übertrage bei einem OK alle Werte in dein original, ist leichter als sich alle Änderungen zu merken. Memento ist interessant, wenn du das für deine Anzeige verwenden möchtest. Ich hätte es eher so verwendet, nach einem Restore die Viewmodels neu zu bauen - falls du welche für deine Models hast - oder die Modelreferenzen neu zu setzen, da sie im endeffekt komplett ungültig geworden sind.

Das mit dem Leerstring ist etwas fragil, dürfte nur Eigenschaften betreffen die gebunden sind und nicht als OneTime-Binding deklariert wurden, alles andere kann ich mir nur schwer vorstellen.

Für die Reihenfolgefrage gibt meiner Meinung nach nur 2 Optionen : Reihenfolge in deiner Klasse - weil : reflection, oder Reihenfolge des Binding im xaml...ich tippe mal auf die 2.

Das Xaml-binding baut intern eine Liste von Binding-informationen auf, ich vermute mal das diese liste dann abgearbeitet wird.

vg

Holla,

da du irgendwo View und ViewModel verbinden musst, ist eine Plugin-Assembly schon die richtige Stelle. Ein Plugin ist sowas wie eine zusätzliche "void main" methode, in der du zusätzliche Daten und Funktionen bereit stellen kannst.

Hier ein paar kleine Hinweise, wenn du das etwas ausbauen möchtest:

Zum einen, wenn du Plugins verwenden möchtest, mach plugins draus 😉 Wenn du referenzierst, hast du kein Plugin mehr. Dafür gibt es IOC-Frameworks. Die sind etwas gewöhnungsbedürftig, aber machen eine Anwendung enorm flexibel...besser n Framework verwenden, als selbst zu schreiben, ausser du hast ein paar wochen Zeit...autofac lässt sich sehr einfach verwenden.

Vermeide solche Konstrukte:

viewModel.Plugin = this;

Ist einfacher nur eine Richtung,und zwar von oben nach unten, zu verwalten. Du kannst mit dem IOC-Framework auch vorhandene Instanzen an einer beliebigen Stelle abgreifen - alternativ einen ServiceLocator verwenden...->ServiceLocator.Get<IMyPlugin>()...oder ObjectFactory.Get<IMyPlugin> ... solche Aufrufe sind wesentlich einfacher, als Instanzen quer durch die Anwendung weiter zu reichen.

Man muss ein wenig Erfahrung mit sowas sammeln, aber ist alles kein Hexenwerk.

Wenn du das richtig zusammenschusterst, hast du am Ende eine Exe ohne Inhalt die aus einer Konfiguration den Inhalt zusammenstellt...

vg

Guten Morgen,

ich würde dir raten dich mal in Attached-Properties einzulesen, besser noch Behaviors. Der Weg den du da momentan verfolgst wird dich nicht oder nur schwer zum Ziel führen.

Du kannst alle UI-Komponenten erweitern ohne das eigenliche Control zu erben, ähnlich den Extensions. Die Mechanismen basieren auf dem Decorator-Pattern...sozusagen Grundlagenwissen, wenn man mit WPF effektiv arbeiten möchte.

Einer der markantesten Unterschiede von Winforms und WPF ist die Architektur der Komponentenkommunikation. Diese ist bei Winforms direkt, bei WPF wesentlich indirekter. Dadurch wird das Konstrukt zwar schwerer zu verstehen, bietet aber sehr große Vorteile bei der Entwicklung.

Hallo,

hast es fast richtig gemacht, in deine Betrachtung fehlt jedoch ein wichtiges Detail...

Das Listviewitem ist ein eigenes steuerelement, genauso wie das was dein Datatemplate darstellt. Verwende den Trigger an deiner Textbox, dann gehts. Dein blauer streifen, kommt von der selektions-hintergrundfarbe deines listviewitems, setz das auf transparent, dann siehst du nur noch die textbox und deinen rahmen um die textbox, wenn der trigger richtig gesetzt ist.

vg

TypeActivator ist leichter zu verwenden, wenn du eine instanz von einem typen erstellen möchtest..versucht das mal.

vermutlich liegt das an deinen flags

BindingFlags.Instance | BindingFlags.Public

dürfte nicht genug sein.

vg

Hallo,

es gibt auch die No-Sql-Datenbanken, die sind für sowas wesentlich einfacher, da du keine große Arbeit mit der Administration hast und keine Tabellen modellieren musst.

Ich verwende gerade MongoDB, ist komplett kostenfrei und es gibt .net Komponenten - also nen Mapper...

vg

Hallo,

ich habs mir mal angeschaut, gibt nun 2 gute möglichkeiten die du machen kannst...beide dürften funktionieren:

1. Du leitest dir ein eigenes VirtualizingStackPanel ab und stellst dir ne Methode zur verfügung die dein Item Selektiert - über index oder objekt

2. Lade deine Knoten nur dann wenn du sie aufklappst, du hast das expanded in deinem ViewModel, da kannst du im Setter die Children aufbauen, wenn sie noch nicht vorhanden sind. Da kannst du die Virtualisierung ausschalten und hast nur das im Memory was dich interessiert. Ist eigentlich ne üblichere Vorgehensweise um Resourcenschonender zu arbeiten.

Da du bei der Virtualisierung erst das Treeviewitem bekommst, wenn es da ist, bringt das Behaviour tatsächlich wenig...wenns nicht da ist, kannst du es nicht anzeigen. Könntest auch nen Event verwenden der am VM hängt, dass beim Selektieren übers ViewModel auslöst und dann über den ItemsContainerGenerator vom Treeview den Visualizer holst und dann BringIntoView() aufrufst. Da brauchst du dann aber die Ref vom VM und Tree ... Kannst mal probieren, ist aber wahrscheinlich keine so schöne lösung.

vg

Hallo,

ich hab son ding auch selbst gebaut, ist recht einfach.

Was du brauchst :

1. Eine komponente die für ein ViewModel eine View ermittelt ... wie immer du das auch zusammen bringst

2. ContentPresenter für die View

3. Einen Mechanismus zum setzen deines aktuellen ViewModels (ich habs mitm command gemacht)

4. Das ViewModel bindest du an den DataContext des ContentPresenters

5. Hier kommt das Hexenwerk an der Geschichte : deine View-ViewModel-Komponente muss beim Konfigurieren ein DataTemplate anlegen, mit deiner View als Inhalt und deinem ViewModel als TargetType...die packst du dann in das globale Resource - Dictionary deiner Applikation. Das ganze geht nur per Code-Behind, musst also für jede View-ViewModel-Relation ein DataTemplate dynamisch erzeugen und der Anwendung als Resource zur Verfügung stellen.

Sobald der DataContext des Presenters einen Wert bekommt, wird automatisch ein vorhandenes DataTemplate für den Typen deines ViewModels gesucht...das reicht für 90% aller Anwendungsfälle aus.

Ich zitier mich mal selbst 😉

Hat jemand dafür n Hook-Script zur Hand oder nen Ansatz wo ich mich dran hängen muss?

CruiseControl

Achso, ich such eigentlich sowas wie beim TFS, da kann man das einstellen, dass der lokale Build erfolgreich sein muss, damit man überhaupt einchecken kann.

Hallo,

ich wollt mal dezent in die Runde fragen, ob jemand weiß, was ich anstellen muss, damit ich meine schusselige Entwicklerbande dazu zwinge vor dem Checkin zu bauen.

Hat jemand dafür n Hook-Script zur Hand oder nen Ansatz wo ich mich dran hängen muss?

vg

PS : ICH FINDE SVN SUPER********TOLL

Guten Morgen,

wenns manchmal geht und manchmal nicht ... ist es meist ein synchronisationsproblem, da ui in wpf über einen eigenen Thread läuft.

ich muss mal doof raten aber ich vermute du hast irgendwas in deinem code, dass sagen wir mal, zum falschen Zeitpunkt aufgerufen wird.

ohne code wird das nix 😉

vg

Huhu,
versuch mal dein Layouting im Xaml zu machen ... sonst brauchst du kein WPF...

Wie ich schon schrieb : binde das selecteditem an dein viewmodel.selecteditem ... setze es und verwende ein behaviour das auf die selektion reagiert, ist wesentlich mehr aufwand als in winforms, dafür kannst du aber hübschere bilder malen 😉 Geht leider nicht alles einfach.

Mehr technischer Schnick-Schnack ist meist auch mit mehr Aufwand verbunden.

Ich wiedersprechen meinem Vorposter mal, natürlich geht es...

                var result= methodInfo.MakeGenericMethod(instance.GetType(), genericTypeArg).Invoke(null/*instanz der klasse wenn vorhanden -> null = static methods*/, methodParameter) ;

Wenn du den Canvas als Content deines Buttons verwendest, gehts nur über fragile Ancestor-Bindings, die sind langsam und unsicher.

Es wäre leichter, wenn du die am Button verwendest und damit den Canvas beeinflusst. Von child zum parent ist wesentlich umständlicher, als anders herum.

Wenn du das wiederverwenden möchtest, lageres das ganze in einen Style für den Button aus und verwende diesen als Style-Resource.

vg

Hallo,

also die Selektion kannst du über ein Behaviour lösen, ist "relativ" unkompliziert. Es gibt ne Menge Beispiele dafür -> google.
Wenn du später die Nodes aus dem Code selektieren willst, kommst du um ein eigenes ViewModel nicht mehr rum, es gibt keine Methode für den TreeView um einen Knoten zu selektieren...

Du musst dafür das SelectedItem an dein ViewModel binden und dann im ViewModel das entsprechende Datum des Knoten setzen, dann wird auch der Knoten selbst selektiert.

vg

Du könntest auch einfach keine ControlTemplates überschreiben, dann hast du das Problem nicht, wie gesagt, dass Binding in nem ControlTemplate zu machen, ist alles andere als optimal.