nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

WPF and MVVM: GeoViewTapped Event

MonikaLucas

Hello,

I am trying to create binding for the GeoViewTappedAsync event so that I can place the code in my MapViewModel to follow an MVVM pattern for my WPF application, however I'm not sure how to wire this up. Is there some sample code available that demonstrates this pattern? After looking through GeoNet, I have found some suggestions but they are a few years old.

<esri:MapView x:Name="MainMap" Map="{Binding Map}" GeoViewTapped="Binding {to what does this bind?}">

Thank you!

Jen

Find more posts tagged with

Accepted answers

All comments

JoeHershman

Also one thing to consider: IMHO the purist MVVM approach where absolutely no code-behind can ever exist isn't really true to what MVVM is saying. You can have code-behind, as long as that code-behind is view-specific.

YES!. And in a large application I think this is absolutely required (certainly with Runtime it is).

Here is how we do something like changing viewpoint. This code is in the MapViews Code behind. Zoom is done from anywhere in the application by firing a SetViewpointEvent

<SPAN class="keyword token">private</SPAN> <SPAN class="keyword token">async</SPAN> <SPAN class="keyword token">void</SPAN> <SPAN class="token function">OnSetViewpoint</SPAN><SPAN class="punctuation token">(</SPAN>SetViewpointEventArgs args<SPAN class="punctuation token">)</SPAN>
<SPAN class="punctuation token">{</SPAN>
	<SPAN class="comment token">//First see if a viewpoint was sent, otherwise use a geometry</SPAN>
	<SPAN class="keyword token">try</SPAN>
	<SPAN class="punctuation token">{</SPAN>
		<SPAN class="keyword token">if</SPAN> <SPAN class="punctuation token">(</SPAN> args<SPAN class="punctuation token">.</SPAN>Viewpoint <SPAN class="operator token">!=</SPAN> <SPAN class="keyword token">null</SPAN> <SPAN class="punctuation token">)</SPAN>
		<SPAN class="punctuation token">{</SPAN>
			<SPAN class="keyword token">await</SPAN> MapView<SPAN class="punctuation token">.</SPAN><SPAN class="token function">SetViewpointAsync</SPAN><SPAN class="punctuation token">(</SPAN>args<SPAN class="punctuation token">.</SPAN>Viewpoint<SPAN class="punctuation token">,</SPAN> TimeSpan<SPAN class="punctuation token">.</SPAN><SPAN class="token function">FromMilliseconds</SPAN><SPAN class="punctuation token">(</SPAN><SPAN class="number token">750</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>
			<SPAN class="keyword token">return</SPAN><SPAN class="punctuation token">;</SPAN>
		<SPAN class="punctuation token">}</SPAN>

		<SPAN class="keyword token">var</SPAN> geometry <SPAN class="operator token">=</SPAN> args<SPAN class="punctuation token">.</SPAN>Geometry<SPAN class="punctuation token">;</SPAN>

		<SPAN class="keyword token">switch</SPAN> <SPAN class="punctuation token">(</SPAN>geometry<SPAN class="punctuation token">)</SPAN>
		<SPAN class="punctuation token">{</SPAN>
			<SPAN class="keyword token">case</SPAN> MapPoint mapPoint<SPAN class="punctuation token">:</SPAN>
				<SPAN class="keyword token">if</SPAN> <SPAN class="punctuation token">(</SPAN>MapView<SPAN class="punctuation token">.</SPAN>MapScale <SPAN class="operator token"><</SPAN> args<SPAN class="punctuation token">.</SPAN>Scale<SPAN class="punctuation token">)</SPAN>
				<SPAN class="punctuation token">{</SPAN>
					<SPAN class="keyword token">await</SPAN> MapView<SPAN class="punctuation token">.</SPAN><SPAN class="token function">SetViewpointCenterAsync</SPAN><SPAN class="punctuation token">(</SPAN>mapPoint<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>
				<SPAN class="punctuation token">}</SPAN>
				<SPAN class="keyword token">else</SPAN>
				<SPAN class="punctuation token">{</SPAN>
					<SPAN class="keyword token">await</SPAN> MapView<SPAN class="punctuation token">.</SPAN><SPAN class="token function">SetViewpointCenterAsync</SPAN><SPAN class="punctuation token">(</SPAN>mapPoint<SPAN class="punctuation token">,</SPAN> args<SPAN class="punctuation token">.</SPAN>Scale<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>
				<SPAN class="punctuation token">}</SPAN>

				<SPAN class="keyword token">break</SPAN><SPAN class="punctuation token">;</SPAN>
			<SPAN class="keyword token">case</SPAN> Polyline polyline<SPAN class="punctuation token">:</SPAN>
			<SPAN class="punctuation token">{</SPAN>
				<SPAN class="keyword token">var</SPAN> envelope <SPAN class="operator token">=</SPAN> polyline<SPAN class="punctuation token">.</SPAN>Extent<SPAN class="punctuation token">;</SPAN>
				<SPAN class="keyword token">var</SPAN> buffer <SPAN class="operator token">=</SPAN> GeometryEngine<SPAN class="punctuation token">.</SPAN><SPAN class="token function">Buffer</SPAN><SPAN class="punctuation token">(</SPAN>envelope<SPAN class="punctuation token">,</SPAN> <SPAN class="number token">1000</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>
				<SPAN class="keyword token">var</SPAN> viewpoint <SPAN class="operator token">=</SPAN> <SPAN class="keyword token">new</SPAN> <SPAN class="token class-name">Viewpoint</SPAN><SPAN class="punctuation token">(</SPAN>buffer<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>

				<SPAN class="keyword token">await</SPAN> MapView<SPAN class="punctuation token">.</SPAN><SPAN class="token function">SetViewpointAsync</SPAN><SPAN class="punctuation token">(</SPAN>viewpoint<SPAN class="punctuation token">,</SPAN> TimeSpan<SPAN class="punctuation token">.</SPAN><SPAN class="token function">FromMilliseconds</SPAN><SPAN class="punctuation token">(</SPAN><SPAN class="number token">750</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>

				<SPAN class="keyword token">break</SPAN><SPAN class="punctuation token">;</SPAN>
			<SPAN class="punctuation token">}</SPAN>
			<SPAN class="keyword token">case</SPAN> Polygon polygon<SPAN class="punctuation token">:</SPAN>
				<SPAN class="keyword token">await</SPAN> MapView<SPAN class="punctuation token">.</SPAN><SPAN class="token function">SetViewpointGeometryAsync</SPAN><SPAN class="punctuation token">(</SPAN>polygon<SPAN class="punctuation token">.</SPAN>Extent<SPAN class="punctuation token">,</SPAN> args<SPAN class="punctuation token">.</SPAN>Padding<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>
				<SPAN class="keyword token">break</SPAN><SPAN class="punctuation token">;</SPAN>
			<SPAN class="keyword token">case</SPAN> Envelope envelope<SPAN class="punctuation token">:</SPAN>
				<SPAN class="keyword token">await</SPAN> MapView<SPAN class="punctuation token">.</SPAN><SPAN class="token function">SetViewpointGeometryAsync</SPAN><SPAN class="punctuation token">(</SPAN>envelope<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>
				<SPAN class="keyword token">break</SPAN><SPAN class="punctuation token">;</SPAN>
		<SPAN class="punctuation token">}</SPAN>
	<SPAN class="punctuation token">}</SPAN>
	<SPAN class="keyword token">catch</SPAN> <SPAN class="punctuation token">(</SPAN><SPAN class="token class-name">Exception</SPAN> e<SPAN class="punctuation token">)</SPAN>
	<SPAN class="punctuation token">{</SPAN>
		_log<SPAN class="punctuation token">.</SPAN><SPAN class="token function">Error</SPAN><SPAN class="punctuation token">(</SPAN>e<SPAN class="punctuation token">.</SPAN>Message<SPAN class="punctuation token">,</SPAN> e<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN>
	<SPAN class="punctuation token">}</SPAN>
<SPAN class="punctuation token">}</SPAN><SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

We do similar stuff with displaying popups, saving screen images, and functions that are exposed by the MapView object

rhughes522

Today I did successfully Query the map's Operational Layers using the location passed from the MapView to the View through a binding. That is all I really needed to do since the Map and all its Operational Layers are available in the View Model. But as I figuring out how to work with the MapView programatically my brain short-circuited. The screen vs map points is a great point to make regarding the differences between the Map and the MapView and all the screen sizing that takes place on the client. I do really like this new design with the MapView and appreciate all that is going into it. I do use code behind to enable the location service on the MapView. Eventually that will have to get put somewhere else if I integrate with an external GPS receiver, or maybe not? That will be interesting.

SomeGISGuy

> it seems so odd that functionality like Identifying/Querying Map Layers is only available on the MapView

This is fair criticism, but something to keep in mind is that Identify is a very UI-centric thing. It (typically) deals with the user actually clicking on the view, it's inputs are actual screen coordinates (not map unit coordinates), and the hit test is done based on the rendering of the features (so a large point symbol will still get found even if you don't click exactly at the center of the point).

You could instead do a spatial query of features based on map geometry directly against the layers without the view, but that's not really "identify" in the usual respect.

There really is only two operations directly on the view: The various Identify and SetViewpoint* operations, which all are very specific to working with the view. Pretty much everything else is tucked into objects you can put in your view model, like the Map, GraphicsOverlay, the location datasource, editor etc.

A good equivalent is the ScrollViewer/ListViews: They have view-specific operations for scrolling to a certain item/offset, and very much akin to the SetViewpoint method, and clicking an item is very much identical to the identify operation. None of these you can't really do without some view specific stuff.

Also one thing to consider: IMHO the purist MVVM approach where absolutely no code-behind can ever exist isn't really true to what MVVM is saying. You can have code-behind, as long as that code-behind is view-specific. For example a click handler that performs the identify, and then forwards the result to the view model is still completely ok and within MVVM. Sure you can do all sorts of tricks and jumps to mask that code into various attached properties etc, but you're just adding an enormous amount of complexity only to pretend you moved your view code out of your code behind, when really all you did is move your view code into some other view code, and in the process made your code much harder to follow and understand. It might make sense to do these tricks if you have any different views and want to reuse that same logic over and over again, but always I'd say to weigh the added complexity with the cost.

JoeHershman

I won't get into a philosophical discussion, but I don't consider the Controller approach as MVVM, it is simply a clean way to expose MapView outside the view that contains it. There is an old discussion about this Accessing MapView methods like IdentifyGraphicsOverlaysAsync from viewmodel. In there is a way that I have used a TriggerAction to attach Identify behavior to the MapView. It then uses eventing to send results to the rest of the application.

I have written a very large scale enterprise application consisting of over a dozen separate modules and been almost completely able to avoid having to share the MapView. The one issue is with a module that uses the TOC toolbox control which requires the MapView and in there the controller approach was used to pass the MapView. Everything else can be done using event publish/subscribe from the code behind of the view containing the MapView.

I agree with your initial statement, to me the MapView provides too much functionality and really hampers building a nice MVVM structure. It (literally) took me years to work through all the various places I required MapView methods and organize them in what I consider a clean MVVM manner where the remainder of the application has no knowledge of the MapView (excluding the TOC issue)

rhughes522

Update from me on using a Controller for the MapView. I like how I can now both listen to events and call methods on the view model. Thanks to the samples from esri folks I was able to get this together for another productive day tomorrow. I'll be studying this code more... Thanks for you help. What I did was combine a 10.2.x sample on navigating with the view model Navigate from ViewModel | ArcGIS for Developers, and a more recent sample of listening to the GeoView Tap Events via a ControllerAccessing MapView methods like IdentifyGraphicsOverlaysAsync from viewmodel. I don't see a button for code formatting otherwise I would post what I have. It is basically relies on the classes and stuff in C# that I don't know yet, so I will be busy with that. Meanwhile getting over this hurdle will make everything soo much brighter!!

PrashantKirpan

Try this, I haven't tested but this should work

<esri:MapView x:Name="MyMapView" />

In Code behind of map control access map view and assign to viewmodel prperty

public MainWindow()
        {
            InitializeComponent();
            ((MapViewModel)this.DataContext).MyMapView = this.MyMapView;
        }

MapViewModel:

public MapView MyMapView { get; set; }

public MapView MyMapView { get; set; }

All members of MapView will be available in view model

Regards,

Prashant

rhughes522

Hello all,

I've been doing research on this learning with WPF and it seems so odd that functionality like Identifying/Querying Map Layers is only available on the MapView and that it is really difficult to call methods on it using MVVM.

I understand more or less how to relay the events from the View to the View Model (using mvvm light), but what about simply calling a method on the MapView? Does that still require creating Controllers? I've been working with the samples available online for Navigating from the View Model, and Identification Controllers, and am so worried because I just don't understand how to make them work for me. I think the Navigating from the View Model sample provides the technique for calling methods on the View, but I am having issues with implementing it.

What I am doing is attempting to Identify the layers at a point. I have the point from the Location MapPoint because I can pass that property with the Command as a CommandParameter to my ViewModel, but to perform the query on the layers I need to call a method on the MapView. That is where I need help.

Am I just way off the path here? My background is in Python and javascript/typescript so I am learning the .net sdk and WPF with a plan to transition to UWP after I get a better grasp of how to structure these runtime apps.

Thanks,

Rich

JoeHershman

There is nothing wrong with this approach, but as I mentioned in my previous post it does not scale to a large application that may need access to a MapView event from an object that is not bound directly MapViews view. Using an event approach one can respond to a MapView event from anywhere, even a separate .dll. Again not a bad approach, but does not scale to a really large application.

PrashantKirpan

Hi,

I am able to bind tapped event with MVVM Light. See below code, might be helpful.

MapVM:

public ICommand gvtapped { get; set; }
public MapControlViewModel(): ViewModelBase
{
gvtapped = new RelayCommand<Esri.ArcGISRuntime.UI.Controls.GeoViewInputEventArgs>(Ongvtapped);
}

private void Ongvtapped(GeoViewInputEventArgs obj)
{
}

Map.xaml:

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
xmlns:cmd="http://www.galasoft.ch/mvvmlight"

<esri:MapView >
     <i:Interaction.Triggers>
         <i:EventTrigger EventName="GeoViewTapped">
            <cmd:EventToCommand Command="{Binding gvtapped}" PassEventArgsToCommand="True" />
         </i:EventTrigger>
      </i:Interaction.Triggers>
</esri:MapView>

Regards,

Prashant

MonikaLucas

Hi Joe,

Thanks for your insight and code snippet! I am looking at MVVM Light as it seems like it may be simpler to me to follow as someone new to these frameworks. I've started an intro course on Pluralsight so I'll see how it goes. Thanks again for your help.

MonikaLucas

Hi Morton,

Thanks for your feedback on this. Currently, I'm looking into the MVVM Light framework to use with my application. It seems Pluralsight has a good intro provided by Laurent Bugnion. I managed to bind the button click without the use of any framework but I think using an existing one will be important as I move forward with this application.

I do like your suggestion of putting view specific code in the code-behind, and then forwarding the event on to the viewmodel for simplification purposes. Although I want to adhere to the MVVM pattern, I am not opposed to this approach if it makes things easier to follow.

JoeHershman

Like Morten Nielsen‌ says, just wire up the events to an EventAggregator in the code behind of the view that contains MapView. This does assume you are using a framework that provides event aggregation. I use Prism, but MVVM Light would work as well

<SPAN class="keyword token">private</SPAN> <SPAN class="keyword token">void</SPAN> <SPAN class="token function">WireUpMapViewEventHandlers</SPAN><SPAN class="punctuation token">(</SPAN>IEventAggregator eventAggregator<SPAN class="punctuation token">)</SPAN>
<SPAN class="punctuation token">{</SPAN>
	MapView<SPAN class="punctuation token">.</SPAN>GeoViewTapped <SPAN class="operator token">+</SPAN><SPAN class="operator token">=</SPAN> <SPAN class="punctuation token">(</SPAN>s<SPAN class="punctuation token">,</SPAN> e<SPAN class="punctuation token">)</SPAN> <SPAN class="operator token">=</SPAN><SPAN class="operator token">></SPAN> <SPAN class="punctuation token">{</SPAN> eventAggregator<SPAN class="punctuation token">.</SPAN>GetEvent<SPAN class="operator token"><</SPAN>GeoViewTappedEvent<SPAN class="operator token">></SPAN><SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="token function">Publish</SPAN><SPAN class="punctuation token">(</SPAN>e<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN> <SPAN class="punctuation token">}</SPAN><SPAN class="punctuation token">;</SPAN>
	MapView<SPAN class="punctuation token">.</SPAN>GeoViewDoubleTapped <SPAN class="operator token">+</SPAN><SPAN class="operator token">=</SPAN> <SPAN class="punctuation token">(</SPAN>s<SPAN class="punctuation token">,</SPAN> e<SPAN class="punctuation token">)</SPAN> <SPAN class="operator token">=</SPAN><SPAN class="operator token">></SPAN> <SPAN class="punctuation token">{</SPAN> eventAggregator<SPAN class="punctuation token">.</SPAN>GetEvent<SPAN class="operator token"><</SPAN>GeoViewDoubleTappedEvent<SPAN class="operator token">></SPAN><SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="token function">Publish</SPAN><SPAN class="punctuation token">(</SPAN>e<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN> <SPAN class="punctuation token">}</SPAN><SPAN class="punctuation token">;</SPAN>
	MapView<SPAN class="punctuation token">.</SPAN>GeoViewHolding <SPAN class="operator token">+</SPAN><SPAN class="operator token">=</SPAN> <SPAN class="punctuation token">(</SPAN>s<SPAN class="punctuation token">,</SPAN> e<SPAN class="punctuation token">)</SPAN> <SPAN class="operator token">=</SPAN><SPAN class="operator token">></SPAN> <SPAN class="punctuation token">{</SPAN> eventAggregator<SPAN class="punctuation token">.</SPAN>GetEvent<SPAN class="operator token"><</SPAN>GeoViewHoldingEvent<SPAN class="operator token">></SPAN><SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="token function">Publish</SPAN><SPAN class="punctuation token">(</SPAN>e<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN> <SPAN class="punctuation token">}</SPAN><SPAN class="punctuation token">;</SPAN>
	MapView<SPAN class="punctuation token">.</SPAN>ViewpointChanged <SPAN class="operator token">+</SPAN><SPAN class="operator token">=</SPAN> <SPAN class="punctuation token">(</SPAN>s<SPAN class="punctuation token">,</SPAN> e<SPAN class="punctuation token">)</SPAN> <SPAN class="operator token">=</SPAN><SPAN class="operator token">></SPAN> <SPAN class="punctuation token">{</SPAN> eventAggregator<SPAN class="punctuation token">.</SPAN>GetEvent<SPAN class="operator token"><</SPAN>ViewpointChangedEvent<SPAN class="operator token">></SPAN><SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="token function">Publish</SPAN><SPAN class="punctuation token">(</SPAN>MapView<SPAN class="punctuation token">.</SPAN>VisibleArea<SPAN class="punctuation token">.</SPAN>Extent<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN> <SPAN class="punctuation token">}</SPAN><SPAN class="punctuation token">;</SPAN>
	MapView<SPAN class="punctuation token">.</SPAN>NavigationCompleted <SPAN class="operator token">+</SPAN><SPAN class="operator token">=</SPAN> <SPAN class="punctuation token">(</SPAN>s<SPAN class="punctuation token">,</SPAN> e<SPAN class="punctuation token">)</SPAN> <SPAN class="operator token">=</SPAN><SPAN class="operator token">></SPAN> <SPAN class="punctuation token">{</SPAN> eventAggregator<SPAN class="punctuation token">.</SPAN>GetEvent<SPAN class="operator token"><</SPAN>NavigationCompletedEvent<SPAN class="operator token">></SPAN><SPAN class="punctuation token">(</SPAN><SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">.</SPAN><SPAN class="token function">Publish</SPAN><SPAN class="punctuation token">(</SPAN>MapView<SPAN class="punctuation token">.</SPAN>VisibleArea<SPAN class="punctuation token">.</SPAN>Extent<SPAN class="punctuation token">)</SPAN><SPAN class="punctuation token">;</SPAN> <SPAN class="punctuation token">}</SPAN><SPAN class="punctuation token">;</SPAN>
<SPAN class="punctuation token">}</SPAN><SPAN class="line-numbers-rows"><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN><SPAN>‍</SPAN></SPAN>

Now just need to add an event handler anywhere in the application you want to respond to the event.

The problem (to me) with using an EventToCommand type approach is that this only allows response to these events in the MapViewModel. This is fine in a simple application but if you want the application to grow beyond the single ViewModel it really won't support it (imo).

As pointed out by Morten, the code in the code behind is only associated to the MapView. So, I would not consider it breaking any MVVM principle. No other part of the application knows anything about the MapView other than that it fires these events

SomeGISGuy

You don't bind directly from view events to VM code in WPF. The way you would handle this is very similar to how you for instance would handle a click event from a button.

It's all a little different based on which MVVM framework you use, but typically it's called "EventToCommand" or similar approach, and there's quite a lot of examples online if you search for that.

Also whichever suggestions you found should still be relevant (albeit code might have to be tweaked), since reacting to view events in MVVM hasn't really changed.

Another MUCH simpler way, is to simply create a GeoViewTapped event handler in code-behind, and all that handler is doing is forwarding the event directly to the viewmodel (and possible filtering anything view-specific away). This is _still_ pure MVVM, as your code-behind is only view-specific code, and thus still gets the separation MVVM likes to promote. And really it's not much different than a pure-xaml version of it is, as the XAML is really just generating code in the same view class. I personally prefer this more pragmatic approach as it's much simpler to follow the flow from view events to the view model. TBH I find the EventToCommand approach a little less MVVM as it forwards view-specific event arguments directly to your viewmodel. But it's all religion at this point which approach you choose to take.

Join the Conversation

Signed in members can post, follow updates, and more. New here? Register a free account.

Quick Links

Community Help
Find useful guides, FAQs, and documents to help you navigate and make the most of Esri Community.