Wie rufen Sie die Methode-in-Fenster (.xaml.cs) von viewmodel - (.cs) ohne Einführung neuer Referenzen in wpf

Ich bin auf der Suche nach eine einfache Möglichkeit zum aufrufen einer Methode in meiner Main-Fenster, aber ich möchte es nennen, die aus meiner Sicht Modell. Im Grunde bin ich auf der Suche für einige, der König ".Eltern - " Art der Sache zu stellen, die in die View-Modell-Referenz des Hauptfensters.

Oder, wenn Sie möchten, heraus zu überprüfen, der Grund, warum ich dies tun wollen und sagen Sie mir, einen anderen Weg zu gehen über mein problem:

Arbeite ich mit einer app, die ständig bekommt Informationen gefüttert. Im viewmodel werden die Informationen verarbeitet. Ich möchte, um eine Benachrichtigung jedes mal, wenn eine information kommt, die erfüllt gewisse Qualifikation.

Anfangs hatte ich ein Wörterbuch in der viewmodel, dass die gespeicherten Informationen über die Informationen, und ich aufgerufen, Wörterbuch im Hauptfenster, so dass ich könnte die Fenster, Blitz und senden weitere Meldungen. Aber ich war immer Probleme mit dem viewmodel-Wörterbuch wird kontinuierlich verändert, während ich auf es in die MainWindow.

Sorry, wenn diese Frage klingt dumm. Ich habe gerade angefangen mit WPF zwei Monaten, und habe keinen großen hintergrund in der Programmierung auch vor, dass, entweder.

Nicht, dass wenn das ganze Paradigma des MVVM? Ein view-Modell sollte nicht einmal wissen, dass die Ansicht existiert. Wie werden Sie reagieren auf Veränderungen in das Wörterbuch aus der Sicht derzeit? Könnten Sie potenziell abonnieren, um Ereignisse aus der View-Modell, wie beschrieben in dieser thread?
Danke @nekizalb , ich bin der überprüfung heraus, dass der thread jetzt

InformationsquelleAutor | 2013-11-07

  1. 28

    VM sollte "wissen" nichts von Ihrer Ansicht oder Fenster, die Art, wie VM in der Regel "kommuniziert" mit V in WPF/MVVM ist von rasing Veranstaltungen. So VM bleibt unwissend/entkoppelt von der V und da die VM schon DataContext V es ist nicht schwer, abonnieren Sie VM-Ereignis.

    Beispiel:

    VM:

    public event EventHandler<NotificationEventArgs<string>> DoSomething;
...
Notify(DoSomething, new NotificationEventArgs<string>("Message"));

    V:

    var vm = DataContext as SomeViewModel; //Get VM from view's DataContext
if (vm == null) return; //Check if conversion succeeded
vm.DoSomething += DoSomething; //Subscribe to event

private void DoSomething(object sender, NotificationEventArgs<string> e)
{
    //Code    
}
    Danke! Das scheint genau das, was ich Suche. Und es ist so einfach zu machen..ich habe nur eine Frage: Wie bekomme ich Zugang zu NotificationEventArgs? Ich habe keinen Zugriff, um es in mein Projekt jetzt. Aber wenn ich mit der Eingabe beginnen, wird die option "NotifyParentPropertyAttribute" kommt. Sind diese zwei Versionen von der gleichen Sache? Oder bin ich fehlt einen Verweis?
    Das ist ein Teil des MVVM Frameworks, die ich verwenden als Einfache MVVM Toolkit. Das MVVM-Implementierung ist viel einfacher, wenn du die frameworks wie die, die ich erwähnt oder MVVM Light. Man könnte aber schreiben Sie Ihre eigene version von NotificationEventArgs da die Unterschrift ist so einfach wie die öffentliche Klasse NotificationEventArgs : EventArgs { public NotificationEventArgs(); public NotificationEventArgs(string message); public string Message { get; protected set; } }
    Das ist perfekt. Danke @Dean. Ich werde upvote Ihre Antwort, sobald ich genug Ruf (Das war mein Erster post auf stackoverflow)
    Ich auch don ' T haben Zugriff zu Benachrichtigen :/ @Dean
    Ja, das ist alles Teil des Simple MVVM-Framework. Installieren, und es wird angezeigt. Es wird auch Ihren MVVM Leben viel einfacher...

    InformationsquelleAutor Dean Kuga

  2. 12

    erste von allen, es ist keine blöde Frage. Die meisten von MVVM starter kamen aus winforms und es ist normal, die Tendenz haben, bringen Sie Ihre winforms-Praktiken und die Arbeit an code hinter. Alles was Sie jetzt tun müssen, ist vergessen, und denke MVVM.

    Gehen zurück zu Ihrer Frage, Sie haben ein Wörterbuch, dass Ihre VM-Verarbeitung, und Sie greifen auf das Wörterbuch aus der Sicht. Ihre Sicht sollte nicht eine Idee, über Ihre viewmodel-außer durch Bindung.

    Machen, ein Fenster blinkt, wenn es gibt änderungen im viewmodel klingt wie eine angefügte Verhalten zu mir. Hier ist gut zu Lesen über angehängte Verhalten.
    http://www.codeproject.com/Articles/28959/Introduction-to-Attached-Behaviors-in-WPF

    Um es einfacher zu machen, werde ich versuchen, Ihnen ein sehr einfaches Beispiel, das irgendwie relevant, um Ihren Fall.

    Erstellen Sie eine angefügte Verhalten-Klasse, wo Sie eine IEnumerable-wo, Wann immer Sie etwas hinzufügen, eine messagebox auf dem Bildschirm erscheinen. Ändern Sie einfach die messagebox-code, um was auch immer blinkende animation, die Sie gerne tun würden auf Benachrichtigen. 

    public class FlashNotificationBehavior
{
    public static readonly DependencyProperty FlashNotificationsProperty =
        DependencyProperty.RegisterAttached(
        "FlashNotifications",
        typeof(IEnumerable),
        typeof(FlashNotificationBehavior),
        new UIPropertyMetadata(null, OnFlashNotificationsChange));

    private static void OnFlashNotificationsChange(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var collection = e.NewValue as INotifyCollectionChanged;

        collection.CollectionChanged += (sender, args) => 
            {
                if (args.Action == NotifyCollectionChangedAction.Add)
                {
                    foreach (var items in args.NewItems)
                        MessageBox.Show(items.ToString());
                }
            };            
    }

    public static IEnumerable GetFlashNotifications(DependencyObject d)
    {
        return (IEnumerable)d.GetValue(FlashNotificationsProperty);
    }

    public static void SetFlashNotifications(DependencyObject d, IEnumerable value)
    {
        d.SetValue(FlashNotificationsProperty, value);
    }
}

    In der viewmodel erstellen, können Sie eine ObservableCollection-Eigenschaft müssen Sie eine observable-collection, so gibt es eine Sammlung changed-Ereignis-Benachrichtigung. Ich habe auch einen Befehl für das hinzufügen, so dass Sie es testen kann. 

       public class MainViewModel : ViewModelBase
{
    ObservableCollection<string> notifications;

    public ObservableCollection<string> Notifications
    {
        get { return notifications; }
        set
        {
            if (notifications != value)
            {
                notifications = value;
                base.RaisePropertyChanged(() => this.Notifications);
            }
        }
    }

    public ICommand AddCommand
    {
        get
        {
            return new RelayCommand(() => this.Notifications.Add("Hello World"));
        }
    }

    public MainViewModel()
    {
        this.Notifications = new ObservableCollection<string>();             
    }
}

    Und hier ein Blick, wo Sie können, binden Sie die Benachrichtigungen proeprty von Ihrem view-Modell. 

    <Window x:Class="WpfApplication7.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:vm="clr-namespace:WpfApplication7.ViewModel"
    xmlns:local="clr-namespace:WpfApplication7"
    Title="MainWindow" Height="350" Width="525">
<Window.DataContext>
    <vm:MainViewModel />
</Window.DataContext>
<Grid>
    <StackPanel>
        <ListBox ItemsSource="{Binding Notifications}" 
                 local:FlashNotificationBehavior.FlashNotifications="{Binding Notifications}"></ListBox>
        <Button Command="{Binding AddCommand}" >Add Something</Button>
    </StackPanel>
</Grid>

    Jedes mal, wenn Sie etwas hinzufügen in die ObservableCollection, erhalten Sie eine messagebox den Benutzer zu Benachrichtigen, dass etwas Hinzugefügt wurde, um Ihre Sammlung.

    Ich hoffe, dass ich geholfen bei deinem problem. Sag mir einfach, wenn Sie einige Klarstellungen.

    Danke! Diese Erklärung half mir zeigen, wie verschiedene Teile von mir, code, so dass Sie interagieren können, in einer MVVM-Mode (ich bin immer noch gewöhnungsbedürftig)

    InformationsquelleAutor Lance

Schreibe einen Kommentar