ArcEngine控制台应用程序

控制台应用程序相比其他应用程序，更加简单，简化了许多冗余，可以让我们更加关注于本质的东西。
现在让我们看一看ArcGIS Engine的控制台应用程序吧！

一、首先是许可绑定：
  1、运行时环境的绑定

   

    ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);

    2、AO的许可级别

    

 IAoInitialize aoInitialize = new AoInitializeClass();
 esriLicenseStatus licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
 if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
            {
                Console.WriteLine("Unable to check-out an ArcInfo license, error code is {0}", licenseStatus);
                return;
            }

  二、接下来就可以写我们的程序啦。

using System;
using System.IO;
using System.Runtime.InteropServices;
using ESRI.ArcGIS.ADF;
using ESRI.ArcGIS.DataSourcesGDB;
using ESRI.ArcGIS.esriSystem;
using ESRI.ArcGIS.Geodatabase;
using ESRI.ArcGIS.Geometry;

namespace CursorDemo
{
    public class CursorDemo
    {
        public static void Main(string[] args)
        {
            #region Licensing
            ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
            // Set up the licencing. NOTE: This sample assumes that you are using ArcInfo Desktop.
            // You will need to adjust this code if using ArcEngine or ArcEditor.
            IAoInitialize aoInitialize = new AoInitializeClass();
            esriLicenseStatus licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
            if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
            {
                Console.WriteLine("Unable to check-out an ArcInfo license, error code is {0}", licenseStatus);
                return;
            }
            #endregion

            // If test data exists from a previous run, delete it.
            if (Directory.Exists("CursorDemo.gdb"))
            {
                Directory.Delete("CursorDemo.gdb", true);
            }

            // Copy the test data from this section's Data directory.
            Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory");
            IWorkspaceFactory workspaceFactory = (IWorkspaceFactory)Activator.CreateInstance(factoryType);
            IWorkspaceName sourceWorkspaceName = new WorkspaceNameClass
            {
                PathName = @"..\..\..\Data\CursorDemo.gdb",
                WorkspaceFactoryProgID = "esriDataSourcesGDB.FileGDBWorkspaceFactory"
            };
            IWorkspaceName copiedWorkspaceName = null;
            workspaceFactory.Copy(sourceWorkspaceName, Environment.CurrentDirectory, out copiedWorkspaceName);

            // Open the copied data.
            IName copiedName = (IName)copiedWorkspaceName;
            IWorkspace workspace = (IWorkspace)copiedName.Open();
            IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;

            // Open the two feature classes used in this demo.
            IFeatureClass parcelsFeatureClass = featureWorkspace.OpenFeatureClass("Parcels");
            IFeatureClass pipesFeatureClass = featureWorkspace.OpenFeatureClass("Pipes");

            // The first demo, SearchCursorDemo, will display the Parcel IDs of all residential
            // parcels within a certain extent.
            SearchCursorDemo(parcelsFeatureClass);

            // The second demo, UpdateCursorDemo, will change the all parcels zoned as "Manufacturing"
            // to "Commercial".
            UpdateCursorDemo(workspace, parcelsFeatureClass);

            // The third demo, InsertCursorDemo, will create one hundred new pipe features using
            // an insert cursor.
            InsertCursorDemo(workspace, pipesFeatureClass);

            // Shutdown the licensing.
            aoInitialize.Shutdown();
        }

        /// <summary>
        /// This sample queries a feature class of parcels, finding the Parcel IDs of all residential
        /// features that are within a given extent.
        /// </summary>
        /// <param name="featureClass">The feature class to query.</param>
        private static void SearchCursorDemo(IFeatureClass featureClass)
        {
            // Create an envelope that will define the spatial extent of the query.
            IEnvelope envelope = new EnvelopeClass();
            envelope.PutCoords(506000, 684500, 506500, 685000);

            // Create a new spatial filter.
            ISpatialFilter spatialFilter = new SpatialFilterClass
            {
                Geometry = envelope,
                GeometryField = featureClass.ShapeFieldName,
                SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects,
                SubFields = "Parcel_ID",
                WhereClause = "ZONING_S = 'R'"
            };

            // Find the index of the Parcel_ID field. This is required to display the query results.
            int parcelIdIndex = featureClass.FindField("Parcel_ID");

            using (ComReleaser comReleaser = new ComReleaser())
            {
                // Query the feature class to get a feature cursor. We can use a recycling
                // cursor because we're only going to be reading the data.
                IFeatureCursor featureCursor = featureClass.Search(spatialFilter, true);
                comReleaser.ManageLifetime(featureCursor);

                // Iterate through the query results.
                IFeature feature = null;
                while ((feature = featureCursor.NextFeature()) != null)
                {
                    // Display the current feature's Parcel ID.
                    Console.WriteLine("Parcel found: {0}", feature.get_Value(parcelIdIndex));
                }
                // Display the number of feature matching the query.
                Console.WriteLine("Parcels found: {0}", featureClass.FeatureCount(spatialFilter));
            }
        }

        /// <summary>
        /// This sample re-zones all "Manufacturing" parcels as "Commercial".
        /// </summary>
        /// <param name="workspace">The workspace containing the feature class.</param>
        /// <param name="featureClass">The feature class to update.</param>
        private static void UpdateCursorDemo(IWorkspace workspace, IFeatureClass featureClass)
        {
            // Create a new query filter for the update.
            IQueryFilter queryFilter = new QueryFilterClass { WhereClause = "ZONING_S = 'M'" };

            // Display the feature's zoned as Manufacturing.
            Console.WriteLine("Parcel found zoned as Manufacturing: {0}", featureClass.FeatureCount(queryFilter));

            // Find the index of the Zoning_S field. This is required for the update.
            int zoningIndex = featureClass.FindField("ZONING_S");

            // Start a new edit session and edit operation.
            IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)workspace;
            workspaceEdit.StartEditing(true);
            workspaceEdit.StartEditOperation();

            using (ComReleaser comReleaser = new ComReleaser())
            {
                // Query the feature class to get a feature cursor. Since we are performing
                // updates, we should use a non-recycling cursor.
                IFeatureCursor featureCursor = featureClass.Update(queryFilter, false);
                comReleaser.ManageLifetime(featureCursor);

                try
                {
                    // Iterate through the query results.
                    IFeature feature = null;
                    while ((feature = featureCursor.NextFeature()) != null)
                    {
                        // Change the feature's ZONING_S value to "B" (the code for Business/Commercial).
                        feature.set_Value(zoningIndex, "B");

                        // Update the feature.
                        featureCursor.UpdateFeature(feature);
                    }

                    // All of the features were successfully updated; stop the edit operation
                    // and stop the edit session, saving the changes made in edit operations.
                    workspaceEdit.StopEditOperation();
                    workspaceEdit.StopEditing(true);
                }
                catch (COMException)
                {
                    // An error occurred while editing. Abort the edit operation and stop the
                    // edit session, discarding any changes made in edit operations.
                    workspaceEdit.AbortEditOperation();
                    workspaceEdit.StopEditing(false);
                }

                // Display the feature's zoned as Manufacturing after update.
                Console.WriteLine("Parcel found zoned as Manufacturing after update: {0}", featureClass.FeatureCount(queryFilter));
            }
        }

        /// <summary>
        /// This sample uses an insert cursor to create one hundred new pipe features.
        /// </summary>
        /// <param name="workspace">The workspace containing the feature class.</param>
        /// <param name="featureClass">The feature class to insert new features into.</param>
        private static void InsertCursorDemo(IWorkspace workspace, IFeatureClass featureClass)
        {
            // Find the index of the "Contractor" field. This will be edited in the new features.
            int contractorIndex = featureClass.FindField("CONTRACTOR");

            // Put the feature class into "load-only" mode. In a File GDB, this will disable spatial
            // and attribute indexing, improving performance for data loading.
            IFeatureClassLoad featureClassLoad = (IFeatureClassLoad)featureClass;
            featureClassLoad.LoadOnlyMode = true;

            // Start an edit session and edit operation.
            IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)workspace;
            workspaceEdit.StartEditing(true);
            workspaceEdit.StartEditOperation();

            // Open the two text files containing the contractor's data.
            using (StreamReader geometryReader = new StreamReader(@"PipeGeo.csv"))
            using (StreamReader attributeReader = new StreamReader(@"PipeAttr.csv"))
            using (ComReleaser comReleaser = new ComReleaser())
            {
                // Create a new insert cursor with buffering.
                IFeatureCursor featureCursor = featureClass.Insert(true);
                comReleaser.ManageLifetime(featureCursor);

                // Create a feature buffer. This will store the values common to every
                // feature to be installed.
                IFeatureBuffer featureBuffer = featureClass.CreateFeatureBuffer();
                comReleaser.ManageLifetime(featureBuffer);
                featureBuffer.set_Value(contractorIndex, "B Pierce");

                try
                {
                    while (!geometryReader.EndOfStream && !attributeReader.EndOfStream)
                    {
                        // Read the next line from each text file.
                        String geometryData = geometryReader.ReadLine();
                        String attributeData = attributeReader.ReadLine();

                        // Set the geometry and attribute values of the feature buffer.
                        featureBuffer.Shape = ConstructGeometryFromString(geometryData);
                        PopulateAttributeValues(featureBuffer, attributeData);

                        // Insert a new feature using the feature buffer.
                        featureCursor.InsertFeature(featureBuffer);
                    }

                    // Flush the cursor.
                    featureCursor.Flush();

                    // All of the features were successfully inserted; stop the edit operation
                    // and stop the edit session, saving the changes made in edit operations.
                    workspaceEdit.StopEditOperation();
                    workspaceEdit.StopEditing(true);
                }
                catch (COMException)
                {
                    // An error occurred while editing. Abort the edit operation and stop the
                    // edit session, discarding any changes made in edit operations.
                    workspaceEdit.AbortEditOperation();
                    workspaceEdit.StopEditing(false);
                }
            }

            // Take the class out of load-only mode.
            featureClassLoad.LoadOnlyMode = false;
        }

        /// <summary>
        /// This method converts a comma-delimited set of numeric values into a polyline.
        /// </summary>
        /// <param name="input">A string of comma-delimited numeric values.</param>
        /// <returns>A polyline.</returns>
        private static IGeometry ConstructGeometryFromString(String input)
        {
            // Split the input string into individual values.
            String[] inputValues = input.Split(new char[] { ',' });

            // Create a new polyline.
            IPolyline polyline = new PolylineClass();
            IGeometryCollection geometryCollection = (IGeometryCollection)polyline;

            // Each set of four values represents one segment of a polyline.
            int segmentCount = inputValues.Length / 4;
            int inputValuePosition = 0;
            for (int i = 0; i < segmentCount; i++)
            {
                // This value is required for geometry construction.
                object missingType = Type.Missing;

                // Construct the segment.
                IPoint fromPoint = new PointClass
                {
                    X = Double.Parse(inputValues[inputValuePosition++]),
                    Y = Double.Parse(inputValues[inputValuePosition++])
                };
                IPoint toPoint = new PointClass
                {
                    X = Double.Parse(inputValues[inputValuePosition++]),
                    Y = Double.Parse(inputValues[inputValuePosition++])
                };
                IPath path = new PathClass();
                IPointCollection pointCollection = (IPointCollection)path;
                pointCollection.AddPoint(fromPoint, ref missingType, ref missingType);
                pointCollection.AddPoint(toPoint, ref missingType, ref missingType);

                // Add the segment to the collection.
                geometryCollection.AddGeometry(path, ref missingType, ref missingType);
            }

            // Return the constructed polyline.
            return polyline;
        }

        /// <summary>
        /// Populates the inbound feature buffer with the comma-delimited values
        /// in the input string.
        /// </summary>
        /// <param name="featureBuffer">The feature buffer to populate.</param>
        /// <param name="input">A string containing attribute values.</param>
        private static void PopulateAttributeValues(IFeatureBuffer featureBuffer, String input)
        {
            // Split the input string into individual values.
            String[] inputValues = input.Split(new char[] { ',' });

            // Set the values of the Date_Installed, material and diameter fields.
            // For the sake of simplicity, we'll hard-code the values here.
            featureBuffer.set_Value(2, inputValues[0]);
            featureBuffer.set_Value(4, inputValues[1]);
            featureBuffer.set_Value(5, inputValues[2]);
        }
    }
}