ArcGIS Pro SDK Blog - Page 3

The next release of ArcGIS Pro 2.6 will soon arrive, and with it new updates to the ArcGIS Pro SDK for Microsoft .NET.

After sometime back I got difficulty on reading aptx file information with ArcPro SDK, refer to this post.

Retrieval of Project/project template metadata 

Thank to Wolfgang Kaiser‌, I found out that aptx is actually a 7zip file, and no wonder I can't use build in Microsoft provided zipfile libraries.

And the there are a lot of 7zip extractor out there in nugget space but some are not working properly to extract that aptx file.

Among them, SevenZipExtractor, 7z.NET nugget libraries can extract that aptx file.

Below is the code snippet how we can achieve and extract aptx info.

Model class generated and modified from xml file

using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;

 // NOTE: Generated code may require at least .NET Framework 4.5 or .NET Core/Standard 2.0.
    /// <remarks/>
    [System.SerializableAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)]
    [System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)]
    public partial class ESRI_ItemInformation: INotifyPropertyChanged
    {

        private string nameField;

        private string guidField;

        private decimal versionField;

        private object createdField;

        private object modifiedField;

        private object catalogpathField;

        private string snippetField;

        private object descriptionField;

        private string summaryField;

        private string titleField;

        private string tagsField;

        private string typeField;

        private string[] typekeywordsField;

        private string thumbnailField;

        private object documentationField;

        private object urlField;

        private object spatialreferenceField;

        private decimal minScaleField;

        private decimal maxScaleField;

        private object datalastModifiedTimeField;

        private object accessinformationField;

        private object licenseinfoField;

        private string cultureField;

        /// <remarks/>
        public string name
        {
            get
            {
                return this.nameField;
            }
            set
            {
                this.nameField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public string guid
        {
            get
            {
                return this.guidField;
            }
            set
            {
                this.guidField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public decimal version
        {
            get
            {
                return this.versionField;
            }
            set
            {
                this.versionField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object created
        {
            get
            {
                return this.createdField;
            }
            set
            {
                this.createdField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object modified
        {
            get
            {
                return this.modifiedField;
            }
            set
            {
                this.modifiedField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object catalogpath
        {
            get
            {
                return this.catalogpathField;
            }
            set
            {
                this.catalogpathField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public string snippet
        {
            get
            {
                return this.snippetField;
            }
            set
            {
                this.snippetField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object description
        {
            get
            {
                return this.descriptionField;
            }
            set
            {
                this.descriptionField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public string summary
        {
            get
            {
                return this.summaryField;
            }
            set
            {
                this.summaryField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public string title
        {
            get
            {
                return this.titleField;
            }
            set
            {
                this.titleField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public string tags
        {
            get
            {
                return this.tagsField;
            }
            set
            {
                this.tagsField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public string type
        {
            get
            {
                return this.typeField;
            }
            set
            {
                this.typeField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        [System.Xml.Serialization.XmlArrayItemAttribute("typekeyword", IsNullable = false)]
        public string[] typekeywords
        {
            get
            {
                return this.typekeywordsField;
            }
            set
            {
                this.typekeywordsField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public string thumbnail
        {
            get
            {
                return this.thumbnailField;
            }
            set
            {
                this.thumbnailField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object documentation
        {
            get
            {
                return this.documentationField;
            }
            set
            {
                this.documentationField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object url
        {
            get
            {
                return this.urlField;
            }
            set
            {
                this.urlField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object spatialreference
        {
            get
            {
                return this.spatialreferenceField;
            }
            set
            {
                this.spatialreferenceField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public decimal minScale
        {
            get
            {
                return this.minScaleField;
            }
            set
            {
                this.minScaleField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public decimal maxScale
        {
            get
            {
                return this.maxScaleField;
            }
            set
            {
                this.maxScaleField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object datalastModifiedTime
        {
            get
            {
                return this.datalastModifiedTimeField;
            }
            set
            {
                this.datalastModifiedTimeField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object accessinformation
        {
            get
            {
                return this.accessinformationField;
            }
            set
            {
                this.accessinformationField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        public object licenseinfo
        {
            get
            {
                return this.licenseinfoField;
            }
            set
            {
                this.licenseinfoField = value;
                this.NotifyPropertyChanged();
            }
        }

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public string Culture
        {
            get
            {
                return this.cultureField;
            }
            set
            {
                this.cultureField = value;
                this.NotifyPropertyChanged();
            }
        }

        public event PropertyChangedEventHandler PropertyChanged = delegate { };

        private void NotifyPropertyChanged([CallerMemberName] string propName = "")
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propName));
        }
    }
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Real fun part extract and load into object, later part you can freely play with object

For below sample, I am using NuGet Gallery | SevenZipExtractor 1.0.15 

ESRI_ItemInformation TemplateInfo ;

using (ArchiveFile archiveFile = new ArchiveFile(templatePath))
            {
                Entry itemInfoEntry = archiveFile.Entries.FirstOrDefault(x => x.FileName.Equals(@"esriinfo\iteminfo.xml", StringComparison.OrdinalIgnoreCase));
                if (itemInfoEntry != null)
                {
                    MemoryStream memoryStream = new MemoryStream();
                    itemInfoEntry.Extract(memoryStream);
                    memoryStream.Position = 0;

                    XmlSerializer serializer = new XmlSerializer(typeof(ESRI_ItemInformation));
                    TemplateInfo = (ESRI_ItemInformation)serializer.Deserialize(memoryStream);
                }
            }‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Original Author: @ChristopherZent 

The GeoDev Webinar Series will be hosting a webinar on ArcGIS Pro SDK Extensibility Patterns on Thursday, July 2nd at 9 AM Pacific Time.  This will be introductory-level webinar and should be helpful for those looking for an overview of the SDK and the main patterns for extending Pro.

More information and registration at:   ArcGIS Pro SDK for .NET: Extensibility Patterns 

ArcGIS Pro‌

Original Author: @ChristopherZent 

Dev Summit technical sessions are now available online!

You can now view all the ArcGIS Pro SDK technical sessions from the 2020 Esri Developer Summit at the Esri Events Channel on YouTube.  A playlist of the SDK videos can be found here and also the individual session descriptions and links are found below.

The sessions are a great way to get introduced to ArcGIS Pro development and extensibility, and to get updates on the latest SDK information and development patterns.  In addition to the videos, the slides for the sessions will also be available on the Proceedings site in the coming weeks.

The Dev Summit was converted to an online virtual event due to the COVID-19 pandemic, and the plenary was hosted live online.

During this year’s plenary, Wolf Kaiser from the SDK Team gave an exciting demonstration of a Pro add-in using the Realtime Stream Layer API to capture transponder flight data for tour helicopters flying over the island of Kauai. Watch here as Wolf walks through the custom tools interacting with the 3D event data and scene, and then shows you how it’s accomplished in the code:

ArcGIS Pro SDK Technical Sessions

Beginning Pro Customization Showing Pro Extensibility Patterns of the SDK

Learn how to customize and extend ArcGIS Pro with its .NET SDK. We’ll show you how you can get up and running quickly with the Add-in, Configuration, Plug-in, and Core Host extensibility patterns and provide an overview of “DAML” the declarative extensibility programming language for ArcGIS Pro.

Developer’s Perspective: Diagnosing issues with Performance and Responsiveness in ArcGIS Pro

ArcMon is a diagnostic tool contained in ArcGIS Pro. ArcMon can help determine GUI Hang, application busy state, forground and background tasks, memory usage, and more. This session will demonstrate troubleshooting performance issues within your add-ins in ArcGIS Pro. We will also go over the usage of other performance evaluators such as the performance overlay in map views, ArcGIS Pro PerfTools and other helpful utilities.

Understanding Feature Services, a Guide for Developers

This is an intermediate level session for developers working with Feature Services in Pro. We will discuss feature service architecture and its relation to data storage and editing capabilities including branch versioning. We will provide guidance and insights into deployment options, authoring, publishing, caching, and dataset naming. We will explore how to work with default and named versions, short and long transaction types, and ramifications for save, undo, and cancel edits.

An Overview of the Utility Network Management API

This session will provide an overview of the utility network APIs for developing custom tools and applications for electric, gas, water and wastewater utilities. Topics to be covered will include accessing utility network metadata, tracing, and editing.

Beginning Editing with Focus on EditOperation

In this introductory session you will learn the development patterns for creating and updating features with the Editing API. We introduce the EditOperation and Inspector classes along with the different edit events. Finally you will learn how to create your own construction tool.

Advanced Editing with Focus on UI Customization

Learn how to add your own custom editing functionality into the Pro UI by creating an advanced modify tool. We show customizing the galleries and integration into the modify dockpanes. Additional topics include the EditOperation callback method, and working with mixed database environments.

Effective Geodatabase Programming

ArcGIS developers build applications that can access and interact with a geodatabase. Learn about key programming techniques and APIs that must be employed when developing high-performance geodatabase applications. This session will focus on issues that will allow developers to be more efficient, write less code, and save time. Explore the correct and effective programming patterns that should be employed when using the geodatabase API.

An Overview of the Geodatabase API

This session will provide an overview of the geodatabase .NET API (ArcGIS.Core.Data) for working with data in ArcGIS Pro, including working with datasets, fields, queries, selections, joins and relates.

Real-time Analysis and Visualization using ArcGIS Pro Real-time API

This session will show how to use the Real-time API to analyze, explore, and visualize events in ArcGIS Pro as they are happening in real time – whether you want to find nearby coffee shops from moving vehicles, or sending geo-fencing alerts or spatial analysis to compute affected areas as natural disaster strikes. The session also covers how to add a stream service, visualize latest and previous locations with separate renderers, limit the number of features drawn on a map based on query filter or by feature count, and draw real-time data on charts and perform analysis with them.

Optimizing Content for 3D: Scene Layers and Developers

Customers are creating and commissioning more 3D content than ever before. Esri users and developers need to advise end users on the tools, patterns, and techniques required to create the best performing 3D content for use in GIS. This presentation will discuss tools in ArcGIS for working with 3D content including common patterns in CityEngine and ArcGIS Pro for examining and converting 3D content. The session will also discuss a planned SDK for developers to generate and optimize I3S content.

Introduction to the Parcel Fabric API

This session introduces the Parcel Fabric API which is in pre-release at 2.5. We’ll cover the information model, concepts and editing patterns. Additionally, we’ll highlight COGO-specific patterns such as using ground to grid corrections and converting between different direction formats.

Enhancing the Managed API using the Cartographic Information Model (CIM)

In this session we strip away some of the mystique surrounding the Cartographic Information Model (CIM). The Managed API exposes commonly used functionality, whereas the CIM pattern allows access to more advanced capabilities. We use examples from maps, layers, and reports but the concepts we cover are broadly applicable to all of the CIM in general.

Demonstrating Pro Extensibility with Partner Add-Ins

Learn about the customization opportunities available with the Pro SDK through a series of demonstrations showcasing add-in products from Esri Business Partners. With each demo, we’ll discuss the user workflow, the different Pro APIs used, and resources for developers interested in building similar capabilities.

ArcGIS Pro

‌

Have noticed that there is arcgis pro sdk OpenItemDialog object which allow developers to use for consistent look and feel like arcgis pro.

Below is the ArcPro github guide.

ProGuide Custom Browse Dialog Filters · Esri/arcgis-pro-sdk Wiki · GitHub 

However if we run into the scenario to get the file types which are not natively support by the sdk.

Actually we can use two other libraries which are provided by microsoft.

For getting folder path - 

using (FolderBrowserDialog tmpDestination = new FolderBrowserDialog())
                {

                    if (tmpDestination.ShowDialog() == DialogResult.OK)
                    {
                        this.InputModel.SourceFolderPath = tmpDestination.SelectedPath;
                        
                                            
                    }
                }‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Help doco of that class : FolderBrowserDialog Class (System.Windows.Forms) | Microsoft Docs 

That will look like this.

For getting file for specific extension - like excel files. 

OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.Filter = "Excel Files|*.xls;*.xlsx;*.xlsm";
                if (openFileDialog.ShowDialog() == DialogResult.OK)
                {              

                   //lets move on with 
string filePath = openFileDialog.FileName;
                }‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Help doco of that class :OpenFileDialog Class (System.Windows.Forms) | Microsoft Docs 

That will look like this.

All in all the point is that ArcGIS pro sdk is based on the wpf c#, so sometime if sdk don't have build in functionality, we can always go back to foundation to base libraries of wpf and sample out there may be in stackoverflow especially UI customization and, thread management. 

Feel free to comment, it is just my first blog because noticed that could give some ideas to the developer who does not know much about wpf development or .net framework area.

Original Author: @ChristopherZent 

ArcGIS Pro developers are doing great work developing add-ins with the ArcGIS Pro SDK for Microsoft .NET.  They’ve been building on new capabilities with each release of Pro, most recently with ArcGIS Pro 2.5 and the 2.5 SDK updates we announced previously.

This new release of the SDK builds on previous Pro releases, with several new opportunities for developers to enhance and extend Pro with unique tools and workflows.

Distributing Pro Add-Ins

As you and your organization complete a new Pro add-in, you may want to make it publicly available online.  To help with this process, there is a new ProConcepts Distributing Add-Ins Online document online with the SDK documentation updated at 2.5.

There are two main approaches to distributing your add-in online via Esri websites – ArcGIS Online and the ArcGIS Marketplace.

For any organization that would like to distribute a free Pro add-in, ArcGIS Online is available with an item listing. For Esri Partners, the ArcGIS Marketplace is a location to register as an approved Marketplace Provider and create listings for products and solutions, both free and for sale.

ArcGIS Online Item

An ArcGIS Pro add-in can be easily shared via ArcGIS Online. Creating an item listing is straight-forward to set up and can be posted and available in minutes.  There are several Pro add-in listings on ArcGIS.com.

The new ProConcepts document lists a couple Esri add-in item listing pages which you can check for ideas, and provides tips and links to help you create your own listing.

A new sample ArcGIS Pro add-in item listing:

ArcGIS Marketplace Listing

If you are an Esri Business Partner, an Esri Emerging Business Partner, or Esri Distributor, you can register to become an ArcGIS Marketplace Provider, and create a listing for your add-in on the ArcGIS Marketplace.

The ArcGIS Marketplace allows ArcGIS users to search, discover, and acquire apps, content, solutions, and professional services from Marketplace providers.  We included some updates on a few of the providers that have listed exciting new Pro add-ins in the last Pro extensibility review.

If you are an Esri Partner, you can find out more on how to become a Marketplace provider here.

A few ArcGIS Marketplace Pro add-In listings:

Getting Started

It’s a great time to get started building add-ins to take advantage of all the capabilities of ArcGIS Pro 2.5.  Check out the resources available at the Pro SDK landing page.  You can also collaborate with other developers here in the GeoNet Pro SDK Group where you can ask technical questions and learn more.

Also, for online instructor-led training, the official Pro SDK course, Extending ArcGIS Pro with Add-Ins, is available with several scheduled dates.  The course is also available for scheduling at your organization.  The course provides a thorough introduction to help jump-start your development work with Pro.

Finally, the Developer Summit technical session recordings will soon be available online, and we’ll follow up with a post with links to all the Pro SDK sessions.  The sessions are a great resource for information on SDK patterns, updates and best practices.

ArcGIS Pro‌

Original Author: @ChristopherZent 

The Esri Developer Summit 2020 in Palm Springs is almost here, scheduled March 10^th – 13^th.  Once again, many teams have been working to provide a comprehensive line-up of offerings to help you get up to speed with the ArcGIS Pro SDK for .NET, and caught up with the latest features and patterns.

Below is a list of the many Pro SDK learning opportunities with links to all the details.  There will also be many ArcGIS Pro introductory and advanced-level sessions available at Dev Summit.  You can search the online agenda here.

Finally, plan to visit the ArcGIS Pro Area in the Esri Showcase to speak with Pro team members, including the SDK team.  See demos of the latest features with ArcGIS Pro 2.5, ask your questions and discuss your plans for using and customizing Pro.

We look forward to seeing you at Dev Summit!

Pre-Summit Hands-On Training

Introduction to Programming with the ArcGIS Pro SDK for .NET

This two-day hands-on training workshop is a great way to get started learning and using the Pro SDK.  It often fills up quickly, although depending on availability you can still register right up to the day of the training.  See the link above to register.

Technical Sessions

Note:  Most session titles are led by “ArcGIS Pro SDK for .NET” in the online agenda.

Tuesday, March 10^th

Beginning Pro Customization Showing Pro Extensibility Patterns of the SDK

Learn how to customize and extend ArcGIS Pro with its .NET SDK. We’ll show you how you can get up and running quickly with the Add-in, Configuration, Plug-in, and Core Host extensibility patterns and provide an overview of “DAML” the declarative extensibility programming language for ArcGIS Pro.

Demonstrating Pro Extensibility with Partner Add-Ins

Learn about the customization opportunities available with the Pro SDK through a series of demonstrations showcasing add-in products from Esri Business Partners. With each demo, we’ll discuss the user workflow, the different Pro APIs used, and resources for developers interested in building similar capabilities.

Developer’s Perspective: Diagnosing issues with Performance and Responsiveness in ArcGIS Pro

ArcMon is a diagnostic tool contained in ArcGIS Pro. ArcMon can help determine GUI Hang, application busy state, forground and background tasks, memory usage, and more. This session will demonstrate troubleshooting performance issues within your add-ins in ArcGIS Pro. We will also go over the usage of other performance evaluators such as the performance overlay in map views, ArcGIS Pro PerfTools and other helpful utilities.

Wednesday, March 11^th

Introduction to the Parcel Fabric API

This session introduces the Parcel Fabric API which is in pre-release at 2.5. We’ll cover the information model, concepts and editing patterns. Additionally, we’ll highlight COGO-specific patterns such as using ground to grid corrections and converting between different direction formats.

Understanding Feature Services, a Guide for Developers

This is an intermediate level session for developers working with Feature Services in Pro. We will discuss feature service architecture and its relation to data storage and editing capabilities including branch versioning. We will provide guidance and insights into deployment options, authoring, publishing, caching, and dataset naming. We will explore how to work with default and named versions, short and long transaction types, and ramifications for save, undo, and cancel edits.

An Overview of the Utility Network Management API

This session will provide an overview of the utility network APIs for developing custom tools and applications for electric, gas, water and wastewater utilities. Topics to be covered will include accessing utility network metadata, tracing, and editing.

Beginning Editing with Focus on EditOperation

In this introductory session you will learn the development patterns for creating and updating features with the Editing API. We introduce the EditOperation and Inspector classes along with the different edit events. Finally you will learn how to create your own construction tool.

Advanced Editing with Focus on UI Customization

Learn how to add your own custom editing functionality into the Pro UI by creating an advanced modify tool. We show customizing the galleries and integration into the modify dockpanes. Additional topics include the EditOperation callback method, and working with mixed database environments.

Effective Geodatabase Programming

ArcGIS developers build applications that can access and interact with a geodatabase. Learn about key programming techniques and APIs that must be employed when developing high-performance geodatabase applications. This session will focus on issues that will allow developers to be more efficient, write less code, and save time. Explore the correct and effective programming patterns that should be employed when using the geodatabase API.

Thursday, March 12^th

An Overview of the Geodatabase API

This session will provide an overview of the geodatabase .NET API (ArcGIS.Core.Data) for working with data in ArcGIS Pro, including working with datasets, fields, queries, selections, joins and relates.

Real-time Analysis and Visualization using ArcGIS Pro Real-time API

This session will show how to use the Real-time API to analyze, explore, and visualize events in ArcGIS Pro as they are happening in real time – whether you want to find nearby coffee shops from moving vehicles, or sending geo-fencing alerts or spatial analysis to compute affected areas as natural disaster strikes. The session also covers how to add a stream service, visualize latest and previous locations with separate renderers, limit the number of features drawn on a map based on query filter or by feature count, and draw real-time data on charts and perform analysis with them.

Friday, March 13^th

Enhancing the Managed API using the Cartographic Information Model (CIM)

In this session we strip away some of the mystique surrounding the Cartographic Information Model (CIM). The Managed API exposes commonly used functionality, whereas the CIM pattern allows access to more advanced capabilities. We use examples from maps, layers, and reports but the concepts we cover are broadly applicable to all of the CIM in general.

Demo Theater Sessions

Tuesday, March 10^th

Working with Rasters and Imagery

Learn how to use the ArcGIS Pro SDK with Imagery and Raster data to create compelling add-ins. Developers can use the ArcGIS Pro SDK to control how their imagery and raster data is displayed, read/write pixels and properties and control how data is processed.

Getting Started

We’ll cover beginner demos on installing the Pro SDK in Microsoft Visual Studio and building your first Pro add-ins with C#. We’ll review how to leverage the community samples as a foundation for your add-ins, and walk through the online resources.

Thursday, March 12^th

Working with Geometry

From points and multipoints to segments, polylines and polygons, we will investigate and discover how to construct and manipulate geometries using the geometry builder objects. We will also introduce the GeometryEngine for performing spatial operations such as Union, Touches, Cut, Clip and more.

Developing Pro Add-ins with Oriented Imagery

Learn how the ArcGIS Oriented Imagery add-In was developed and how to develop similar capabilities in your add-ins. We’ll provide demonstrations on building code that allows users to add and work with new imagery datasets in Pro, as well as work with the built-in Chromium browser. As a developer you can incorporate oriented imagery content in Pro, and access and work with the content with add-in tools.

ArcGIS Pro Road Ahead Technical Sessions

The Road Ahead: ArcGIS Pro – Tuesday, March 10^th  and Thursday, March 12^th

Learn about what’s new in the latest release of ArcGIS Pro and what’s coming in the next release. Members of the ArcGIS Pro development team will share an early look at new and improved capabilities in ArcGIS Pro.

ArcGIS Pro‌

Original Author: @ChristopherZent 

ArcGIS Pro 2.5 is now available, and included are many new updates to the ArcGIS Pro SDK for Microsoft .NET.

This new release of the SDK builds on previous Pro releases, with several new opportunities for developers to enhance and extend Pro with unique tools and workflows.   Let’s take a look at some of the highlights of the release.

Content API

New at 2.5, developers can create and configure browse dialog filters to better control what users can browse to within Pro.  This can help to focus and tailor the Pro UI for users, to save time and ensure the accuracy of your workflows.  The new capabilities are discussed in the Browse Dialog Filters section of the Content ProConcepts document.  Also, there’s a new ProGuide Custom Browse Dialog Filters document which walks you through how to get started.   There’s also a new community sample you can try and use with your own add-ins.

Also, the new browse filter builds on earlier custom items capabilities, find out more about those in the Concepts and Guide documents.

The Browse Filters community sample:

Geometry API

2.5 brings new support for writing multipatch features, with the ability to update geometry, and apply materials and textures.  The new capabilities provide developers with the ability to create tools for building 3D content that are focused around specific organizational needs.

There are a series of new code snippets available, as well as a new community sample which allows you to explore the capabilities.

An example of extending Pro with a custom multipatch editing workflow:

Parcel Fabric API Pre-Release

At 2.5, developers can try the pre-release version of the Parcel Fabric API, which will allow developers to create record-driven workflows with parcel-aware editing capabilities.  The full, supported release is targeted for availability at 2.6.

The parcel fabric is a comprehensive framework of functionality in ArcGIS for modeling parcels in organizations ranging from national cadastral agencies to local governments, and is commonly used in conjunction with the geodatabase and editing workflows.

Developers can begin to try out the pre-release capabilities with the help of a new ProConcepts document, code snippets, and a new community sample.

The Parcel Fabric 3D Editing community sample:

Other API Enhancements

New classes and methods available in the Editing, Geodatabase, Map Authoring and Raster APIs.

For a full listing of all the API changes, see the What’s New for Developers at 2.5 page in the Pro API reference.

New code samples and documentation

Finally, to help you get started quickly with the new capabilities, the team has developed several new code samples which can be found at the community samples site, as well as code snippets and other updated concept and guide documentation, which can all be found at the SDK documentation site.

For more information on all the exciting updates in ArcGIS Pro 2.5, see the What’s New page, which also includes a new video highlighting new functionality.  We hope it will give you lots of new ideas on the great work you can do in using and extending Pro 2.5.

Collaborate and Share your Feedback

As always, we invite you to send us your feedback and needs for the Pro SDK.  Let us know, find out more and collaborate with others here in the GeoNet Pro SDK Group.  

We’ll have updates soon on all the SDK learning opportunities available at the Esri Developer Summit in Palm Springs, where we look forward to showing you more.

ArcGIS Pro‌