"}],"short_description":"Illustrates the use of ArcGIS Maps SDKs for Native Apps to consume data from a feed and dynamically update geoelement location and attributes.","flexible_content":[{"acf_fc_layout":"content","content":"It wasn\u2019t long ago that maps were strictly static documents whose information was quickly out-of-date. In the last few decades, GIS and the internet have revolutionized the map, turning it from a static document into a dynamic online resource. To provide data that is relevant and up-to-date, mobile data collection and crowdsourcing now ensure data updates occur quickly and efficiently. Despite such advances, traditional GIS data updates are still not frequent or consistent enough for some use cases.<\/p>\n"},{"acf_fc_layout":"content","content":"
In this article, I walk through creating an application that highlights some common workflows for processing data in real-time using ArcGIS Maps SDKs for Native Apps. I use .NET (C#) code to show some examples, but the concepts apply to each of the Native SDKs that support consuming data from a stream.<\/p>\n
For an overview of creating real-time apps using your preferred Native SDK, see the Real-time<\/em> topic in the developer guide: Java<\/a><\/strong> | .NET<\/strong><\/a> | Qt<\/a><\/strong> | Swift<\/a><\/strong>.<\/p>\n"},{"acf_fc_layout":"content","content":" Sometimes, data-driven decisions require information for current (or very recent) conditions in a quickly changing environment. Real-time apps rely on data that is updated frequently to show its current (or nearly current) state. This data commonly comes from GPS and other sensors that provide location and attribute updates. You can connect to a data stream to bring data updates directly into your ArcGIS Maps SDK for Native Apps application and process them in real time. Once established, a connection to a data stream continues to deliver updates until the connection is closed. Real-time apps may receive and interpret observations from various data streams, including stationary sensors like weather stations, moving assets like vehicles, or point-in-time events like crime and accidents.<\/p>\n"},{"acf_fc_layout":"sidebar","content":" Use ArcGIS Maps SDKs for Native Apps<\/em> (formerly ArcGIS Runtime SDKs)<\/em> to build apps for a variety of platforms. These SDKs include:<\/p>\n The dynamic entities API described in this article was introduced at version 200.1 for all SDKs except Maps SDK for Kotlin. It was introduced for that SDK at version 200.2.<\/p>\n","image_reference":false,"layout":"standard","image_reference_figure":"","snippet":"","spotlight_name":"","section_title":"","position":"Right","spotlight_image":false},{"acf_fc_layout":"content","content":" I include an app that illustrates some of the essential concepts, and perhaps a few pitfalls, you may encounter. The app uses a stream service created with ArcGIS GeoEvent Server<\/a> with global flight updates from a FlightAware<\/a> data feed. You can filter the stream to only show dynamic entities in the current map extent and list all flights going to a selected airport. Selecting a specific flight shows attributes for the entity (airline, speed, altitude, origin, destination, and so on). The selected flight is also displayed as a graphic that is tracked in an inset scene view. Click a dynamic entity in the map to see a callout with its flight number and departure and arrival airports.<\/p>\n Download the code and try it yourself: flight-dynamic-entities<\/strong><\/a><\/p>\n"},{"acf_fc_layout":"image","image":{"ID":1864612,"id":1864612,"title":"dyn-entities-flight-app","filename":"dyn-entities-flight-app.png","filesize":403977,"url":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app.png","link":"https:\/\/www.esri.com\/arcgis-blog\/products\/sdk-net\/developers\/create-real-time-apps-with-arcgis-maps-sdks-for-native-apps\/dyn-entities-flight-app","alt":"Flight tracking app that uses dynamic entities","author":"8512","description":"The app connects to an ArcGIS stream service that provides flight tracking info from FlightAware and displays it in the map.","caption":"A flight tracking app that illustrates working with dynamic entities from an ArcGIS stream service.","name":"dyn-entities-flight-app","status":"inherit","uploaded_to":1845082,"date":"2023-03-03 19:31:47","modified":"2023-03-03 19:33:28","menu_order":0,"mime_type":"image\/png","type":"image","subtype":"png","icon":"https:\/\/www.esri.com\/arcgis-blog\/wp-includes\/images\/media\/default.png","width":800,"height":448,"sizes":{"thumbnail":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app-213x200.png","thumbnail-width":213,"thumbnail-height":200,"medium":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app.png","medium-width":464,"medium-height":261,"medium_large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app.png","medium_large-width":768,"medium_large-height":430,"large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app.png","large-width":800,"large-height":448,"1536x1536":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app.png","1536x1536-width":800,"1536x1536-height":448,"2048x2048":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app.png","2048x2048-width":800,"2048x2048-height":448,"card_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app.png","card_image-width":800,"card_image-height":448,"wide_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-flight-app.png","wide_image-width":800,"wide_image-height":448}},"image_position":"center","orientation":"horizontal","hyperlink":""},{"acf_fc_layout":"sidebar","content":" Even in an ideal situation, data has to travel at the speed of light and undergo some type of processing before making it to your device. While that may be close enough to call “real-time”, in most cases a stream does not send updates immediately. Instead, it sends them at a specified interval (cadence). For example, every few seconds, every hour, every day at midnight, and so on.<\/p>\n The term real-time<\/em> better describes an app rather than the data it consumes. When new observations arrive from a stream, a real-time app<\/em> processes them immediately.<\/p>\n","image_reference":false,"layout":"standard","image_reference_figure":"","snippet":"","spotlight_name":"","section_title":"","position":"Right","spotlight_image":false},{"acf_fc_layout":"content","content":" The constructor for an Properties on the <\/p>\n <\/p>\n Apply a <\/p>\n You cannot set the filter (or change it) after the service has loaded. If no data comes from the service when testing your app, try removing any filter defined for the service.<\/p>\n","image_reference":false,"layout":"standard","image_reference_figure":"","snippet":"","spotlight_name":"","section_title":"","position":"Center","spotlight_image":false},{"acf_fc_layout":"content","content":" Once the dynamic entity data source connection is loaded and connected, data will begin to flow from the stream. Create a <\/p>\n <\/p>\n"},{"acf_fc_layout":"image","image":{"ID":1864582,"id":1864582,"title":"dyn-entities-load-flights","filename":"dyn-entities-load-flights.gif","filesize":6808073,"url":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights.gif","link":"https:\/\/www.esri.com\/arcgis-blog\/products\/sdk-net\/developers\/create-real-time-apps-with-arcgis-maps-sdks-for-native-apps\/dyn-entities-load-flights","alt":"Dynamic entities layer loading data from a stream","author":"8512","description":"A dynamic entity layer loads entities from a data source when it's loaded.","caption":"Flights appear in the dynamic entity layer when the stream service is loaded.","name":"dyn-entities-load-flights","status":"inherit","uploaded_to":1845082,"date":"2023-03-03 18:54:12","modified":"2023-03-03 18:56:21","menu_order":0,"mime_type":"image\/gif","type":"image","subtype":"gif","icon":"https:\/\/www.esri.com\/arcgis-blog\/wp-includes\/images\/media\/default.png","width":800,"height":448,"sizes":{"thumbnail":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights-213x200.gif","thumbnail-width":213,"thumbnail-height":200,"medium":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights.gif","medium-width":464,"medium-height":261,"medium_large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights.gif","medium_large-width":768,"medium_large-height":430,"large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights.gif","large-width":800,"large-height":448,"1536x1536":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights.gif","1536x1536-width":800,"1536x1536-height":448,"2048x2048":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights.gif","2048x2048-width":800,"2048x2048-height":448,"card_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights.gif","card_image-width":800,"card_image-height":448,"wide_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-load-flights.gif","wide_image-width":800,"wide_image-height":448}},"image_position":"center","orientation":"horizontal","hyperlink":""},{"acf_fc_layout":"content","content":" Depending on the nature of your data, you may want to toggle additional display settings according to the current map scale. For example, labels, previous observations, and track lines might clutter the display at a small scale. Often, that level of detail is only meaningful and clear at a larger (more zoomed-in) scale.<\/p>\n"},{"acf_fc_layout":"content","content":" As information comes from the stream, the local data store adds or removes dynamic entities as needed. Initial observations mean a new flight, while flights with no more associated observations are removed (purged). While the As a simple example, you could increment or decrement a count to keep track of the current number of entities. I use a variable called DynamicEntityCount<\/em> to keep track of the number of flights currently in the data store and display that value in a label.<\/p>\n <\/p>\n <\/p>\n"},{"acf_fc_layout":"content","content":" Getting unique values for an attribute is a common workflow when using geographic data. With dynamic entities, however, it can be a bit trickier for a couple of reasons. First, you can\u2019t query the dynamic entity data source directly. Second, the values coming from the stream are not always predictable and may change rapidly. For example, working with flight data from around the globe, I can\u2019t know for sure which destination airports will appear in the feed for a given time, especially if I allow the user to filter the data with a map extent. I could build out a master list of all possible airports and provide that in my app, but that adds too much clutter to the list. A much better experience for the user is to only show the relevant values for current data from the feed.<\/p>\n"},{"acf_fc_layout":"content","content":" What you can do instead is listen to update notifications from the stream. Use them to maintain a list of unique values from the observations as they come in. First, you need to handle one of the following events that are raised when data is received:<\/p>\n In my app, the user can change the selected airport anytime, perhaps after most of the dynamic entities are received. I therefore handle the observation received event. To work as expected in a multi-threaded environment, my code uses a <\/p>\n This code uses the hard-coded value for the destination airport field (“dest”). You could easily modify this code to look for unique values in a field selected by the user. For example, you could also create a unique list of airlines, departure airports, or aircraft types for the current flights. You could do something more sophisticated here if you wanted, like keep a count for each destination airport. You might also handle the When an airport is selected from the list, a Similar to the code above to find unique values for a field, I use the <\/p>\n Notice that you can get the dynamic entity from an observation. Likewise, you can get the collection of observations that belong to a dynamic entity.<\/p>\n To accurately track the current<\/strong> set of flights to the selected airport, I also handle the <\/p>\nKeeping it real<\/h2>\n
\nThe following are examples of real-time apps in various application areas:<\/p>\n\n
\n
API overview<\/h2>\n
\n
DynamicEntityDataSource<\/code><\/a> connects to a stream data source and provides notifications for data updates and connection status changes. The connection is maintained (automatically reconnected as needed, for example) to make sure data continues to flow.<\/li>\nDynamicEntity<\/code><\/a> represents one of the real-world objects described by the data source.<\/li>\nDynamicEntityObservation<\/code><\/a> represents a snapshot in time of the state (attributes and location) of a dynamic entity.<\/li>\nDynamicEntityLayer<\/code><\/a> displays dynamic entities and observations and updates them as data is received.<\/li>\n<\/ul>\n"},{"acf_fc_layout":"content","content":"A flight-tracking example<\/h2>\n
Real-time apps<\/h3>\n
Connect to a data stream<\/h2>\n
ArcGISStreamService<\/code><\/a>. For information about creating a stream service, see the ArcGIS Velocity<\/a> or ArcGIS GeoEvent Server<\/a> documentation. Each of those products allows you to configure a data source using a variety of data feed formats and expose them as a stream service. Supported formats include AWS, Azure, HTTP polling, and many more. To explore custom dynamic entity data sources (using version 200.2 of the SDK), see my article Craft your own dynamic entity data source for ArcGIS Maps SDKs for Native Apps<\/a>.<\/div>\n<\/div>\nArcGISStreamService<\/code><\/a> requires the service URI. If the service requires authentication, you’ll need to handle providing the appropriate credentials or challenging the user for them. See the ArcGIS Maps SDK for .NET OAuth sample<\/a> for an example.<\/p>\nArcGISStreamService<\/code><\/a> control connection behavior, define how long previous observations are stored, and listen to notifications. Note that the service won’t start streaming data until it’s loaded and connected. You can do this explicitly by calling LoadAsync()<\/code> and ConnectAsync()<\/code>. It can also happen implicitly when you add a layer that uses the stream service as its data source. Creating a DynamicEntityLayer<\/code> from a stream data source is discussed later in this article.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
\r\n \/\/ Create the stream service from the service URL.<\/span>\r\n var<\/span> streamService = new<\/span> ArcGISStreamService(new<\/span> Uri(serviceUrl));\r\n\r\n \/\/ Set option to purge updates older than 12 hours.<\/span>\r\n streamService.PurgeOptions.MaximumDuration = new<\/span> TimeSpan(12, 0, 0);\r\n\r\n \/\/ Set the max reconnection interval time and max reconnect attempts.<\/span>\r\n streamService.ReconnectionInterval = new<\/span> TimeSpan(0, 0, 15); \r\n streamService.MaximumReconnectionAttempts = 6;\r\n\r\n \/\/ Handle changes to the connection status.<\/span>\r\n streamService.ConnectionStatusChanged += ConnectionStatusChanged;\r\n\r\n<\/pre>\n<\/div>\n<\/details>\nFilter data from the stream<\/h2>\n
ArcGISStreamServiceFilter<\/code><\/a> to the data source to filter the data received from the stream. You can filter based on a specific area (envelope) or with an attribute expression (or both). The filter is applied on the server to limit the data sent to the client. Applying a filter to the stream can reduce the amount of data stored locally.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
\r\n \/\/ Filter to show flights higher than 10,000 ft within the map extent<\/span>\r\n \/\/ (define this before calling LoadAsync() on the service).<\/span>\r\n var<\/span> streamFilter = new<\/span> ArcGISStreamServiceFilter\r\n {\r\n Geometry = currentMapExtent,\r\n WhereClause = \"alt >= 10000\"<\/span>\r\n };\r\n streamService.Filter = streamFilter;\r\n\r\n await<\/span> streamService.LoadAsync();\r\n\r\n<\/pre>\n<\/div>\n<\/details>\n"},{"acf_fc_layout":"sidebar","content":"Display data coming from the stream<\/h2>\n
DynamicEntityLayer<\/code><\/a> from the data source and add it to your map or scene to see dynamic entities appear. If you create a DynamicEntityLayer<\/code><\/a> with a data connection that is not loaded or connected, the connection will load and connect automatically when the layer is added to the map or scene. Like other layers you may have worked with (such as FeatureLayer<\/code>), you can control rendering (symbols), labeling, and various other display properties. The layer’s TrackDisplayProperties<\/code><\/a> allows you to control the display of previous observations. You can set a maximum number of observations to show, connect them with a track line<\/em>, and render the observations and\/or track lines.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
\/\/ Create a dynamic entity layer.<\/span>\r\n _dynamicEntityLayer = new<\/span> DynamicEntityLayer(streamService)\r\n {\r\n \/\/ Create and apply a simple renderer.<\/span>\r\n Renderer = new<\/span> SimpleRenderer(\r\n new<\/span> SimpleMarkerSymbol(SimpleMarkerSymbolStyle.Circle, \r\n System.Drawing.Color.Red, \r\n 6))\r\n };\r\n\r\n \/\/ Turn tracks, entities, and labels off initially<\/span>\r\n \/\/ (The app will manage the display according to the current map scale).<\/span>\r\n _dynamicEntityLayer.TrackDisplayProperties.ShowPreviousObservations = false<\/span>;\r\n _dynamicEntityLayer.TrackDisplayProperties.ShowTrackLine = false<\/span>;\r\n _dynamicEntityLayer.LabelsEnabled = false<\/span>;\r\n\r\n \/\/ Add the layer to the map.<\/span>\r\n MainMapView.Map.OperationalLayers.Add(_dynamicEntityLayer);\r\n\r\n<\/pre>\n<\/div>\n<\/details>\nListen for when dynamic entities are added or removed<\/h2>\n
DynamicEntityLayer<\/code><\/a> manages the display of the dynamic entities, you can handle the DynamicEntityReceived<\/code><\/a> and DynamicEntityPurged<\/code><\/a> events for notifications about dynamic entities added or removed from the local data store.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
private<\/span> void<\/span> StreamService_DynamicEntityReceived(object?<\/span> s, DynamicEntityEventArgs e)\r\n {\r\n DynamicEntityCount++;\r\n }\r\n\r\n private<\/span> void<\/span> StreamService_DynamicEntityPurged(object?<\/span> s, DynamicEntityEventArgs e)\r\n {\r\n DynamicEntityCount--;\r\n }\r\n\r\n<\/pre>\n<\/div>\n<\/details>\nGet a list of unique values for the current dynamic entities<\/h2>\n
\n
DynamicEntityReceived<\/code><\/a> notifies when a new dynamic entity is received from the stream.<\/li>\nDynamicEntityObservationReceived<\/code><\/a> notifies of a new observation, either for a new or existing dynamic entity, is received.<\/li>\n<\/ul>\nGet unique destination airports<\/h3>\n
ConcurrentDictionary<\/code><\/a> (rather than a plain Dictionary<\/code>) with the airport code as the unique key. When an observation is received, the dictionary is used to see if the airport code has already been added. If it’s a new airport code, it’s added to an ObservableCollection<string><\/code><\/a>. The observable collection is bound to a ComboBox<\/code> to display the unique airport codes currently in the layer.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
private<\/span> void<\/span> StreamService_DynamicEntityObservationReceived\r\n (object?<\/span> sender, DynamicEntityObservationEventArgs e)\r\n {\r\n \/\/ Get the attributes dictionary for this observation.<\/span>\r\n var<\/span> attr = e.Observation.Attributes;\r\n \/\/ Make sure there's a value for the destination airport.<\/span>\r\n if<\/span> (attr[\"dest\"<\/span>] != null<\/span>)\r\n {\r\n \/\/ Get the destination airport code as an upper-case string.<\/span>\r\n var<\/span> thisVal = attr[\"dest\"<\/span>].ToString().ToUpper();\r\n\r\n \/\/ Call 'TryAdd' on the ConcurrentDictionary.<\/span>\r\n if<\/span> (_uniqueAirportCodesDictionary.TryAdd(thisVal, thisVal))\r\n {\r\n \/\/ If new code, add it to the observable collection.<\/span>\r\n Application.Current?.Dispatcher?.Invoke(() =>\r\n {\r\n CurrentAirports.Add(thisVal);\r\n });\r\n }\r\n }\r\n }\r\n\r\n<\/pre>\n<\/div>\n<\/details>\nDynamicEntityPurged<\/code><\/a> event to decrement the counts (and remove airports) as appropriate.<\/p>\n"},{"acf_fc_layout":"content","content":"Find dynamic entities that match an attribute expression<\/h2>\n
UniqueValueRenderer<\/code><\/a> is applied to the layer. The renderer shows flights traveling to that airport in red and all others in blue. The selected airport is also geocoded and the inset weather map zooms to its location.<\/p>\nDynamicEntityObservationReceived<\/code><\/a> event handler to get a list of flights with a selected destination airport. The logic is essentially the same: when a new observation is received from the stream, I check its attribute values and create a list of unique values. This time, it’s a list of flight numbers that have the selected airport code for their destination.<\/p>\n"},{"acf_fc_layout":"image","image":{"ID":1864942,"id":1864942,"title":"dyn-entities-select-destination","filename":"dyn-entities-select-destination.gif","filesize":8386493,"url":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination.gif","link":"https:\/\/www.esri.com\/arcgis-blog\/products\/sdk-net\/developers\/create-real-time-apps-with-arcgis-maps-sdks-for-native-apps\/dyn-entities-select-destination","alt":"Flights to the selected airport","author":"8512","description":"Dynamic entities that have a destination attribute that matches the selected airport are shown in the list box. The map is rendered to show those flights in red.","caption":"When the user selects a destination, the list box shows flights to that airport.","name":"dyn-entities-select-destination","status":"inherit","uploaded_to":1845082,"date":"2023-03-03 20:36:03","modified":"2023-03-03 20:40:08","menu_order":0,"mime_type":"image\/gif","type":"image","subtype":"gif","icon":"https:\/\/www.esri.com\/arcgis-blog\/wp-includes\/images\/media\/default.png","width":800,"height":448,"sizes":{"thumbnail":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination-213x200.gif","thumbnail-width":213,"thumbnail-height":200,"medium":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination.gif","medium-width":464,"medium-height":261,"medium_large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination.gif","medium_large-width":768,"medium_large-height":430,"large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination.gif","large-width":800,"large-height":448,"1536x1536":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination.gif","1536x1536-width":800,"1536x1536-height":448,"2048x2048":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination.gif","2048x2048-width":800,"2048x2048-height":448,"card_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination.gif","card_image-width":800,"card_image-height":448,"wide_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/03\/dyn-entities-select-destination.gif","wide_image-width":800,"wide_image-height":448}},"image_position":"center","orientation":"horizontal","hyperlink":""},{"acf_fc_layout":"content","content":"\u2295\u00a0Show code …<\/span><\/summary>\n
private<\/span> void<\/span> StreamService_DynamicEntityObservationReceived\r\n (object?<\/span> sender, DynamicEntityObservationEventArgs e)\r\n {\r\n \/\/ Get the attributes dictionary for this observation.<\/span>\r\n var<\/span> attr = e.Observation.Attributes;\r\n \/\/ Make sure there's a value for the destination airport.<\/span>\r\n if<\/span> (attr[\"dest\"<\/span>] != null<\/span>)\r\n {\r\n \/\/ Get the destination airport code as an upper-case string.<\/span>\r\n var<\/span> thisVal = attr[\"dest\"<\/span>].ToString().ToUpper();\u00a0 \u00a0 \u00a0 \u00a0\r\n\r\n \/\/ ...< code here to get unique airport destinations >...\r\n<\/span>\r\n \/\/ Does the destination (\"dest\") match the selected airport?<\/span>\r\n if<\/span> (_findAirport is<\/span> not null<\/span> && thisVal == _findAirport)\r\n {\r\n \/\/ The \"ident\" field holds the flight ID (\"DAL1234\", eg).<\/span>\r\n var<\/span> displayId = attr[\"ident\"<\/span>]?.ToString();\r\n\r\n if<\/span> (!string<\/span>.IsNullOrEmpty(displayId))\r\n {\r\n \/\/ Get the dynamic entity for this observation.<\/span>\r\n var<\/span> dynamicEntity = e.Observation.GetDynamicEntity();\r\n \/\/ Try to add it to the ConcurrentDictionary.<\/span>\r\n if<\/span> (_dynamicEntityIdDictionary.TryAdd(displayId, dynamicEntity.EntityId))\r\n {\r\n \/\/ If a new ID, add it to the collection.<\/span>\r\n Application.Current?.Dispatcher?.Invoke(() =>\r\n {\r\n DynamicEntityCollection.Add(dynamicEntity);\r\n });\r\n }\r\n }\r\n }\r\n }\r\n }\r\n\r\n<\/pre>\n<\/div>\n<\/details>\nDynamicEntityPurged<\/code><\/a> event to check for entities that are no longer displayed (flights that have landed, for example). If an entity from the list is purged, I remove it from the collection.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
private<\/span> void<\/span> StreamService_DynamicEntityPurged\r\n (object?<\/span> sender, DynamicEntityEventArgs e)\r\n {\r\n DynamicEntityCount--;\r\n\r\n \/\/ Get the dynamic entity being purged.<\/span>\r\n var<\/span> dynamicEntity = e.DynamicEntity;\r\n\r\n \/\/ Get the flight ID.<\/span>\r\n var<\/span> displayId = dynamicEntity.Attributes[\"ident\"<\/span>]?.ToString();\r\n\r\n