Binden Xamarin.Formen.Maps.Karte von ViewModel

Wenn Sie nicht wollen, zu brechen, das MVVM-Muster und immer noch Zugriff auf Ihre Map-Objekt aus dem ViewModel, dann können Sie aussetzen des Map-Instanz mit einer Eigenschaft aus der ViewModel binden und es aus Ihrer Sicht.

Ihr code sollte strukturiert werden, wie hier beschrieben, unten.

ViewModel:

using Xamarin.Forms.Maps;

namespace YourApp.ViewModels
{
    public class MapViewModel
    {
        public MapViewModel()
        {
            Map = new Map();
        }

        public Map Map { get; private set; }
    }
}

View (in diesem Beispiel verwende ich ein ContentPage aber Sie können verwenden, was Ihnen gefällt):

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="YourApp.Views.MapView">
    <ContentPage.Content>
                <!--The map-->
                <ContentView Content="{Binding Map}"/>
    </ContentPage.Content>
</ContentPage>

Ich zeigen nicht, wie, aber der obige code snipped kann nur funktionieren, wenn das ViewModel ist die BindingContext Ihrer Ansicht.

Was zum erstellen einer neuen Control-sagen BindableMap was erbt von Map und führt die binding-updates, die die ursprüngliche Map fehlt intern. Die Umsetzung ist ziemlich einfach und ich habe 2 grundlegende Anforderungen; das Pins - Eigenschaft und die aktuellen MapSpan. Natürlich können Sie fügen Sie Ihre eigenen speziellen Bedürfnisse zu dieser Steuerung. Alles, was Sie danach tun ist, um eine Eigenschaft vom Typ ObservableCollection<Pin> zu Ihrem ViewModel und binden Sie es an die PinsSource Eigentum Ihrer BindableMap in XAML.

Hier ist die BindableMap:

public class BindableMap : Map
{

    public BindableMap()
    {
        PinsSource = new ObservableCollection<Pin>();
        PinsSource.CollectionChanged += PinsSourceOnCollectionChanged;
    }

    public ObservableCollection<Pin> PinsSource
    {
        get { return (ObservableCollection<Pin>)GetValue(PinsSourceProperty); }
        set { SetValue(PinsSourceProperty, value); }
    }

    public static readonly BindableProperty PinsSourceProperty = BindableProperty.Create(
                                                     propertyName: "PinsSource",
                                                     returnType: typeof(ObservableCollection<Pin>),
                                                     declaringType: typeof(BindableMap),
                                                     defaultValue: null,
                                                     defaultBindingMode: BindingMode.TwoWay,
                                                     validateValue: null,
                                                     propertyChanged: PinsSourcePropertyChanged);


    public MapSpan MapSpan
    {
        get { return (MapSpan)GetValue(MapSpanProperty); }
        set { SetValue(MapSpanProperty, value); }
    }

    public static readonly BindableProperty MapSpanProperty = BindableProperty.Create(
                                                     propertyName: "MapSpan",
                                                     returnType: typeof(MapSpan),
                                                     declaringType: typeof(BindableMap),
                                                     defaultValue: null,
                                                     defaultBindingMode: BindingMode.TwoWay,
                                                     validateValue: null,
                                                     propertyChanged: MapSpanPropertyChanged);

    private static void MapSpanPropertyChanged(BindableObject bindable, object oldValue, object newValue)
    {
        var thisInstance = bindable as BindableMap;
        var newMapSpan = newValue as MapSpan;

        thisInstance?.MoveToRegion(newMapSpan);
    }
    private static void PinsSourcePropertyChanged(BindableObject bindable, object oldvalue, object newValue)
    {
        var thisInstance = bindable as BindableMap;
        var newPinsSource = newValue as ObservableCollection<Pin>;

        if (thisInstance == null ||
            newPinsSource == null)
            return;

        UpdatePinsSource(thisInstance, newPinsSource);
    }
    private void PinsSourceOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
        UpdatePinsSource(this, sender as IEnumerable<Pin>);
    }

    private static void UpdatePinsSource(Map bindableMap, IEnumerable<Pin> newSource)
    {
        bindableMap.Pins.Clear();
        foreach (var pin in newSource)
            bindableMap.Pins.Add(pin);
    }
}

Hinweise:

• Die ich ausgelassen habe, die using-Anweisungen und-namespace-Deklaration der Einfachheit halber.
• Um für unsere original Pins - Eigenschaft aktualisiert werden fügen wir die Mitglieder unseres bindbare PinsSource Eigenschaft, erklärte ich der PinsSource als ObservableCollection<Pin> und abonniert seinen CollectionChanged Veranstaltung. Natürlich können Sie definieren es als eine IList wenn Sie wollen, ändern Sie nur die gesamte Wert Ihrer gebundenen Eigenschaft.

Meine Letzte Wort über die 2 ersten Antworten zu dieser Frage:

Obwohl Sie ein View-Steuerelement als eine ViewModel-Eigenschaft befreit uns von dem schreiben der business-Logik im code dahinter, aber es fühlt sich immer noch eine Art hacky. Meiner Meinung nach, der springende Punkt, der (naja, zumindest einen wichtigen Punkt im) der VM Teil des MVVM ist, dass es völlig getrennt und entkoppelt von der V. in der Erwägung, dass die Lösung in den oben genannten Antworten ist eigentlich diese:

Legen Sie eine View-Steuerelement in das Herz Ihrer ViewModel.

Ich denke, dass dieser Weg, nicht nur brechen Sie das MVVM-Muster, aber auch Sie bricht Ihr Herz!

Es ist nicht ideal, aber man konnte hören, die für das property changed-Ereignis in der code-behind und dann übernehmen Sie die änderung, von dort aus. Es ist ein bisschen Anleitung, aber es ist machbar.

((ViewModels.YourViewModel)BindingContext).PropertyChanged += yourPropertyChanged;

Und definieren Sie dann die "yourPropertyChanged" Methode

private void yourPropertyChanged(object sender, PropertyChangedEventArgs e)
{
    if(e.PropertyName == "YourPropertyName")
    {
        var position = new Position(37.79762, -122.40181);
        Map.MoveToRegion(new MapSpan(position, 0.01, 0.01));
        Map.Pins.Add(new Pin
        {
            Label = "Xamarin",
            Position = position
        });
    }
}