Hallo

Ich habe z.B. eine Klasse MyClass mit 2 Properties:

class MyClass 
{
   public string Name {get; private set;}
   public List<T> Entries {get; private set;} //(T soll eine beliebige Klasse sein)
}

Nun will ich über Reflektion diese Klasse analysieren, d.h. ich will wissen ob ein Property eine "Auflistung" ist oder nicht. Doch leider habe ich noch keinen Weg gefunden, um dies eindeutig festzustellen...

Viele Grüße
Quaneu

So jetzt hab ich leider gleich die nächste Frage...
Ich versteh nämlich folgendes Verhalten überhaupt nicht...
Das ControlTemplate sieht nun wie folgt aus:

<ControlTemplate.Triggers>
    <Trigger Property="IsMouseOver" Value="True">
        <Trigger.EnterActions>
            <BeginStoryboard>
                <Storyboard>
                    <ColorAnimation Storyboard.TargetName="_border"
                            Storyboard.TargetProperty="Background.Color" To="Red" />
                </Storyboard>
            </BeginStoryboard>
        </Trigger.EnterActions>
        <Trigger.ExitActions>
            <BeginStoryboard>
                <Storyboard>
                    <ColorAnimation Storyboard.TargetName="_border"
                            Storyboard.TargetProperty="Background.Color" To="DarkGray" />
                </Storyboard>
            </BeginStoryboard>
        </Trigger.ExitActions>
    </Trigger>
    <Trigger Property="IsChecked" Value="True">
        <Trigger.EnterActions>
            <BeginStoryboard>
                <Storyboard>
                    <ColorAnimation Storyboard.TargetName="_border"
                            Storyboard.TargetProperty="Background.Color" To="Yellow" />
                </Storyboard>
            </BeginStoryboard>
        </Trigger.EnterActions>
        <Trigger.ExitActions>
            <BeginStoryboard>
                <Storyboard>
                    <ColorAnimation Storyboard.TargetName="_border"
                            Storyboard.TargetProperty="Background.Color" To="DarkGray" />
                </Storyboard>
            </BeginStoryboard>
        </Trigger.ExitActions>
    </Trigger>

Also ich würde gern folgendes haben bei IsMouseOver und IsChecked soll der Hintergrund "Yellow" sein. Ist nur IsMouseOver dann "Red". Bei keinem von beiden, dann "DarkGray".

Bei dem ControlTemplate von oben funktioniert dies leider nicht wie gewünscht. Wenn ich die Maus über einen RadioButton bewegen wird er "Red"und wenn ich ihn verlasse wieder "DrakGray". Wenn ich einen anklicke, wird er "Yellow". Soweit so so gut. Doch wenn ich nun die Maus über einen RadioButton der schon mal angeklickt war bewege, dann bleibt dieser "DarkGray". Und dies verstehe ich gar nicht...

Was mache ich denn falsch?

Viele Grüße
Quaneu

Vielen Dank für eure Hilfe.

Dann werde ich wieder auf die Trigger zurückgreifen, da ich nicht vorhabe die Anwendung auch in SL laufen zu lassen.

Viele Grüße
Quaneu

Mir gefällt an diesem Weg nicht, dass man noch eine "Liste" hat die man verwalten muss und mit den anderen synchronisieren muss. Aber ich werd´s jetzt erst mal so machen.

Vielen Dank für Deine Hilfe

Grüße
Quaneu

Hi,
so jetzt habe ich gleich noch eine Frage.

Ich habe ein DataGrid und will die Datasource an zwei Listen binden. Ist dies möglich oder muss ich in meinem VM die beiden Listen zu einer zusammenfassen (was mir persönlich nicht gefallen würde)?

Viele Grüße
Quaneu

Hallo,
ich hätte eine Frage bzgl. VisualStates in WPF. Ich habe ein ControlTemplate, das wie folgt definiert ist:

<ControlTemplate TargetType="{x:Type RadioButton}">
   <Border>
      <ContentPresenter />
      <VisualStateManager.VisualStateGroups>
         <VisualStateGroup x:Name="CommonStates">
            <VisualState x:Name="MouseOver">
               <Storyboard>
                  <ColorAnimation Storyboard.TargetProperty="Background.Color" To="Red" />
               </Storyboard>
            </VisualState>
            <VisualState x:Name="Normal" />
            <VisualState x:Name="Pressed" />
            <VisualState x:Name="Disabled" />
         </VisualStateGroup>

         <VisualStateGroup x:Name="CheckStates">
             <VisualState x:Name="Checked">
               <Storyboard>
                  <ColorAnimation Storyboard.TargetProperty="Background.Color" To="Yellow" />
               </Storyboard>
            </VisualState>
            <VisualState x:Name="Unchecked" />
            <VisualState x:Name="Indeterminate" />
         </VisualStateGroup>
      </VisualStateManager.VisualStateGroups>
   </Border>
</ControlTemplate>

Ich habe nun folgendes Problem, wenn ich mit der Maus über den selektierten RadioButton fahre, wird dieser gelb. Doch wenn ich mit der Maus den RadioButton wieder "verlasse", wird dieser nicht mehr rot. Dies müsste er aber wieder werden, da der RadioButton ja selektiert ist.

Wie kann man mit VisualState dies bewerkstelligen?

Viele Grüße
Quaneu

Vielen Dank für deine schnelle Antwort.

Dann haben sich meine schlimmsten Befürchtungen bewahrheitet...
Das heißt, ich muss mir ein eigens Custom Control bauen, mit dem ich meine Wünsche realisieren kann.

Hallo,

ich hätte mal eine frage bezüglich eines TabControls. Ich würde gern die Reiter auf der linken, sowie auf der rechten Seite haben. Über TabStripPlacement ist dies ja leider nicht möglich.
Daher denke ich, dass mir nichts anderes übrig bleibt, als den Style zu überschreiben. Doch wie kann ich dann meinen Reitern sagen, wo sie hingehören?
Müsste ja dann so ähnlich gehen wie bei einem DockPanel.

Viele Grüße
Quaneu

Danke für den Link.

Also ich hab mir vorgenommen, ein Programm zu schreiben, dass nach Methoden sucht, die nicht mehr "gebraucht" werden, um diese dann zu entfernen.
Da wird es sicher schon einiges dafür geben (wahrscheinlich sogar in der Ultimate Version), aber ich mach dass einfach weil programmieren Spass macht und ich so auch wieder was dazu lernen kann.

Viele Grüße
Quaneu

Vielen Dank für eure schnellen Antworten. Dann werde ich mich selbst auf die Suche begeben.

Viele Grüße
Quaneu

Hallo,

ich versuche mich gerade ein bisschen an Regex und scheitere leider schon bei meinem ersten Problem. Ich will ein kleines Programm (in c#) schreiben dass cs-Dateien nach bestimmten Mustern durchsuchen soll. Dazu wollte ich zuerst den namspace Block ermitteln

...
namespace ABC.D
{
...
}
...

Doch ich weiß einfach nicht wie man dafür einen Regex schreiben kann.
Mein Problem liegt an den geschweiften Klammern, denn in dem namespace gibt es sicher auch wieder geschweiften Klammern die auf und wieder zu gehen. Daher scheitern all meine Ansätze. Gibt es hierfür überhaupt eine Möglichkeit einen Regex zu schreiben?

Viele Grüße
Quaneu

Das würde ich schon viel eher verstehen, als meine "Vermutung". Danke nochmals für den Hinweis.

Entschuldige bitte meine späte Antwort, aber bin leider erst jetzt wieder zum Schreiben gekommen.
Das scheint wunderbar zu klappen. Vielen Dank für deinen Hinweis. Dann heißt dies aber, dass der Background der Zellen alle anderen "überschreibt", also die der Row...

Viele Grüße
Quaneu

Ich habe jetzt noch ein bisschen rumprobiert, doch leider ist die Verwirrung nun noch größer.
ich benutzt zusätzlich einen Style für die DataGridCells.
Dieser sieht wie folgt aus:

    <Style x:Key="CellStyle" TargetType="{x:Type DataGridCell}">
        <Setter Property="Height" Value="24" />
        <Setter Property="BorderThickness" Value="0" />
        <Setter Property="Foreground" Value="Black" />
        <Style.Triggers>

            <Trigger Property="IsSelected" Value="True">
                <Setter Property="Background" Value="Green" />
            </Trigger>
            <Trigger Property="IsMouseOver" Value="True">
                <Setter Property="Background" Value="Yellow" />
            </Trigger>

        </Style.Triggers>
    </Style>

Der Trigger für IsSelected funktioniert "fehlerfrei". Doch der für IsMouseOver reagiert nicht wie erwartet.
Dazu sei gesagt, dass ich bei dem DataGrid SelectionUnit="FullRow" und SelectionMode="Single" gesetzt ist.
Bei IsSelected wird nun die ganze Zeile grün, doch bei IsMouseOver nur die jeweilige Zelle.

Warum ist hier ein unterschied und wie schaffe ich es, dass immer die ganze Zeile gefärbt wird?

Viele Grüße
Quaneu

Hi,
ich hätte mal eine Frage bezüglich dem Style für DataGridRow.

Ich will bei MouseOver die Farbe auf z.b. Gelb ändern (was kein Problem darstellt) und bei MouseOver und bei Selected die Farbe auf Grün ändern. Doch bei dem zweiten Fall komme ich einfach nicht weiter...

Hier mal mein "Versuch":

    <Style x:Key="DataGridRowStyle" TargetType="{x:Type DataGridRow}">
        <Setter Property="BorderBrush" Value="Black" />
        <Setter Property="SnapsToDevicePixels" Value="true" />
        <Setter Property="Validation.ErrorTemplate" Value="{x:Null}" />
        <Style.Triggers>
            <Trigger Property="IsMouseOver" Value="True">
                <Setter Property="Background" Value="Yellow" />
            </Trigger>
            <MultiDataTrigger>
                <MultiDataTrigger.Conditions>
                    <Condition Binding="{Binding IsSelected, RelativeSource={x:Static RelativeSource.Self}}"
                            Value="True" />
                    <Condition Binding="{Binding IsMouseOver, RelativeSource={x:Static RelativeSource.Self}}"
                            Value="True" />
                </MultiDataTrigger.Conditions>
                <Setter Property="Background" Value="Green" />
            </MultiDataTrigger>
        </Style.Triggers>
    </Style>

Das Resultat ist folgendes, die Row wird Gelb, wenn ich über Zeilen bin, die nicht selektiert sind, doch bei selektierten Zeilen passiert gar nichts...
Nun meine Frage, warum?

Sorry war ein blödes Beispiel... aber ich glaube ich verstehe Dich.

Vielen vielen Dank dafür.

Aber nur um sicher zu gehen 😃
Wenn ich z.B. ein DataGrid habe und gewissen Code ausführen will, wenn sich das SelectedItem ändert, dann hast Du ein Binding an das SelectedItem und bekommst so die Änderung im Setter des Properties mit, an das Du gebunden hast?

Also bei Commands geht es ja relativ leicht, diese an die ViewModel durchzureichen bzw. dort zu "bearbeiten".
Doch mein Problem sind Events, z.B.:

<Button Click="Button_Click"/>

Doch das Event wird im Code-Behind behandelt und dies will ich nicht. Daher suche ich eine Möglichkeit Events direkt an meine ViewModels zu leiten.

Vielen Dank nochmals.

Das wollte ich schon am Anfang so machen, aber leider fand ich keinen Weg, wie ich die Klasse ermittle in dem ein Control liegt.
Z.B.
Ich bekomme ein DependencyObject (z.B. Button) und will herausfinden, wo dieser liegt. Denn damit wäre es kein Problem mehr für mich.

VG
Quaneu

Danke für Deine schnelle Antwort.
Ach so, dann hab ich schon etwas "grundsätzlich" falsch verstanden ...
Denn ich dachte einfach, dass die View die ViewModel kennat und das ViewModel das Model kennt, aber nur bezogen auf die Projekte...

Hmm... ich versuche es gerade zu verstehen. ist das dann eine Art Helper Class in der View?

Jetzt hatte ich mal wieder ein bisschen Zeit, mich mit diesem Thema zu beschäftigen und bin auf folgende Lösung gekommen (wobei ich mich hier nicht auf ein Command binde):

public static readonly DependencyProperty EventNamesProperty = DependencyProperty.RegisterAttached("EventNames", typeof(string), typeof(TestViewVM), new UIPropertyMetadata(EventNameChanged));
public static string GetEventNames(DependencyObject obj)
{
   return (string)obj.GetValue(EventNamesProperty);
}
public static void SetEventNames(DependencyObject obj, string value)
{
   obj.SetValue(EventNamesProperty, value);
}

private static void EventNameChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs args)
{
   string[] eventNames = ((args.NewValue as string).Replace(" ", "")).Split(',');
   TestViewVM temp = new TestViewVM();
   MethodInfo methodInfo;
   EventInfo eventInfo;

   foreach (string eventName in eventNames)
   {
      eventInfo = dependencyObject.GetType().GetEvent(eventName.Trim());
      methodInfo = temp.GetType().GetMethod(eventName, BindingFlags.NonPublic | BindingFlags.Instance);
      eventInfo.AddEventHandler(dependencyObject, Delegate.CreateDelegate(eventInfo.EventHandlerType, temp , methodInfo));
   }
}

Will ich nun ein Event an z.B. meine TestViewVM "durchreichen, schreibe ich XAML

... :EventNames="Click"

Und dann muss ich natürlich noch in der Klasse TestViewVM den EventHandler für ein Click-Event schreiben.

Jetzt wollt ich eigentlich nur mal eure Meinung dazu wissen, da ich auf diesem Gebiet noch nicht so viel Erfahrung habe.

Viele Grüße
Quaneu

Ok, vielen Dank für eure Hilfe.

talla: Behaviour sind ja im Prinzip nichts anderes als attached Properties

Dann schaue ich, wie ich das selbst mit attached Properties schaffe, denn das würde mir mehr zusagen. Hättest Du vielleicht auch einen Tipp für eine gute Hilfe diesbezüglich?

Grüße
Quaneu

Das dies Sprachresourcen sind, war mir schon klar. Doch ich brauch diese nicht, da ich keine Sprachunterstützung anbiete. Daher suche ich nach einer Alternative.
Oder kann ich diese einfach löschen?

Hallo,
ich bin auf der Suche nach einer Alternative zu Behaviors. Diese benutze ich derzeit um Events an mein ViewModel "weiterzuleiten". Dazu benutze ich folgende dll und xml:

Microsoft.Expression.Interactions.dll
Microsoft.Expression.Interactions.dll

Jetzt wollte ich mal wissen, ob es dazu alternativen gäbe. Da wenn ich es so mache, in meinem Debug bzw. Realse Ordner viele Ordner erstellt werden mit lauter dlls z.B. de Ordner mit System.Windows.Interactivity.resources.dll. Und das finde ich nicht sehr schön, bzw. weiß ich nicht ob man die wirklich alle braucht usw..
Weiß zufällig jemand ob man die auch wieder löschen kann oder ob es eine "schönere" Alternative gäbe?

Viele Grüße
Quaneu

@xxMUROxx:

Dies klappt soweit ganz gut, Danke dir. Doch leider wird eben bei einem Konstruktor immer der Methodenname ".ctor" angezeigt. Aber den bekomme ich ja dann über den KlassenNamen. Daher wäre dies eine Lösung. Vielen Dank dafür.

Hallo,

ich stehe gerade vor folgendem Problem:

Ich habe eine statische Klasse Logger, mit deren Hilfe ich mein LogFile erzeugen will.
Dazu biete ich drei Methoden an, für Warnings, Errors und Messages.

Beispiel:

public static void WriteMessage(object sender, message)
{
...
}

Mein Wunsch wäre es jetzt über den sender mitzuteilen, in welcher Methode (Namespace und Class) WriteMessage aufgerufen wurde. Doch nur wie...

StackTrace habe ich schon verwendet, doch leider liefert der nicht immer was anständiges zurück (z.B. bei einem Konstruktor) und leider bekomme ich damit die Klasse und den Namespace nicht raus.

Daher meine Frage wie bekomme ich diese Informationen (ich will dies nicht über "strings" lösen, also einfach per drei strings die Informationen übergeben)

Vielen Dank schon mal und viele Grüße

Quaneu

Vielen vielen Dank für deine Hilfe.

Hab es nun mit PropertyChangedCallback gelöst und es klappt wunderbar. Werde mir das Kapitel gleich nochmal durchlesen, damit mir so etwas nicht mehr passiert. Hat mich die halbe Nacht gekostet...

Also nochmals vielen Dank.

Gruß
Quaneu

Danke für deinen Hinweis.

Das Buch liegt gerade vor mir 😃

Was ich nicht verstehe, ist wieso ich in dem set lande, wenn ich im Code myDataGrid.IsModified = true setze.

Aber ich werde es jetzt mal mit CoerceValueCallback versuchen.

Grüße
Quaneu

Hallo,
ich weiß jetzt nicht so recht wie ich mein Problem beschreiben soll, daher gleich mal ein Beispiel:

Ich habe mein "eigenes" DataGrid:

public partial class MyDataGrid : DataGrid
{
private static readonly DependencyProperty IsModifiedProperty = DependencyProperty.Register("IsModified", typeof(bool), typeof(MyDataGrid ));

public MyDataGrid()
{
  InitializeComponent();
  DataContext = this;
}
public bool IsModified
{
   get { return (bool)GetValue(IsModifiedProperty ); }
   set
   {
      Focusable = !value;
      IsHitTestVisible = !value;
      SetValue(IsModifiedProperty , value);
    }
}

Ein Ausschnitt aus XAML (in der das Property benutzt wird)

<MultiDataTrigger>
   <MultiDataTrigger.Conditions>
      <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="True"/>
      <Condition Binding="{Binding IsModified, RelativeSource={RelativeSource AncestorType={x:Type local:MyDataGrid }}}" Value="True"/>                        
   </MultiDataTrigger.Conditions>
            <Setter Property="Background" Value="Red" TargetName="DGR_Border"/>
            <Setter Property="BorderBrush" Value="Blue" TargetName="DGR_Border"/>
</MultiDataTrigger>

Soweit so gut... nun benutzt ich ich in einem UserControl mein MyDataGird wie folgt:

<local:MyDataGird IsModified="{Binding ElementName=_view, Path=Modified, Mode=TwoWay}"/>

Das Problem ist, dass ich niemals in dem set von IsModified lande, er aber den Background und BorderBrush auf Red und Blue umstellt. D.h. aber für mich, dass er IsModifiedauf true gesetzt hat.
ABER wieso komme ich niemals in das set? (Wenn ich es im Code mache, dann komme ich in den set...)

Ich verstehe die Welt nimmer...

Grüße
Quaneu

Und nochmals vielen vielen Dank. Da werd ich wohl ein bisserl brauchen bis ich ihn verstehe. Aber danke für den erneuten Hinweis.

Vielen Dank für deinen Hinweis und den ContextMenuItem.
Werd ich mir gleich mal anschaunen.

Jetzt wird mir alles klar und ich war schon kurz davor meinen Rechner vor die Tür zu setzen....

Halllo,

ich habe schon seid dem WE an folgendes Problem (hab nur das nötigste, also bitte nicht wundern):

<Grid x:Class="UI.Search"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:local="clr-namespace:UI">

    </local:MyStack>
        <local:MyButton>
            <local:MyTree>
                <local:MyTree.ContextMenu>
                    <ContextMenu>
                        <MenuItem Header="Search"/>
                    </ContextMenu>
                </local:MyTree.ContextMenu>
            </local:MyTree>
        </local:MyButton>
    </local:MyStack>
</Grid>

Nun will ich dem MenuItem ein Command per Binding zuweisen. In der UI.Search.cs habe ich ein Property namens ViewModel, an das ich binden will.
Ungefähr so:

Command="{Binding Path=ViewModel.SearchCommand}"

Doch ich bekomme das Binding einfach nicht hin, egal wie ich es versuche... sei es mit AncestorType mit ElementName... er kommt einfach nicht aus dem local:MyTree "raus", da er im Output schreibt, dass local:MyTree ViewModel nicht enthält.

Wie muss ich denn mein Binding gestallten, damit es geht.

Hoffe mir kann jemand helfen, da es mich echt in den Wahnsinn treibt...

Viele Grüße
Quaneu

... lesen sollte man können... entschuldigt bitte.

Jetzt ist es mir klar. Danke für eure Hilfe und vor allem eure Geduld 😃

Hm, das versteh ich ja auch alles (glaub ich zumindest), aber ich löse das doch auch aus:

private void OnNewExecute(object parameter)
{
   Units.Add(new VmUnit());
   OnPropertyChanged("Units"); //<--------------
}

Meine ViewModelBase hat das INotifyCollectionChanged implementiert:

public event PropertyChangedEventHandler PropertyChanged;

protected virtual void OnPropertyChanged(String propertyName)
{
   PropertyChangedEventHandler handler = this.PropertyChanged;
   if (handler != null)
   {
      handler(this, new PropertyChangedEventArgs(propertyName));
   }
}

Dies klappt, danke Dir. Mir war es nur ein Rätsle wieso es davor nicht geklappt hat, aber sieht echt danach aus, ob Bindingsystem schaut, ob es ein neues "Objekt" ist.

Was ich nur nicht ganz versteh, ist das die ObservableCollection auch die selbe bleibt und nur mitteilt , ich habe mich geändert.

Und eben in OnNewExecute, da rufe ich doch auch OnPropertyChanged("Units") auf.

Hallo,
und weil´s so schön ist, hab ich gleich noch ein Problem... bzw. Frage.

Also ich habe folgendes:

public List<VmUnit> Units
{
   get { return _units; }
   private set
   {
      _units = value;
      OnPropertyChanged("Units");
    }
}


private void OnNewExecute(object parameter)
{
   Units.Add(new VmUnit());
   OnPropertyChanged("Units");
}

OnNewExecute wird ausgelöst, wenn ich der Liste ein neues Element hinzufügen will. OnPropertyChanged ist für das Interface INotifyPropertyChanged. Ich habe ein DataGrid, dessen ItemSource wie folgt an Units gebunden ist:

<DataGrid ItemsSource="{Binding ElementName=_unitView, Path=ViewModel.Units, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}">
...
</DataGrid>

Doch leider wird das DataGrid niemals aktualisiert, wenn ich auf den Button klicke, der OnNewExecute auslöst.

Ich weiß, dass es die ObservableCollection gibt, die eine Benachrichtigung zu Verfügung stellen usw.. Und wenn ich diese benutzt klappt es auch, d.h. das DataGrid aktualisiert sich.

Doch warum klappt es nicht mit der "normlen" Liste und dem INotifyPropertyChanged? Denn hier müsste ich doch auch ein PropertyChanged auslösen...

Viele Grüße
Quaneu

Ich glaube, er will einfach nur das DataContextChanged ausgelöst wird.
Kannst Du es nicht einfach aufrufen (wie eine Methode)?

Ich hätte eine Möglichkeit, wobei ich nicht weiß, ob es die schönste ist:

Du könntest zuerst einen ganzen Kreis nehmen und mit Execlude (CombinedGeometry) das Stück entfernen, dass durch die zwei Winkel definiert wird.
Dazu müsstest Du Dir ein "Hilfsgeometrie" erzeugen, deren Punkte Du dir mathematisch berechnen kannst.
Dann würdest Du Teilkreise bekommen.

Viele Grüße
Quaneu

Nochmals vielen Dank für eure Antworten. Werde mich dahingehend auch mal schlau machen.

@FZelle:
Das Problem ist, dass ich das nicht wusste, da ich ganz neu auf diesem Gebiet bin und ich gerade erst am einlesen bin (WCF). Doch ich hoffe, dass dies auch bald Grundlagen für mich sind. Mich hat "nur" interessiert, wie hier der "beste" Weg ist.

Viele Grüße
Quaneu

@Rainbird:
Danke für dein Hinweis. Doch sind Datenbankzugriffe allgemein schon "langsam" und bei meinem Ansatz würde ich ständig welche ausführen.
Das kommt ganz drauf an können bis max. 100 sein (aber will mich da nicht festlegen)

@FZelle:
Da müsst eich mich erst schlau machen, welche Mechanismen es da gibt und wie diese arbeiten. Aber ich denke man kommt da nicht um Datenbankabfragen umher.

Viele Grüße
Quaneu

Hallo,

ich habe folgendes Problem und weiß einfach nicht warum dies so ist...
Ich habe eine ComboBox die wie folgt definiert ist:

<ComboBox DisplayMemberPath="ShortName" SelectedItem="{Binding ElementName=_View, Path=ViewModel.UnitClone.Dimension, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>           

Die _View ist das UserControl, indem sich die ComboBox befindet.

Wenn ich nun in der GUI den Eintrag in der ComboBox ändere wird das Binding nicht ausgelöst und ich weiß einfach nicht wieso... (ich habe das selbe Problem beim DataGrid).

Entweder ich sehe den Wald vor lauter Bäumen nicht oder ich verstehe Mode=TwoWay falsch.

Viele Grüße
Quaneu

Genau um solche Dinge zu vermeiden will ich jetzt WCF verwenden (und natürlich auch aus Gründen der Wartbarkeit usw.). Denn bis jetzt können n User gleichzeitig auf die Datenbank zugreifen und da kann es es zu Unstimmigkeiten kommen.
Daher wollte ich einen Service einrichten, der dies überwacht.
Ich dachte mir dann noch, dass ich eben schon vor einem Commit dem User irgendwie zeigen kann, dass er auf diesem Element nur Leserechte hat (siehe Excel, wenn zwei User die selbe Datei öffnen wollen), denn er macht sich die Mühe und ändern alles und stellt zum Schluss fest, dass er nicht commiten kann. Doch ich glaube dies ist nicht ohne weiteres möglich, denn da bräuchte ich wirklich bei jedem selektieren eines Elements ein Service-Aufruf.

Auch Dir vielen vielen Dank für deine Hilfe.

Bin gerade fleißig am einlesen in WCF (Services, Proxys, Clients usw. ...). Wobei ich gerade gelesen habe das ein Service Aufruf 100 bis 1000 mal langsamer ist als eine Methode (was auch klar ist) und das macht mir gerade Kopfzerbrechen... denn dann weiß ich nicht ob dies für mich geeignet ist. Da ich bei jedem anklicken in einem DataGrid so einen Aufruf bräuchte... hmmm....

Aber nochmals vielen vielen Dank.

Viele Grüße
Quaneu

Vielen dank für eure schnellen Antworten. (Ich krabbel grad aus dem Loch, in dem ich versunken bin... 😃 )

@winSharp93:
Ich denke ja. Das wichtige ist, dass der "Main-Prozess" über jede Applikation Bescheid weiß, also welche Daten sie gerade anzeigen usw.. Denn diese müssen dann gegeben falls gesperrt werden usw.

Da werde ich mich mal in diese Richtung schlau machen. Nochmals danke.

Hallo,

ich hätte mal eine ganz allgemeine Frage bezüglich claude computing (falls folgendes Szenario claude computing darstellt)

Ich würde gern eine Applikation schreiben die mehrere User "gleichzeitig" starten können, aber das eben nur ein "Main-Prozess" läuft, der über alles wacht.
Doch wie kann man dies bewerkstelligen? Es müsste ja dann mehrere Instanzen der Anwendung geben usw.
Falls jemand hier schon Erfahrungen gesammelt hat, würde ich mich sehr freuen, wenn er mir diese mitteilen könnte.

Schon mal jetzt vielen Dank
Quaneu

Ok. Schade.
Aber vielen Dank für den Link. Werd ihn mir gleich durchlesen.

Hallo,
ich versuche mich jetzt schon seid längerem mit dem MVVM und bin immer mehr davon begeistert, obwohl einem so mancher Stein in den Weg gelegt werde (MessageBox aber z.B. schon gelöst).
Nun bin ich bei Events angelangt und will diese mit Hilfe von Behavior an mein ViewModel weiterleiten ohne Code in der View.cs. Bei einer TextBox mit TextChanged klappt das schon sehr gut, doch nun will ich auf einem Grid das Event TextBoxBase.TextChanged um nicht auf allen TextBoxen ein Event zu regestrieren.

Hier mien Code:

...
<Grid>
   <i:Interaction.Triggers>
      <i:EventTrigger EventName="TextBoxBase.TextChanged">
         <ei:CallMethodAction TargetObject="{Binding Mode=OneWay, Source={StaticResource MainWindowView}}" MethodName="TextChangedMethod"/>
      </i:EventTrigger>
   </i:Interaction.Triggers>
...
</Grid>

doch dies will nicht so laufen, hat denn vielleicht jemand einen Hinweis, der mit weiterhelfen könnte?

Viele Grüße und schon mal vielen Dank
Quaneu

Das war bzw. ist die Lösung, vielen vielen Dank.

Mit Content klappt es wunderbar:

 <ContentPresenter Content="{Binding RibbonToolBar}" HorizontalAlignment="Stretch" RecognizesAccessKey="True" VerticalAlignment="Top" Margin="0,0.5,6,0" />

Vielen Dank nochmals für deine Bemühungen.

Es gibt da noch mehr "ToolBars" die man je nach dem einbinden kann (hab jetzt nur eins mit ins Beispiel, damit es klein bleibt), so kann man das OwnWindow für verschieden Zwecke benutzen.

Ich hab´s mal probiert, indem ich dem Tag die "ToolBar" zugewiesen hab und dann

<ContentPresenter ContentSource="Tag" RecognizesAccessKey="True"/>

geschrieben. Das hat wunderbar geklappt, doch finde ich diesen Weg nicht schön.

Dies habe ich schon alles probiert, doch leider klappen beide Varianten nicht.