ProSnippets Geodatabase
Language: C#
Subject: Geodatabase
Contributor: ArcGIS Pro SDK Team <arcgisprosdk@esri.com>
Organization: esri, http://www.esri.com
Date: 10/22/2024
ArcGIS Pro: 3.4
Visual Studio: 2022
.NET Target Framework: .Net 8
public async Task OpenFileGDB()
{
try
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
// Opens a file geodatabase. This will open the geodatabase if the folder exists and contains a valid geodatabase.
using (
Geodatabase geodatabase =
new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb"))))
{
// Use the geodatabase.
}
});
}
catch (GeodatabaseNotFoundOrOpenedException exception)
{
// Handle Exception.
}
}public async Task OpenEnterpriseGeodatabase()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
// Opening a Non-Versioned SQL Server instance.
DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
Instance = @"testMachine\testInstance",
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
Database = "LocalGovernment",
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
User = "gdb",
Password = "password",
Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
{
// Use the geodatabase
}
});
}public async Task OpenEnterpriseGeodatabaseUsingSDEFilePath()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
{
// Use the geodatabase.
}
});
}public async Task ObtainingGeodatabaseFromProjectItem()
{
IEnumerable<GDBProjectItem> gdbProjectItems = Project.Current.GetItems<GDBProjectItem>();
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
foreach (GDBProjectItem gdbProjectItem in gdbProjectItems)
{
using (Datastore datastore = gdbProjectItem.GetDatastore())
{
//Unsupported datastores (non File GDB and non Enterprise GDB) will be of type UnknownDatastore
if (datastore is UnknownDatastore)
continue;
Geodatabase geodatabase = datastore as Geodatabase;
// Use the geodatabase.
}
}
});
}DatabaseConnectionFile connectionFile = new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"));
DatabaseConnectionProperties connectionProperties = DatabaseClient.GetDatabaseConnectionProperties(connectionFile);
// Now you could, for example, change the user name and password in the connection properties prior to use them to open a geodatabasepublic async Task ObtainingGeodatabaseFromFeatureLayer()
{
IEnumerable<Layer> layers = MapView.Active.Map.Layers.Where(layer => layer is FeatureLayer);
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
foreach (FeatureLayer featureLayer in layers)
{
using (Table table = featureLayer.GetTable())
using (Datastore datastore = table.GetDatastore())
{
if (datastore is UnknownDatastore)
continue;
Geodatabase geodatabase = datastore as Geodatabase;
}
}
});
}// Executes raw SQL on the underlying database management system.
// Any SQL is permitted (DDL or DML), but no results can be returned
public void ExecuteSQLOnGeodatabase(Geodatabase geodatabase, string statement)
{
QueuedTask.Run(() =>
{
DatabaseClient.ExecuteStatement(geodatabase, statement);
});
}public async Task ObtainingDefinitionFromGeodatabase()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
{
// Remember that for Enterprise databases you have to qualify your dataset names with the DatabaseName and UserName.
TableDefinition enterpriseTableDefinition = geodatabase.GetDefinition<TableDefinition>("LocalGovernment.GDB.CitizenContactInfo");
// It does not matter if the dataset is within a FeatureDataset or not.
FeatureClassDefinition featureClassDefinition = geodatabase.GetDefinition<FeatureClassDefinition>("LocalGovernment.GDB.FireStation");
// GetDefinition For a RelationshipClass.
RelationshipClassDefinition relationshipClassDefinition = geodatabase.GetDefinition<RelationshipClassDefinition>("LocalGovernment.GDB.AddressPointHasSiteAddresses");
// GetDefinition For a FeatureDataset.
FeatureDatasetDefinition featureDatasetDefinition = geodatabase.GetDefinition<FeatureDatasetDefinition>("LocalGovernment.GDB.Address");
}
});
}public async Task ObtainingDefinitionsFromGeodatabase()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
{
IReadOnlyList<FeatureClassDefinition> enterpriseDefinitions = geodatabase.GetDefinitions<FeatureClassDefinition>();
IEnumerable<Definition> featureClassesHavingGlobalID = enterpriseDefinitions.Where(definition => definition.HasGlobalID());
IReadOnlyList<FeatureDatasetDefinition> featureDatasetDefinitions = geodatabase.GetDefinitions<FeatureDatasetDefinition>();
bool electionRelatedFeatureDatasets = featureDatasetDefinitions.Any(definition => definition.GetName().Contains("Election"));
IReadOnlyList<AttributedRelationshipClassDefinition> attributedRelationshipClassDefinitions = geodatabase.GetDefinitions<AttributedRelationshipClassDefinition>();
IReadOnlyList<RelationshipClassDefinition> relationshipClassDefinitions = geodatabase.GetDefinitions<RelationshipClassDefinition>();
}
});
}public async Task ObtainingRelatedDefinitionsFromGeodatabase()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
{
// Remember the qualification of DatabaseName. for the RelationshipClass.
RelationshipClassDefinition enterpriseDefinition = geodatabase.GetDefinition<RelationshipClassDefinition>("LocalGovernment.GDB.AddressPointHasSiteAddresses");
IReadOnlyList<Definition> enterpriseDefinitions = geodatabase.GetRelatedDefinitions(enterpriseDefinition, DefinitionRelationshipType.DatasetsRelatedThrough);
FeatureClassDefinition enterpriseAddressPointDefinition = enterpriseDefinitions.First(defn => defn.GetName().Equals("LocalGovernment.GDB.AddressPoint"))
as FeatureClassDefinition;
FeatureDatasetDefinition featureDatasetDefinition = geodatabase.GetDefinition<FeatureDatasetDefinition>("LocalGovernment.GDB.Address");
IReadOnlyList<Definition> datasetsInAddressDataset = geodatabase.GetRelatedDefinitions(featureDatasetDefinition, DefinitionRelationshipType.DatasetInFeatureDataset);
FeatureClassDefinition addressPointInAddressDataset = datasetsInAddressDataset.First(defn => defn.GetName().Equals("LocalGovernment.GDB.AddressPoint"))
as FeatureClassDefinition;
RelationshipClassDefinition addressPointHasSiteAddressInAddressDataset = datasetsInAddressDataset.First(defn => defn.GetName().Equals("LocalGovernment.GDB.AddressPointHasSiteAddresses"))
as RelationshipClassDefinition;
}
});
}// GetDefinitionFromLayer - This code works even if the layer has a join to another table
private TableDefinition GetDefinitionFromLayer(FeatureLayer featureLayer)
{
// Get feature class from the layer
FeatureClass featureClass = featureLayer.GetFeatureClass();
// Determine if feature class is a join
if (featureClass.IsJoinedTable())
{
// Get join from feature class
Join join = featureClass.GetJoin();
// Get origin table from join
Table originTable = join.GetOriginTable();
// Return feature class definition from the join's origin table
return originTable.GetDefinition();
}
else
{
return featureClass.GetDefinition();
}
}public async Task OpeningDatasetsFromGeodatabase()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
{
using (Table table = geodatabase.OpenDataset<Table>("LocalGovernment.GDB.EmployeeInfo"))
{
}
// Open a featureClass (within a feature dataset or outside a feature dataset).
using (FeatureClass featureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.AddressPoint"))
{
}
// You can open a FeatureClass as a Table which will give you a Table Reference.
using (Table featureClassAsTable = geodatabase.OpenDataset<Table>("LocalGovernment.GDB.AddressPoint"))
{
// But it is really a FeatureClass object.
FeatureClass featureClassOpenedAsTable = featureClassAsTable as FeatureClass;
}
// Open a FeatureDataset.
using (FeatureDataset featureDataset = geodatabase.OpenDataset<FeatureDataset>("LocalGovernment.GDB.Address"))
{
}
// Open a RelationsipClass. Just as you can open a FeatureClass as a Table, you can also open an AttributedRelationshipClass as a RelationshipClass.
using (RelationshipClass relationshipClass = geodatabase.OpenDataset<RelationshipClass>("LocalGovernment.GDB.AddressPointHasSiteAddresses"))
{
}
}
});
}// Must be called within QueuedTask.Run9)
public bool TableExists(Geodatabase geodatabase, string tableName)
{
try
{
TableDefinition tableDefinition = geodatabase.GetDefinition<TableDefinition>(tableName);
tableDefinition.Dispose();
return true;
}
catch
{
// GetDefinition throws an exception if the definition doesn't exist
return false;
}
}// Must be called within QueuedTask.Run()
public bool FeatureClassExists(Geodatabase geodatabase, string featureClassName)
{
try
{
FeatureClassDefinition featureClassDefinition = geodatabase.GetDefinition<FeatureClassDefinition>(featureClassName);
featureClassDefinition.Dispose();
return true;
}
catch
{
// GetDefinition throws an exception if the definition doesn't exist
return false;
}
}// Must be called within QueuedTask.Run().
// When used with file or enterprise geodatabases, this routine takes two table names.
// When used with feature services, this routine takes layer IDs, or the names of the tables as they are exposed through the service (e.g., "L0States")
public IReadOnlyList<RelationshipClass> OpenRelationshipClassFeatureServices(Geodatabase geodatabase, string originClass, string destinationClass)
{
return geodatabase.OpenRelationshipClasses(originClass, destinationClass);
}public async Task GetFeatureClassesInRelationshipClassAsync()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb"))))
{
IReadOnlyList<RelationshipClassDefinition> relationshipClassDefinitions = geodatabase.GetDefinitions<RelationshipClassDefinition>();
foreach (RelationshipClassDefinition relationshipClassDefinition in relationshipClassDefinitions)
{
IReadOnlyList<Definition> definitions = geodatabase.GetRelatedDefinitions(relationshipClassDefinition, DefinitionRelationshipType.DatasetsRelatedThrough);
foreach (Definition definition in definitions)
{
System.Diagnostics.Debug.WriteLine($"Feature class in the RelationshipClass is:{definition.GetName()}");
}
}
}
});
}public async Task OpenShapefileFeatureClass()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
FileSystemConnectionPath fileConnection = new FileSystemConnectionPath(new Uri("path\\to\\folder\\containing\\shapefiles"), FileSystemDatastoreType.Shapefile);
using (FileSystemDatastore shapefile = new FileSystemDatastore(fileConnection))
{
FeatureClass taxLotsFeatureClass = shapefile.OpenDataset<FeatureClass>("TaxLots");
FeatureClass manHolesFeatureClass = shapefile.OpenDataset<FeatureClass>("ManHoles.shp"); // Can use the .shp extension, but its not needed.
Table taxDetailsTableWithoutExtension = shapefile.OpenDataset<Table>("TaxDetails");
Table taxDetailsTable = shapefile.OpenDataset<Table>("TaxDetails.dbf");
}
});
}public async Task OpenCADFeatureClass()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
FileSystemConnectionPath fileConnection = new FileSystemConnectionPath(new Uri("path\\to\\folder\\containing\\CAD"), FileSystemDatastoreType.Cad);
using (FileSystemDatastore cadDatastore = new FileSystemDatastore(fileConnection))
{
// note - extension is required
FeatureClass cadDataset = cadDatastore.OpenDataset<FeatureClass>("hatchplayboundaries.dwg");
// take note of the pattern for referencing a feature class.
FeatureClass cadfeatureClass = cadDatastore.OpenDataset<FeatureClass>("hatchplayboundaries.dwg:Polyline");
int numRows = 0;
using (RowCursor cursor = cadfeatureClass.Search())
{
while (cursor.MoveNext())
numRows++;
}
}
});
}public async Task SearchingATable()
{
try
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (Table table = geodatabase.OpenDataset<Table>("EmployeeInfo"))
{
QueryFilter queryFilter = new QueryFilter
{
WhereClause = "COSTCTRN = 'Information Technology'",
SubFields = "KNOWNAS, OFFICE, LOCATION",
PostfixClause = "ORDER BY OFFICE"
};
using (RowCursor rowCursor = table.Search(queryFilter, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
string location = Convert.ToString(row["LOCATION"]);
string knownAs = Convert.ToString(row["KNOWNAS"]);
}
}
}
}
});
}
catch (GeodatabaseFieldException fieldException)
{
// One of the fields in the where clause might not exist. There are multiple ways this can be handled:
// Handle error appropriately
}
catch (Exception exception)
{
// logger.Error(exception.Message);
}
}using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (Table table = geodatabase.OpenDataset<Table>("TableWithChineseCharacters"))
{
// This will fail with many database systems that expect Latin characters by default
string incorrectWhereClause = "颜色 = '绿'";
// Correct solution is to prepend the 'National String Prefix' to the attribute value
// For example, with SQL Server this value is 'N'
// This value is obtained using the SQLSyntax class
string nationalStringPrefix = "";
SQLSyntax sqlSyntax = geodatabase.GetSQLSyntax();
nationalStringPrefix = sqlSyntax.GetSupportedStrings(SQLStringType.NationalStringPrefix).First();
// This Where clause will work
QueryFilter queryFilter = new QueryFilter()
{
WhereClause = "颜色 = " + nationalStringPrefix + "'绿'"
};
}public RowCursor SearchingATable(Table table, IReadOnlyList<long> objectIDs)
{
QueryFilter queryFilter = new QueryFilter()
{
ObjectIDs = objectIDs
};
return table.Search(queryFilter);
}public async Task SearchingAFeatureClass()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (FeatureClass schoolBoundaryFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.SchoolBoundary"))
{
// Using a spatial query filter to find all features which have a certain district name and lying within a given Polygon.
SpatialQueryFilter spatialQueryFilter = new SpatialQueryFilter
{
WhereClause = "DISTRCTNAME = 'Indian Prairie School District 204'",
FilterGeometry = new PolygonBuilderEx(new List<Coordinate2D>
{
new Coordinate2D(1021880, 1867396),
new Coordinate2D(1028223, 1870705),
new Coordinate2D(1031165, 1866844),
new Coordinate2D(1025373, 1860501),
new Coordinate2D(1021788, 1863810)
}).ToGeometry(),
SpatialRelationship = SpatialRelationship.Within
};
using (RowCursor indianPrairieCursor = schoolBoundaryFeatureClass.Search(spatialQueryFilter, false))
{
while (indianPrairieCursor.MoveNext())
{
using (Feature feature = (Feature)indianPrairieCursor.Current)
{
// Process the feature. For example...
Console.WriteLine(feature.GetObjectID());
}
}
}
}
});
}public async Task SelectingRowsFromATable()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (Table enterpriseTable = geodatabase.OpenDataset<Table>("LocalGovernment.GDB.piCIPCost"))
{
QueryFilter anotherQueryFilter = new QueryFilter { WhereClause = "FLOOR = 1 AND WING = 'E'" };
// For Selecting all matching entries.
using (Selection anotherSelection = enterpriseTable.Select(anotherQueryFilter, SelectionType.ObjectID, SelectionOption.Normal))
{
}
// This can be used to get one record which matches the criteria. No assumptions can be made about which record satisfying the criteria is selected.
using (Selection onlyOneSelection = enterpriseTable.Select(anotherQueryFilter, SelectionType.ObjectID, SelectionOption.OnlyOne))
{
}
// This can be used to obtain a empty selction which can be used as a container to combine results from different selections.
using (Selection emptySelection = enterpriseTable.Select(anotherQueryFilter, SelectionType.ObjectID, SelectionOption.Empty))
{
}
// If you want to select all the records in a table.
using (Selection allRecordSelection = enterpriseTable.Select(null, SelectionType.ObjectID, SelectionOption.Normal))
{
}
}
});
}public async Task SelectingFeaturesFromAFeatureClass()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.FacilitySite"))
{
List<Coordinate2D> newCoordinates = new List<Coordinate2D>
{
new Coordinate2D(1021570, 1880583),
new Coordinate2D(1028730, 1880994),
new Coordinate2D(1029718, 1875644),
new Coordinate2D(1021405, 1875397)
};
SpatialQueryFilter spatialFilter = new SpatialQueryFilter
{
WhereClause = "FCODE = 'Park'",
FilterGeometry = new PolygonBuilderEx(newCoordinates).ToGeometry(),
SpatialRelationship = SpatialRelationship.Crosses
};
// For Selecting all matching entries.
using (Selection anotherSelection = enterpriseFeatureClass.Select(spatialFilter, SelectionType.ObjectID, SelectionOption.Normal))
{
}
// This can be used to get one record which matches the criteria. No assumptions can be made about which record satisfying the
// criteria is selected.
using (Selection onlyOneSelection = enterpriseFeatureClass.Select(spatialFilter, SelectionType.ObjectID, SelectionOption.OnlyOne))
{
}
// This can be used to obtain a empty selction which can be used as a container to combine results from different selections.
using (Selection emptySelection = enterpriseFeatureClass.Select(spatialFilter, SelectionType.ObjectID, SelectionOption.Empty))
{
}
// If you want to select all the records in a table.
using (Selection allRecordSelection = enterpriseFeatureClass.Select(null, SelectionType.ObjectID, SelectionOption.Normal))
{
}
}
});
}//Note: call within QueuedTask.Run()
Table table = featureLayer.GetTable();
long count = table.GetCount();FeatureLayer lyr = MapView.Active.Map.GetLayersAsFlattenedList().OfType<FeatureLayer>().FirstOrDefault();
QueuedTask.Run(() =>
{
FeatureClass featureClass = lyr.GetFeatureClass();
long nCount = featureClass.GetCount();
});public RowCursor SortWorldCities(FeatureClass worldCitiesTable)
{
using (FeatureClassDefinition featureClassDefinition = worldCitiesTable.GetDefinition())
{
Field countryField = featureClassDefinition.GetFields()
.First(x => x.Name.Equals("COUNTRY_NAME"));
Field cityNameField = featureClassDefinition.GetFields()
.First(x => x.Name.Equals("CITY_NAME"));
// Create SortDescription for Country field
SortDescription countrySortDescription = new SortDescription(countryField);
countrySortDescription.CaseSensitivity = CaseSensitivity.Insensitive;
countrySortDescription.SortOrder = SortOrder.Ascending;
// Create SortDescription for City field
SortDescription citySortDescription = new SortDescription(cityNameField);
citySortDescription.CaseSensitivity = CaseSensitivity.Insensitive;
citySortDescription.SortOrder = SortOrder.Ascending;
// Create our TableSortDescription
TableSortDescription tableSortDescription = new TableSortDescription(
new List<SortDescription>() { countrySortDescription, citySortDescription });
return worldCitiesTable.Sort(tableSortDescription);
}
}// Calculate the Sum and Average of the Population_1990 and Population_2000 fields, grouped and ordered by Region
public void CalculateStatistics(FeatureClass countryFeatureClass)
{
using (FeatureClassDefinition featureClassDefinition = countryFeatureClass.GetDefinition())
{
// Get fields
Field regionField = featureClassDefinition.GetFields()
.First(x => x.Name.Equals("Region"));
Field pop1990Field = featureClassDefinition.GetFields()
.First(x => x.Name.Equals("Population_1990"));
Field pop2000Field = featureClassDefinition.GetFields()
.First(x => x.Name.Equals("Population_2000"));
// Create StatisticsDescriptions
StatisticsDescription pop1990StatisticsDescription = new StatisticsDescription(pop1990Field,
new List<StatisticsFunction>() { StatisticsFunction.Sum,
StatisticsFunction.Average });
StatisticsDescription pop2000StatisticsDescription = new StatisticsDescription(pop2000Field,
new List<StatisticsFunction>() { StatisticsFunction.Sum,
StatisticsFunction.Average });
// Create TableStatisticsDescription
TableStatisticsDescription tableStatisticsDescription = new TableStatisticsDescription(new List<StatisticsDescription>() {
pop1990StatisticsDescription, pop2000StatisticsDescription });
tableStatisticsDescription.GroupBy = new List<Field>() { regionField };
tableStatisticsDescription.OrderBy = new List<SortDescription>() { new SortDescription(regionField) };
// Calculate Statistics
IReadOnlyList<TableStatisticsResult> tableStatisticsResults = countryFeatureClass.CalculateStatistics(tableStatisticsDescription);
foreach (TableStatisticsResult tableStatisticsResult in tableStatisticsResults)
{
// Get the Region name
// If multiple fields had been passed into TableStatisticsDescription.GroupBy, there would be multiple values in TableStatisticsResult.GroupBy
string regionName = tableStatisticsResult.GroupBy.First().Value.ToString();
// Get the statistics results for the Population_1990 field
StatisticsResult pop1990Statistics = tableStatisticsResult.StatisticsResults[0];
double population1990Sum = pop1990Statistics.Sum;
double population1990Average = pop1990Statistics.Average;
// Get the statistics results for the Population_2000 field
StatisticsResult pop2000Statistics = tableStatisticsResult.StatisticsResults[1];
double population2000Sum = pop2000Statistics.Sum;
double population2000Average = pop2000Statistics.Average;
// Do something with the results here...
}
}
}public async Task SimpleQueryDef()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
{
QueryDef adaCompilantParksQueryDef = new QueryDef
{
Tables = "Park",
WhereClause = "ADACOMPLY = 'Yes'",
};
using (RowCursor rowCursor = geodatabase.Evaluate(adaCompilantParksQueryDef, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
Feature feature = row as Feature;
Geometry shape = feature.GetShape();
String type = Convert.ToString(row["ADACOMPLY"]); // will be "Yes" for each row.
try
{
Table table = row.GetTable(); // Will always throw exception.
}
catch (NotSupportedException exception)
{
// Handle not supported exception.
}
}
}
}
}
});
}public async Task JoiningWithWhereQueryDef()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
{
QueryDef municipalEmergencyFacilitiesQueryDef = new QueryDef
{
SubFields = "EmergencyFacility.OBJECTID, EmergencyFacility.Shape, EmergencyFacility.FACILITYID, FacilitySite.FACILITYID, FacilitySite.FCODE",
Tables = "EmergencyFacility, FacilitySite",
WhereClause = "EmergencyFacility.FACNAME = FacilitySite.NAME AND EmergencyFacility.JURISDICT = 'Municipal'",
};
using (RowCursor rowCursor = geodatabase.Evaluate(municipalEmergencyFacilitiesQueryDef, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
Feature feature = row as Feature;
Geometry shape = feature.GetShape();
long objectID = Convert.ToInt64(row["EmergencyFacility.OBJECTID"]);
String featureCode = Convert.ToString(row["FacilitySite.FCODE"]);
IReadOnlyList<Field> fields = feature.GetFields(); //Contains one ArcGIS.Core.Data.Field objects for every subfield
}
}
}
}
});
}public async Task EvaluatingQueryDefWithOuterJoin()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
{
QueryDef queryDefWithLeftOuterJoin = new QueryDef
{
Tables = "CommunityAddress LEFT OUTER JOIN MunicipalBoundary on CommunityAddress.Municipality = MunicipalBoundary.Name",
SubFields = "CommunityAddress.OBJECTID, CommunityAddress.Shape, CommunityAddress.SITEADDID, CommunityAddress.ADDRNUM, CommunityAddress.FULLNAME, CommunityAddress.FULLADDR, CommunityAddress.MUNICIPALITY, MunicipalBoundary.Name, MunicipalBoundary.MUNITYP, MunicipalBoundary.LOCALFIPS",
};
using (RowCursor rowCursor = geodatabase.Evaluate(queryDefWithLeftOuterJoin, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
Feature feature = row as Feature;
Geometry shape = feature.GetShape();
int siteAddressId = Convert.ToInt32(row["CommunityAddress.SITEADDID"]);
String stateName = Convert.ToString(row["MunicipalBoundary.name"]);
}
}
}
}
});
}public async Task EvaluatingQueryDefWithInnerJoin()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
{
QueryDef queryDef = new QueryDef()
{
Tables = "People INNER JOIN States ON People.FK_STATE_ID = States.OBJECTID",
SubFields = "People.OBJECTID, People.First_Name, People.Last_Name, People.City, States.State_Name"
};
using (RowCursor cursor = geodatabase.Evaluate(queryDef))
{
while (cursor.MoveNext())
{
using (Row row = cursor.Current)
{
// Handle row
}
}
}
}
});
}public async Task EvaluatingQueryDefWithNestedJoin()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(
new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
{
QueryDef queryDef = new QueryDef()
{
Tables = "((People INNER JOIN States ON People.FK_STATE_ID = States.OBJECTID) LEFT OUTER JOIN Homes ON People.OBJECTID = Homes.FK_People_ID)",
SubFields = "People.OBJECTID, People.First_Name, People.Last_Name, States.State_Name, Homes.Address"
};
using (RowCursor cursor = geodatabase.Evaluate(queryDef, false))
{
while (cursor.MoveNext())
{
using (Row row = cursor.Current)
{
// Handle row
}
}
}
}
});
}Create Default QueryDescription for a Database table and obtain the ArcGIS.Core.Data.Table for the QueryDescription
public async Task DefaultQueryDescription()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
DatabaseConnectionProperties databaseConnectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = "instance",
Database = "database",
User = "user",
Password = "password"
};
using (Database database = new Database(databaseConnectionProperties))
{
QueryDescription queryDescription = database.GetQueryDescription("CUSTOMERS");
using (Table table = database.OpenTable(queryDescription))
{
//use table
}
}
});
}public async Task CustomQueryDescription()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
DatabaseConnectionProperties databaseConnectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = "instance",
Database = "database",
User = "user",
Password = "password"
};
using (Database database = new Database(databaseConnectionProperties))
{
QueryDescription queryDescription = database.GetQueryDescription("SELECT OBJECTID, Shape, FACILITYID FROM EmergencyFacility WHERE JURISDICT = 'Municipal'", "MunicipalEmergencyFacilities");
using (Table table = database.OpenTable(queryDescription))
{
// Use the table.
}
}
});
}public async Task JoinQueryDescription()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
DatabaseConnectionProperties databaseConnectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = "instance",
Database = "database",
User = "user",
Password = "password"
};
using (Database database = new Database(databaseConnectionProperties))
{
QueryDescription queryDescription = database.GetQueryDescription("SELECT BUSLINES.ID as BUSLINESID, BUSSTOPS.ID as BUSSTOPSID, BUSLINES.RTE_DESC, BUSLINES.DIR, BUSSTOPS.JURISDIC, BUSSTOPS.LOCATION, BUSSTOPS.ROUTE,BUSSTOPS.SHAPE from demosql.dbo.BUSSTOPS JOIN demosql.dbo.BUSLINES ON BUSSTOPS.ROUTE = BUSLINES.ROUTE", "BusInfo");
queryDescription.SetObjectIDFields("BUSLINESID,BUSSTOPSID");
using (Table table = database.OpenTable(queryDescription))
{
// Use the table.
}
}
});
}public async Task MultiGeometryQueryDescription()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
DatabaseConnectionProperties databaseConnectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = "instance",
Database = "database",
User = "user",
Password = "password"
};
using (Database database = new Database(databaseConnectionProperties))
{
QueryDescription pointQueryDescription = database.GetQueryDescription("select Description, SHAPE, UniqueID from MULTIGEOMETRYTEST", "MultiGeometryPoint");
pointQueryDescription.SetShapeType(GeometryType.Point);
using (Table pointTable = database.OpenTable(pointQueryDescription))
{
//use pointTable
}
QueryDescription polygonQueryDescription = database.GetQueryDescription("select Description, SHAPE, UniqueID from MULTIGEOMETRYTEST", "MultiGeometryPolygon");
polygonQueryDescription.SetShapeType(GeometryType.Polygon);
using (Table polygonTable = database.OpenTable(polygonQueryDescription))
{
//use polygonTable
}
}
});
}public async Task SqliteQueryDescription()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Database database = new Database(new SQLiteConnectionPath(new Uri("Path\\To\\Sqlite\\Database\\USA.sqlite"))))
{
QueryDescription washingtonCitiesQueryDescription = database.GetQueryDescription("select OBJECTID, Shape, CITY_FIPS, CITY_NAME, STATE_FIPS, STATE_CITY, TYPE, CAPITAL from main.cities where STATE_NAME='Washington'", "WashingtonCities");
using (Table washingtonTable = database.OpenTable(washingtonCitiesQueryDescription))
{
// Use washingtonTable.
}
}
});
}public async Task UsingSqlSyntaxToFormPlatformAgnosticQueries()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri("C:\\Data\\LocalGovernment.gdb"))))
using (FeatureClass featureClass = geodatabase.OpenDataset<FeatureClass>("FacilitySite"))
{
SQLSyntax sqlSyntax = geodatabase.GetSQLSyntax();
string substringFunctionName = sqlSyntax.GetFunctionName(SQLFunction.Substring);
string upperFunctionName = sqlSyntax.GetFunctionName(SQLFunction.Upper);
string substringfunction = string.Format("{0}({1}(FCODE, 1, 6)) = 'SCHOOL'", upperFunctionName, substringFunctionName);
QueryFilter queryFilter = new QueryFilter
{
WhereClause = substringfunction
};
using (Selection selection = featureClass.Select(queryFilter, SelectionType.ObjectID, SelectionOption.Normal))
{
// work with the selection.
}
}
});
}Joining a file geodatabase feature class to an Oracle database query layer feature class with a virtual relationship class
public async Task JoiningFileGeodatabaseFeatureClassToOracleQueryLayer()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri("C:\\Data\\LocalGovernment.gdb"))))
using (Database database = new Database(new DatabaseConnectionProperties(EnterpriseDatabaseType.Oracle)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = "instance",
User = "user",
Password = "password",
Database = "database"
}))
using (FeatureClass leftFeatureClass = geodatabase.OpenDataset<FeatureClass>("Hospital"))
using (Table rightTable = database.OpenTable(database.GetQueryDescription("FacilitySite")))
{
Field originPrimaryKey = leftFeatureClass.GetDefinition().GetFields().FirstOrDefault(field => field.Name.Equals("facilityId"));
Field destinationForeignKey = rightTable.GetDefinition().GetFields().FirstOrDefault(field => field.Name.Equals("hospitalID"));
VirtualRelationshipClassDescription description = new VirtualRelationshipClassDescription(
originPrimaryKey, destinationForeignKey, RelationshipCardinality.OneToOne);
using (RelationshipClass relationshipClass = leftFeatureClass.RelateTo(rightTable, description))
{
JoinDescription joinDescription = new JoinDescription(relationshipClass)
{
JoinDirection = JoinDirection.Forward,
JoinType = JoinType.LeftOuterJoin
};
Join join = new Join(joinDescription);
using (Table joinedTable = join.GetJoinedTable())
{
// Perform operation on joined table.
}
}
}
});
}public async Task JoinTablesFromDifferentGeodatabases()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase sourceGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri("Path \\ to \\Geodatabase \\ one"))))
using (Geodatabase destinationGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri("Path \\ to \\Geodatabase \\ two"))))
using (Table sourceTable = sourceGeodatabase.OpenDataset<Table>("State"))
using (Table destinationTable = destinationGeodatabase.OpenDataset<Table>("Cities"))
{
Field primaryKeyField = sourceTable.GetDefinition().GetFields().FirstOrDefault(field => field.Name.Equals("State.State_Abbreviation"));
Field foreignKeyField = destinationTable.GetDefinition().GetFields().FirstOrDefault(field => field.Name.Equals("Cities.State"));
VirtualRelationshipClassDescription virtualRelationshipClassDescription = new VirtualRelationshipClassDescription(primaryKeyField, foreignKeyField, RelationshipCardinality.OneToMany);
using (RelationshipClass relationshipClass = sourceTable.RelateTo(destinationTable, virtualRelationshipClassDescription))
{
JoinDescription joinDescription = new JoinDescription(relationshipClass)
{
JoinDirection = JoinDirection.Forward,
JoinType = JoinType.InnerJoin,
TargetFields = sourceTable.GetDefinition().GetFields()
};
using (Join join = new Join(joinDescription))
{
Table joinedTable = join.GetJoinedTable();
//Process the joined table. For example ..
using (RowCursor cursor = joinedTable.Search())
{
while (cursor.MoveNext())
{
using (Row row = cursor.Current)
{
// Use Row
}
}
}
}
}
}
});
}public async Task QueryTableJoinWithVersionedData()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
QueryDef queryDef = new QueryDef
{
Tables = "CommunityAddress JOIN MunicipalBoundary on CommunityAddress.Municipality = MunicipalBoundary.Name",
SubFields = "CommunityAddress.OBJECTID, CommunityAddress.Shape, CommunityAddress.SITEADDID, CommunityAddress.ADDRNUM, CommunityAddress.FULLNAME, CommunityAddress.FULLADDR, CommunityAddress.MUNICIPALITY, MunicipalBoundary.Name, MunicipalBoundary.MUNITYP, MunicipalBoundary.LOCALFIPS",
};
using (Geodatabase testVersion1Geodatabase = new Geodatabase(new DatabaseConnectionProperties(EnterpriseDatabaseType.Oracle)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = "instance",
User = "user",
Password = "password",
Database = "database",
Version = "user.testVersion1"
}))
{
QueryTableDescription queryTableDescription = new QueryTableDescription(queryDef)
{
Name = "CommunityAddrJounMunicipalBoundr",
PrimaryKeys = testVersion1Geodatabase.GetSQLSyntax().QualifyColumnName("CommunityAddress", "OBJECTID")
};
// Will be based on testVersion1.
using (Table queryTable = testVersion1Geodatabase.OpenQueryTable(queryTableDescription))
{
// Use queryTable.
}
}
using (Geodatabase testVersion2Geodatabase = new Geodatabase(new DatabaseConnectionProperties(EnterpriseDatabaseType.Oracle)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = "instance",
User = "user",
Password = "password",
Database = "database",
Version = "user.testVersion2"
}))
{
QueryTableDescription queryTableDescription = new QueryTableDescription(queryDef)
{
Name = "CommunityAddrJounMunicipalBoundr",
PrimaryKeys = testVersion2Geodatabase.GetSQLSyntax().QualifyColumnName("CommunityAddress", "OBJECTID")
};
// Will be based on testVersion2.
using (Table queryTable = testVersion2Geodatabase.OpenQueryTable(queryTableDescription))
{
// Use queryTable.
}
}
});
}object val = row[field.Name];
if (val is DBNull || val == null)
{
// field value is null
}
else
{
// field value is not null
}public string GetDomainStringFromField(Row row, Field field)
{
// Get the table and table definition from the Row
using (Table table = row.GetTable())
using (TableDefinition tableDefinition = table.GetDefinition())
{
// Get name of subtype field
string subtypeFieldName = tableDefinition.GetSubtypeField();
// Get subtype, if any
Subtype subtype = null;
if (subtypeFieldName.Length != 0)
{
// Get value of subtype field for this row
object varSubtypeCode = row[subtypeFieldName];
long subtypeCode = (long)varSubtypeCode;
// Get subtype for this row
subtype = tableDefinition.GetSubtypes().First(x => x.GetCode() == subtypeCode);
}
// Get the coded value domain for this field
CodedValueDomain domain = field.GetDomain(subtype) as CodedValueDomain;
// Return the text string for this field
if (domain != null)
{
return domain.GetName(row[field.Name]);
}
else
{
return row[field.Name].ToString();
}
}
}public void GetDatastoreProperties(Datastore geodatabase)
{
// Check if a data store supports datastore properties
bool areDatastorePropertiesSupported = geodatabase.AreDatastorePropertiesSupported();
if (areDatastorePropertiesSupported)
{
DatastoreProperties datastoreProperties = geodatabase.GetDatastoreProperties();
// Supports 64-bit integer field
bool supportsBigInteger = datastoreProperties.SupportsBigInteger;
// Supports pagination
bool supportsQueryPagination = datastoreProperties.SupportsQueryPagination;
// Supports datastore edit
bool canEdit = datastoreProperties.CanEdit;
// Supports 64-bit Object ID
bool supportsBigObjectId = datastoreProperties.SupportsBigObjectID;
// Supports DateOnly field
bool supportsDateOnly = datastoreProperties.SupportsDateOnly;
// Supports TimeOnly field
bool supportsTimeOnly = datastoreProperties.SupportsTimeOnly;
// Supports TimestampOffset field
bool supportsTimestampOffset = datastoreProperties.SupportsTimestampOffset;
}
}public void QueryFilterWithPagination(Table table, List<long> objectIDs)
{
int rowsPerBatch = 100;
int offset = 0;
// Query filter
// Some datastores support pagination only through an SQL postfix clause
QueryFilter queryFilter = new QueryFilter()
{
ObjectIDs = objectIDs,
PostfixClause = "ORDER BY OBJECTID"
};
// Fetch rows in a batch from a table
for (int index = offset; index <= objectIDs.Count; index += rowsPerBatch)
{
// Set number of rows to return from a table
queryFilter.RowCount = rowsPerBatch;
// Set positional offset to skip number of rows from a table
queryFilter.Offset = index;
using (RowCursor cursor = table.Search(queryFilter))
{
while (cursor.MoveNext())
{
using (Row row = cursor.Current)
{
Console.WriteLine(row.GetObjectID());
}
}
}
}
}public void GetVersionConflictsInfoInUpdateDeleteType(ServiceConnectionProperties featureServiceConnectionProperties, string featureClassName)
{
// To illustrate the conflict between versions,
// the feature is updated in the child version and deleted in the parent version.
long featureObjectIDForEdit = Int64.MinValue;
// Get branch versioned service
using (Geodatabase fsGeodatabase = new Geodatabase(featureServiceConnectionProperties))
using (VersionManager versionManager = fsGeodatabase.GetVersionManager())
using (Version defaultVersion = versionManager.GetDefaultVersion())
using (Geodatabase defaultGeodatabase = defaultVersion.Connect())
using (FeatureClass defaultFeatureClass = defaultGeodatabase.OpenDataset<FeatureClass>(featureClassName))
using (FeatureClassDefinition defaultFeatureClassDefinition = defaultFeatureClass.GetDefinition())
{
// Create a feature in the default version to edit in a branch
defaultGeodatabase.ApplyEdits(() =>
{
using (RowBuffer rowBuffer = defaultFeatureClass.CreateRowBuffer())
{
rowBuffer["NAME"] = "Loblolly Pine";
rowBuffer["TREEAGE"] = 1;
rowBuffer[defaultFeatureClassDefinition.GetShapeField()] = new MapPointBuilderEx(new Coordinate2D(1, 1),
SpatialReferenceBuilder.CreateSpatialReference(4152, 0)).ToGeometry();
using (Feature feature = defaultFeatureClass.CreateRow(rowBuffer))
{
featureObjectIDForEdit = feature.GetObjectID();
}
}
});
// Add newly created feature in the filter
QueryFilter queryFilter = new QueryFilter { ObjectIDs = new List<long> { featureObjectIDForEdit } };
// Create a branch version
VersionDescription versionDescription = new VersionDescription("UpdateDeleteConflictType",
"Update-Delete version conflict type", VersionAccessType.Private);
// Edit the feature in the branch
using (Version editVersion = versionManager.CreateVersion(versionDescription))
using (Geodatabase branchGeodatabase = editVersion.Connect())
using (FeatureClass featureClass = branchGeodatabase.OpenDataset<FeatureClass>(featureClassName))
using (RowCursor rowCursor = featureClass.Search(queryFilter, false))
{
branchGeodatabase.ApplyEdits(() =>
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
row["TREEAGE"] = 100;
row["NAME"] = $"{row["Name"]}_EditInBranch";
row.Store();
}
}
});
// Delete the feature from the default version
defaultFeatureClass.DeleteRows(queryFilter);
// Reconcile options
ReconcileOptions reconcileOptions = new ReconcileOptions(defaultVersion)
{
ConflictResolutionType = ConflictResolutionType.FavorEditVersion,
ConflictDetectionType = ConflictDetectionType.ByRow,
ConflictResolutionMethod = ConflictResolutionMethod.Continue
};
// Reconcile with default
ReconcileResult reconcileResult = editVersion.Reconcile(reconcileOptions);
// Check for conflicts
bool hasConflictsReconcileResults = reconcileResult.HasConflicts;
bool hasConflictsAfterReconcile = editVersion.HasConflicts();
// Fetch conflicts
IReadOnlyList<Conflict> conflictsAfterReconcile = editVersion.GetConflicts();
// Iterate conflicts
foreach (Conflict conflict in conflictsAfterReconcile)
{
// Object ID of row where conflict occurs
long objectId = conflict.ObjectID;
ConflictType conflictType = conflict.ConflictType;
IReadOnlyList<FieldValue> ancestorVersionValues = conflict.AncestorVersionValues;
object nameAncestor = ancestorVersionValues.FirstOrDefault(f => f.FieldName.Contains("NAME")).Value;
object treeAgeAncestor = ancestorVersionValues.FirstOrDefault(f => f.FieldName.Contains("TREEAGE")).Value;
IReadOnlyList<FieldValue> childVersionValues = conflict.ChildVersionValues;
object nameChild = childVersionValues.FirstOrDefault(f => f.FieldName.Contains("NAME")).Value;
object treeAgeChild = childVersionValues.FirstOrDefault(f => f.FieldName.Contains("TREEAGE")).Value;
IReadOnlyList<FieldValue> parentVersionValues = conflict.ParentVersionValues;
IReadOnlyList<Field> originalFields = defaultFeatureClassDefinition.GetFields();
string datasetName = conflict.DatasetName;
}
}
}
}public void ExploreContingentValues(Table table)
{
using (TableDefinition tableDefinition = table.GetDefinition())
{
IReadOnlyList<Contingency> contingencies = tableDefinition.GetContingencies();
foreach (Contingency contingency in contingencies)
{
// Field group
FieldGroup filedGroup = contingency.FieldGroup;
string fieldGroupName = filedGroup.Name;
IReadOnlyList<string> fieldInFieldGroup = filedGroup.FieldNames;
bool isEditRestriction = filedGroup.IsRestrictive;
int contingencyId = contingency.ID;
Subtype subtype = contingency.Subtype;
bool isContingencyRetired = contingency.IsRetired;
// Contingent values
IReadOnlyDictionary<string, ContingentValue> contingentValuesByFieldName = contingency.GetContingentValues();
foreach (KeyValuePair<string, ContingentValue> contingentValueKeyValuePair in contingentValuesByFieldName)
{
string attributeFieldName = contingentValueKeyValuePair.Key;
// Contingent value type associated with the attribute field
ContingentValue contingentValue = contingentValueKeyValuePair.Value;
switch (contingentValue)
{
case ContingentCodedValue contingentCodedValue:
string codedValueDomainName = contingentCodedValue.Name;
object codedValueDomainValue = contingentCodedValue.CodedValue;
break;
case ContingentRangeValue contingentRangeValue:
object rangeDomainMaxValue = contingentRangeValue.Max;
object rangeDomainMinValue = contingentRangeValue.Min;
break;
case ContingentAnyValue contingentAnyValue:
// Any value type
break;
case ContingentNullValue contingentNullValue:
// Null value
break;
}
}
}
}
}public void ValidateContingentValues(FeatureClass parcels, string zoningFieldName = "Zone", string taxCodeFieldName = "TaxCode")
{
using (RowBuffer rowBuffer = parcels.CreateRowBuffer())
{
// Insert values in a row buffer
rowBuffer[zoningFieldName] = "Business";
rowBuffer[taxCodeFieldName] = "TaxB";
// Validate contingency values of the parcels' row
ContingencyValidationResult contingencyValidationResult = parcels.ValidateContingencies(rowBuffer);
// Valid contingencies
IReadOnlyList<Contingency> matchedContingencies = contingencyValidationResult.Matches;
if (matchedContingencies.Count > 0)
{
// Create a row with valid contingency values
parcels.CreateRow(rowBuffer);
}
// Invalid contingencies
IReadOnlyList<ContingencyViolation> violatedContingencies = contingencyValidationResult.Violations;
foreach (ContingencyViolation contingencyViolation in violatedContingencies)
{
ContingencyViolationType violationType = contingencyViolation.Type;
Contingency violatedContingency = contingencyViolation.Contingency;
}
}
}
public void GetPossibleContingentValues(FeatureClass parcels, string zoningFieldName = "Zone")
{
using (RowBuffer rowBuffer = parcels.CreateRowBuffer())
{
IReadOnlyDictionary<FieldGroup, IReadOnlyList<ContingentValue>> possibleZonings = parcels.GetContingentValues(rowBuffer, zoningFieldName);
IEnumerable<FieldGroup> possibleFieldGroups = possibleZonings.Keys;
foreach (FieldGroup possibleFieldGroup in possibleFieldGroups)
{
IReadOnlyList<ContingentValue> possibleZoningValues = possibleZonings[possibleFieldGroup];
foreach (ContingentValue possibleZoningValue in possibleZoningValues)
{
switch (possibleZoningValue)
{
case ContingentCodedValue codedValue:
string codedValueDomainName = codedValue.Name;
object codedValueDomainValue = codedValue.CodedValue;
break;
case ContingentRangeValue rangeValue:
object rangeDomainMaxValue = rangeValue.Max;
object rangeDomainMinValue = rangeValue.Min;
break;
case ContingentAnyValue contingentAnyValue:
// Any value type
break;
case ContingentNullValue contingentNullValue:
// Null value
break;
}
}
}
}
}public async Task CreatingARow()
{
string message = String.Empty;
bool creationResult = false;
EditOperation editOperation = new EditOperation();
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(
new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (Table enterpriseTable = geodatabase.OpenDataset<Table>("LocalGovernment.GDB.piCIPCost"))
{
//var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri)) for a File GDB
//
//var shapeFileConnPath = new FileSystemConnectionPath(uri, FileSystemDatastoreType.Shapefile);
//var shapefile = new FileSystemDatastore(shapeFileConnPath);
//var table = shapefile.OpenDataset<Table>(strShapeFileName); for a Shape file
//declare the callback here. We are not executing it .yet.
editOperation.Callback(context =>
{
TableDefinition tableDefinition = enterpriseTable.GetDefinition();
int assetNameIndex = tableDefinition.FindField("ASSETNA");
using (RowBuffer rowBuffer = enterpriseTable.CreateRowBuffer())
{
// Either the field index or the field name can be used in the indexer.
rowBuffer[assetNameIndex] = "wMain";
rowBuffer["COST"] = 700;
rowBuffer["ACTION"] = "Open Cut";
// subtype value for "Abandon".
rowBuffer[tableDefinition.GetSubtypeField()] = 3;
using (Row row = enterpriseTable.CreateRow(rowBuffer))
{
// To Indicate that the attribute table has to be updated.
context.Invalidate(row);
}
}
}, enterpriseTable);
try
{
creationResult = editOperation.Execute();
if (!creationResult) message = editOperation.ErrorMessage;
}
catch (GeodatabaseException exObj)
{
message = exObj.Message;
}
}
});
if (!string.IsNullOrEmpty(message))
MessageBox.Show(message);
}public async Task CreatingAFeature()
{
string message = String.Empty;
bool creationResult = false;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.FacilitySite"))
{
//var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri)) for a File GDB
//
//var shapeFileConnPath = new FileSystemConnectionPath(uri, FileSystemDatastoreType.Shapefile);
//var shapefile = new FileSystemDatastore(shapeFileConnPath);
//var table = shapefile.OpenDataset<Table>(strShapeFileName); for a Shape file
//declare the callback here. We are not executing it yet
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
FeatureClassDefinition facilitySiteDefinition = enterpriseFeatureClass.GetDefinition();
int facilityIdIndex = facilitySiteDefinition.FindField("FACILITYID");
using (RowBuffer rowBuffer = enterpriseFeatureClass.CreateRowBuffer())
{
// Either the field index or the field name can be used in the indexer.
rowBuffer[facilityIdIndex] = "wMain";
rowBuffer["NAME"] = "Griffith Park";
rowBuffer["OWNTYPE"] = "Municipal";
rowBuffer["FCODE"] = "Park";
// Add it to Public Attractions Subtype.
rowBuffer[facilitySiteDefinition.GetSubtypeField()] = 820;
List<Coordinate2D> newCoordinates = new List<Coordinate2D>
{
new Coordinate2D(1021570, 1880583),
new Coordinate2D(1028730, 1880994),
new Coordinate2D(1029718, 1875644),
new Coordinate2D(1021405, 1875397)
};
rowBuffer[facilitySiteDefinition.GetShapeField()] = new PolygonBuilderEx(newCoordinates).ToGeometry();
using (Feature feature = enterpriseFeatureClass.CreateRow(rowBuffer))
{
//To Indicate that the attribute table has to be updated
context.Invalidate(feature);
}
}
}, enterpriseFeatureClass);
try
{
creationResult = editOperation.Execute();
if (!creationResult) message = editOperation.ErrorMessage;
}
catch (GeodatabaseException exObj)
{
message = exObj.Message;
}
}
});
if (!string.IsNullOrEmpty(message))
MessageBox.Show(message);
}public async Task ModifyingARow()
{
string message = String.Empty;
bool modificationResult = false;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (Table enterpriseTable = geodatabase.OpenDataset<Table>("LocalGovernment.GDB.piCIPCost"))
{
//var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri)) for a File GDB
//
//var shapeFileConnPath = new FileSystemConnectionPath(uri, FileSystemDatastoreType.Shapefile);
//var shapefile = new FileSystemDatastore(shapeFileConnPath);
//var table = shapefile.OpenDataset<Table>(strShapeFileName); for a Shape file
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
QueryFilter openCutFilter = new QueryFilter { WhereClause = "ACTION = 'Open Cut'" };
using (RowCursor rowCursor = enterpriseTable.Search(openCutFilter, false))
{
TableDefinition tableDefinition = enterpriseTable.GetDefinition();
int subtypeFieldIndex = tableDefinition.FindField(tableDefinition.GetSubtypeField());
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
// In order to update the Map and/or the attribute table.
// Has to be called before any changes are made to the row.
context.Invalidate(row);
row["ASSETNA"] = "wMainOpenCut";
if (Convert.ToDouble(row["COST"]) > 700)
{
// Abandon asset if cost is higher than 700 (if that is what you want to do).
row["ACTION"] = "Open Cut Abandon";
row[subtypeFieldIndex] = 3; //subtype value for "Abandon"
}
//After all the changes are done, persist it.
row.Store();
// Has to be called after the store too.
context.Invalidate(row);
}
}
}
}, enterpriseTable);
try
{
modificationResult = editOperation.Execute();
if (!modificationResult) message = editOperation.ErrorMessage;
}
catch (GeodatabaseException exObj)
{
message = exObj.Message;
}
}
});
if (!string.IsNullOrEmpty(message))
MessageBox.Show(message);
}public async Task ModifyingAFeature()
{
string message = String.Empty;
bool modificationResult = false;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.FacilitySite"))
{
//var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri)) for a File GDB
//
//var shapeFileConnPath = new FileSystemConnectionPath(uri, FileSystemDatastoreType.Shapefile);
//var shapefile = new FileSystemDatastore(shapeFileConnPath);
//var table = shapefile.OpenDataset<Table>(strShapeFileName); for a Shape file
FeatureClassDefinition facilitySiteDefinition = enterpriseFeatureClass.GetDefinition();
int ownTypeIndex = facilitySiteDefinition.FindField("OWNTYPE");
int areaIndex = facilitySiteDefinition.FindField(facilitySiteDefinition.GetAreaField());
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
QueryFilter queryFilter = new QueryFilter { WhereClause = "FCODE = 'Hazardous Materials Facility' AND OWNTYPE = 'Private'" };
using (RowCursor rowCursor = enterpriseFeatureClass.Search(queryFilter, false))
{
while (rowCursor.MoveNext())
{
using (Feature feature = (Feature)rowCursor.Current)
{
// In order to update the Map and/or the attribute table.
// Has to be called before any changes are made to the row
context.Invalidate(feature);
// Transfer all Hazardous Material Facilities to the City.
feature[ownTypeIndex] = "Municipal";
if (Convert.ToDouble(feature[areaIndex]) > 50000)
{
// Set the Shape of the feature to whatever you need.
List<Coordinate2D> newCoordinates = new List<Coordinate2D>
{
new Coordinate2D(1021570, 1880583),
new Coordinate2D(1028730, 1880994),
new Coordinate2D(1029718, 1875644),
new Coordinate2D(1021405, 1875397)
};
feature.SetShape(new PolygonBuilderEx(newCoordinates).ToGeometry());
}
feature.Store();
// Has to be called after the store too
context.Invalidate(feature);
}
}
}
}, enterpriseFeatureClass);
try
{
modificationResult = editOperation.Execute();
if (!modificationResult) message = editOperation.ErrorMessage;
}
catch (GeodatabaseException exObj)
{
message = exObj.Message;
}
}
});
if (!string.IsNullOrEmpty(message))
MessageBox.Show(message);
}row[field.Name] = "{" + guid.ToString() + "}";public async Task DeletingARowOrFeature()
{
string message = String.Empty;
bool deletionResult = false;
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (Table enterpriseTable = geodatabase.OpenDataset<Table>("LocalGovernment.GDB.piCIPCost"))
{
//var geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(uri)) for a File GDB
//
//var shapeFileConnPath = new FileSystemConnectionPath(uri, FileSystemDatastoreType.Shapefile);
//var shapefile = new FileSystemDatastore(shapeFileConnPath);
//var table = shapefile.OpenDataset<Table>(strShapeFileName); for a Shape file
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
QueryFilter openCutFilter = new QueryFilter { WhereClause = "ACTION = 'Open Cut'" };
using (RowCursor rowCursor = enterpriseTable.Search(openCutFilter, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
// In order to update the Map and/or the attribute table. Has to be called before the delete.
context.Invalidate(row);
row.Delete();
}
}
}
}, enterpriseTable);
try
{
deletionResult = editOperation.Execute();
if (!deletionResult) message = editOperation.ErrorMessage;
}
catch (GeodatabaseException exObj)
{
message = exObj.Message;
}
}
});
if (!string.IsNullOrEmpty(message))
MessageBox.Show(message);
}public void SplitALineByPoint(FeatureClass lineFeatureClass, MapPoint xPoint)
{
using (RowCursor rowCursor = lineFeatureClass.Search(new QueryFilter() { ObjectIDs = new List<long>() { 1 } }))
{
if (rowCursor.MoveNext())
{
using (Feature feature = rowCursor.Current as Feature)
{
// ObjectIDs of newly created lines
IReadOnlyList<long> splits = feature.Split(xPoint);
}
}
}
}public async Task AddingAttachments()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (FeatureClass parkFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.Park"))
{
QueryFilter filter = new QueryFilter { WhereClause = "NUMPARKING > 0" };
using (RowCursor parkingCursor = parkFeatureClass.Search(filter, false))
{
while (parkingCursor.MoveNext())
{
using (MemoryStream stream = CreateMemoryStreamFromContentsOf("Sample.xml"))
{
Attachment attachment = new Attachment("Sample.xml", "text/xml", stream);
using (Row row = parkingCursor.Current)
{
long attachmentId = row.AddAttachment(attachment);
}
}
}
}
}
});
}
private MemoryStream CreateMemoryStreamFromContentsOf(String fileNameWithPath)
{
MemoryStream memoryStream = new MemoryStream();
using (FileStream file = new FileStream(fileNameWithPath, FileMode.Open, FileAccess.Read))
{
byte[] bytes = new byte[file.Length];
file.Read(bytes, 0, (int)file.Length);
memoryStream.Write(bytes, 0, (int)file.Length);
}
return memoryStream;
}public async Task UpdatingAttachments()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (FeatureClass landUseCaseFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.LandUseCase"))
{
QueryFilter filter = new QueryFilter { WhereClause = "CASETYPE = 'Rezoning'" };
using (RowCursor landUseCursor = landUseCaseFeatureClass.Search(filter, false))
{
while (landUseCursor.MoveNext())
{
using (Feature rezoningUseCase = (Feature)landUseCursor.Current)
{
IReadOnlyList<Attachment> rezoningAttachments = rezoningUseCase.GetAttachments();
IEnumerable<Attachment> filteredAttachments = rezoningAttachments.Where(attachment => !attachment.GetName().Contains("rezoning"));
foreach (Attachment attachmentToUpdate in filteredAttachments)
{
attachmentToUpdate.SetName(attachmentToUpdate.GetName().Replace(".pdf", "Rezoning.pdf"));
rezoningUseCase.UpdateAttachment(attachmentToUpdate);
}
}
}
}
}
});
}public async Task DeletingAttachments()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file\\sdefile.sde"))))
using (Table inspectionTable = geodatabase.OpenDataset<Table>("luCodeInspection"))
{
QueryFilter queryFilter = new QueryFilter { WhereClause = "ACTION = '1st Notice'" };
using (RowCursor cursor = inspectionTable.Search(queryFilter, false))
{
while (cursor.MoveNext())
{
using (Row currentRow = cursor.Current)
{
IReadOnlyList<Attachment> rowAttachments = currentRow.GetAttachments(null, true);
IEnumerable<Attachment> attachments = rowAttachments.Where(attachment => attachment.GetContentType().Equals("application/pdf"));
IReadOnlyList<long> attachmentIDs = attachments.Select(attachment => attachment.GetAttachmentID()) as IReadOnlyList<long>;
IReadOnlyDictionary<long, Exception> failures = currentRow.DeleteAttachments(attachmentIDs);
if (failures.Count > 0)
{
//process errors
}
}
}
}
}
});
}public async Task WriteBlobField(Table table, string blobFieldName, string imageFileName)
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
// Read the image file into a MemoryStream
MemoryStream memoryStream = new MemoryStream(); ;
using (FileStream imageFile = new FileStream(imageFileName, FileMode.Open, FileAccess.Read))
{
imageFile.CopyTo(memoryStream);
}
// Create a new row in the table, and write the Memory Stream into a blob fiele
using (RowBuffer rowBuffer = table.CreateRowBuffer())
{
rowBuffer[blobFieldName] = memoryStream;
table.CreateRow(rowBuffer).Dispose();
}
});
}public async Task ReadBlobField(Table table, QueryFilter queryFilter, string blobFieldName)
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
const string imageFileBaseName = "C:\\path\\to\\image\\directory\\Image";
// for each row that satisfies the search criteria, write the blob field out to an image file
using (RowCursor rowCursor = table.Search(queryFilter))
{
int fileCount = 0;
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
// Read the blob field into a MemoryStream
MemoryStream memoryStream = row[blobFieldName] as MemoryStream;
// Create a file
using (FileStream outputFile = new FileStream(imageFileBaseName + fileCount.ToString(), FileMode.Create, FileAccess.Write))
{
// Write the MemoryStream into the file
memoryStream.WriteTo(outputFile);
}
}
}
}
});
}public async Task GettingRowsRelatedByRelationshipClass()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
using (RelationshipClass relationshipClass = geodatabase.OpenDataset<RelationshipClass>("LocalGovernment.GDB.luCodeViolationHasInspections"))
using (FeatureClass violationsFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.luCodeViolation"))
using (Table inspectionTable = geodatabase.OpenDataset<Table>("LocalGovernment.GDB.luCodeInspection"))
{
List<Row> jeffersonAveViolations = new List<Row>();
QueryFilter queryFilter = new QueryFilter { WhereClause = "LOCDESC LIKE '///%Jefferson///%'" };
using (RowCursor rowCursor = violationsFeatureClass.Search(queryFilter, false))
{
while (rowCursor.MoveNext())
{
jeffersonAveViolations.Add(rowCursor.Current);
}
}
IReadOnlyList<Row> relatedOriginRows = null;
IReadOnlyList<Row> relatedDestinationRows = null;
try
{
QueryFilter filter = new QueryFilter { WhereClause = "ACTION = '1st Notice'" };
using (Selection selection = inspectionTable.Select(filter, SelectionType.ObjectID, SelectionOption.Normal))
{
relatedOriginRows = relationshipClass.GetRowsRelatedToDestinationRows(selection.GetObjectIDs());
}
bool containsJeffersonAve = relatedOriginRows.Any(row => Convert.ToString(row["LOCDESC"]).Contains("Jefferson"));
List<long> jeffersonAveViolationObjectIds = jeffersonAveViolations.Select(row => row.GetObjectID()).ToList();
relatedDestinationRows = relationshipClass.GetRowsRelatedToOriginRows(jeffersonAveViolationObjectIds);
bool hasFirstNoticeInspections = relatedDestinationRows.Any(row => Convert.ToString(row["ACTION"]).Contains("1st Notice"));
}
finally
{
Dispose(jeffersonAveViolations);
Dispose(relatedOriginRows);
Dispose(relatedDestinationRows);
}
}
});
}
private static void Dispose(IEnumerable<Row> rows)
{
foreach (Row row in rows)
row.Dispose();
}public async Task CreatingARelationship()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
using (RelationshipClass relationshipClass = geodatabase.OpenDataset<RelationshipClass>("LocalGovernment.GDB.OverviewToProject"))
using (FeatureClass projectsFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.CIPProjects"))
using (FeatureClass overviewFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.CIPProjectsOverview"))
{
// This will be PROJNAME. This can be used to get the field index or used directly as the field name.
string originKeyField = relationshipClass.GetDefinition().GetOriginKeyField();
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
// The rows are being added to illustrate adding relationships. If one has existing rows, those can be used to add a relationship.
using (RowBuffer projectsRowBuffer = projectsFeatureClass.CreateRowBuffer())
using (RowBuffer overviewRowBuffer = overviewFeatureClass.CreateRowBuffer())
{
projectsRowBuffer["TOTCOST"] = 500000;
overviewRowBuffer[originKeyField] = "LibraryConstruction";
overviewRowBuffer["PROJECTMAN"] = "John Doe";
overviewRowBuffer["FUNDSOUR"] = "Public";
using (Row projectsRow = projectsFeatureClass.CreateRow(projectsRowBuffer))
using (Row overviewRow = overviewFeatureClass.CreateRow(overviewRowBuffer))
{
Relationship relationship = relationshipClass.CreateRelationship(overviewRow, projectsRow);
//To Indicate that the Map has to draw this feature/row and/or the attribute table has to be updated
context.Invalidate(projectsRow);
context.Invalidate(overviewRow);
context.Invalidate(relationshipClass);
}
}
}, projectsFeatureClass, overviewFeatureClass);
bool editResult = editOperation.Execute();
}
});
}public async Task DeletingARelationship()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
using (RelationshipClass relationshipClass = geodatabase.OpenDataset<RelationshipClass>("LocalGovernment.GDB.luCodeViolationHasInspections"))
using (FeatureClass violationsFeatureClass = geodatabase.OpenDataset<FeatureClass>("LocalGovernment.GDB.luCodeViolation"))
{
QueryFilter queryFilter = new QueryFilter { WhereClause = "LOCDESC LIKE '///%Jefferson///%'" };
using (RowCursor rowCursor = violationsFeatureClass.Search(queryFilter, false))
{
if (!rowCursor.MoveNext())
return;
using (Row jeffersonAveViolation = rowCursor.Current)
{
IReadOnlyList<Row> relatedDestinationRows = relationshipClass.GetRowsRelatedToOriginRows(new List<long> { jeffersonAveViolation.GetObjectID() });
try
{
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
foreach (Row relatedDestinationRow in relatedDestinationRows)
{
try
{
relationshipClass.DeleteRelationship(jeffersonAveViolation, relatedDestinationRow);
}
catch (GeodatabaseRelationshipClassException exception)
{
Console.WriteLine(exception);
}
}
}, relationshipClass);
bool editResult = editOperation.Execute();
}
finally
{
foreach (Row row in relatedDestinationRows)
row.Dispose();
}
}
}
}
});
}// Insert Cursors are intended for use in CoreHost applications, not Pro Add-ins
public void UsingInsertCursor()
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
using (Table citiesTable = geodatabase.OpenDataset<Table>("name\\of\\cities_table"))
{
geodatabase.ApplyEdits(() =>
{
using (InsertCursor insertCursor = citiesTable.CreateInsertCursor())
using (RowBuffer rowBuffer = citiesTable.CreateRowBuffer())
{
rowBuffer["State"] = "Colorado";
rowBuffer["Name"] = "Fort Collins";
rowBuffer["Population"] = 167830;
insertCursor.Insert(rowBuffer);
rowBuffer["Name"] = "Denver";
rowBuffer["Population"] = 727211;
insertCursor.Insert(rowBuffer);
// Insert more rows here
// A more realistic example would be reading source data from a file
insertCursor.Flush();
}
});
}
}public async Task CreatingAnAnnotationFeature(Geodatabase geodatabase)
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (AnnotationFeatureClass annotationFeatureClass = geodatabase.OpenDataset<AnnotationFeatureClass>("Annotation // feature // class // name"))
using (AnnotationFeatureClassDefinition annotationFeatureClassDefinition = annotationFeatureClass.GetDefinition())
using (RowBuffer rowBuffer = annotationFeatureClass.CreateRowBuffer())
using (AnnotationFeature annotationFeature = annotationFeatureClass.CreateRow(rowBuffer))
{
annotationFeature.SetAnnotationClassID(0);
annotationFeature.SetStatus(AnnotationStatus.Placed);
// Get the annotation labels from the label collection
IReadOnlyList<CIMLabelClass> labelClasses =
annotationFeatureClassDefinition.GetLabelClassCollection();
// Setup the symbol reference with the symbol id and the text symbol
CIMSymbolReference cimSymbolReference = new CIMSymbolReference();
cimSymbolReference.Symbol = labelClasses[0].TextSymbol.Symbol;
cimSymbolReference.SymbolName = labelClasses[0].TextSymbol.SymbolName;
// Setup the text graphic
CIMTextGraphic cimTextGraphic = new CIMTextGraphic();
cimTextGraphic.Text = "Charlotte, North Carolina";
cimTextGraphic.Shape = new MapPointBuilderEx(new Coordinate2D(-80.843, 35.234), SpatialReferences.WGS84).ToGeometry();
cimTextGraphic.Symbol = cimSymbolReference;
// Set the symbol reference on the graphic and store
annotationFeature.SetGraphic(cimTextGraphic);
annotationFeature.Store();
}
});
}public Geodatabase ConnectToVersion(Geodatabase geodatabase, string versionName)
{
Geodatabase connectedVersion = null;
if (geodatabase.IsVersioningSupported())
{
using (VersionManager versionManager = geodatabase.GetVersionManager())
using (Version version = versionManager.GetVersion(versionName))
{
connectedVersion = version.Connect();
}
}
return connectedVersion;
}public void ReconcileAndPost(Geodatabase geodatabase)
{
// Get a reference to our version and our parent
if (geodatabase.IsVersioningSupported())
{
using (VersionManager versionManager = geodatabase.GetVersionManager())
using (Version currentVersion = versionManager.GetCurrentVersion())
using (Version parentVersion = currentVersion.GetParent())
{
//// Create a ReconcileDescription object
//At 2.x -
//ReconcileDescription reconcileDescription = new ReconcileDescription(parentVersion);
//reconcileDescription.ConflictResolutionMethod = ConflictResolutionMethod.Continue; // continue if conflicts are found
//reconcileDescription.WithPost = true;
//// Reconcile and post
//ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileDescription);
// ReconcileResult.HasConflicts can be checked as-needed
// Create a ReconcileOptions object
ReconcileOptions reconcileOptions = new ReconcileOptions(parentVersion);
reconcileOptions.ConflictResolutionMethod = ConflictResolutionMethod.Continue; // continue if conflicts are found
reconcileOptions.ConflictDetectionType = ConflictDetectionType.ByRow; //Default
reconcileOptions.ConflictResolutionType = ConflictResolutionType.FavorTargetVersion;//or FavorEditVersion
// Reconcile
ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileOptions);
if (!reconcileResult.HasConflicts)
{
//No conflicts, perform the post
PostOptions postOptions = new PostOptions(parentVersion);
//var postOptions = new PostOptions(); for default version
postOptions.ServiceSynchronizationType = ServiceSynchronizationType.Synchronous;//Default
currentVersion.Post(postOptions);
}
}
}
}public void ReconcileAndPost2(Geodatabase geodatabase)
{
// Get a reference to our version and our parent
if (geodatabase.IsVersioningSupported())
{
using (VersionManager versionManager = geodatabase.GetVersionManager())
using (Version currentVersion = versionManager.GetCurrentVersion())
using (Version parentVersion = currentVersion.GetParent())
{
//// Create a ReconcileDescription object
//At 2.x -
//ReconcileDescription reconcileDescription = new ReconcileDescription(parentVersion);
//reconcileDescription.ConflictResolutionMethod = ConflictResolutionMethod.Continue; // continue if conflicts are found
//reconcileDescription.WithPost = true;
//// Reconcile and post
//ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileDescription);
// ReconcileResult.HasConflicts can be checked as-needed
// Create a ReconcileOptions object
ReconcileOptions reconcileOptions = new ReconcileOptions(parentVersion);
reconcileOptions.ConflictResolutionMethod = ConflictResolutionMethod.Continue; // continue if conflicts are found
reconcileOptions.ConflictDetectionType = ConflictDetectionType.ByRow; //Default
reconcileOptions.ConflictResolutionType = ConflictResolutionType.FavorTargetVersion;//or FavorEditVersion
PostOptions postOptions = new PostOptions(parentVersion);
//var postOptions = new PostOptions(); for default version
postOptions.ServiceSynchronizationType = ServiceSynchronizationType.Synchronous;//Default
// Reconcile
ReconcileResult reconcileResult = currentVersion.Reconcile(reconcileOptions, postOptions);
if (reconcileResult.HasConflicts)
{
//TODO resolve conflicts
}
}
}
}public async Task WorkingWithVersions()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri("path\\to\\sde\\file"))))
using (VersionManager versionManager = geodatabase.GetVersionManager())
{
IReadOnlyList<string> versionNames = versionManager.GetVersionNames();
Version defaultVersion = versionManager.GetDefaultVersion();
string testVersionName = versionNames.First(v => v.Contains("Test"));
Version testVersion= versionManager.GetVersion(testVersionName);
Version qaVersion = defaultVersion.GetChildren().First(version => version.GetName().Contains("QA"));
Geodatabase qaVersionGeodatabase = qaVersion.Connect();
FeatureClass currentFeatureClass = geodatabase.OpenDataset<FeatureClass>("featureClassName");
FeatureClass qaFeatureClass = qaVersionGeodatabase.OpenDataset<FeatureClass>("featureClassName");
}
});
}// Check to see if the current version is default.
// Works with both branch and traditional versioning.
public bool IsDefaultVersion(Version version)
{
Version parentVersion = version.GetParent();
if (parentVersion == null)
{
return true;
}
parentVersion.Dispose();
return false;
}
public bool IsDefaultVersion(Geodatabase geodatabase)
{
if (!geodatabase.IsVersioningSupported()) return false;
using (VersionManager versionManager = geodatabase.GetVersionManager())
using (Version currentVersion = versionManager.GetCurrentVersion())
{
return IsDefaultVersion(currentVersion);
}
}
// Gets the default version.
// Works with both branch and traditional versioning.
// Note that this routine depends on IsDefaultVersion(), above.
public Version GetDefaultVersion(Version version)
{
if (IsDefaultVersion(version))
{
return version;
}
else
{
Version parent = version.GetParent();
Version ancestor = GetDefaultVersion(parent);
if (parent != ancestor)
{
parent.Dispose(); //If the versioning tree is more than 2 deep, we want to dispose any intermediary versions
}
return ancestor;
}
}
public Version GetDefaultVersion(Geodatabase geodatabase)
{
if (!geodatabase.IsVersioningSupported()) return null;
using (VersionManager versionManager = geodatabase.GetVersionManager())
{
Version currentVersion = versionManager.GetCurrentVersion();
Version defaultVersion = GetDefaultVersion(currentVersion);
if (currentVersion != defaultVersion)
{
currentVersion.Dispose(); // If we are not pointing to default, we want to dispose this Version object
}
return defaultVersion;
}
}public Version CreateVersion(Geodatabase geodatabase, string versionName, string description, VersionAccessType versionAccessType)
{
if (!geodatabase.IsVersioningSupported()) return null;
using (VersionManager versionManager = geodatabase.GetVersionManager())
{
VersionDescription versionDescription = new VersionDescription(versionName, description, versionAccessType);
return versionManager.CreateVersion(versionDescription);
}
}public HistoricalVersion CreateHistoricalVersion(Geodatabase geodatabase, string versionName)
{
using (VersionManager versionManager = geodatabase.GetVersionManager())
{
HistoricalVersionDescription historicalVersionDescription = new HistoricalVersionDescription(versionName, DateTime.Now);
HistoricalVersion historicalVersion = versionManager.CreateHistoricalVersion(historicalVersionDescription);
return historicalVersion;
}
}public void ChangeVersions(Geodatabase geodatabase, string toVersionName)
{
using (VersionManager versionManager = geodatabase.GetVersionManager())
{
VersionBaseType versionBaseType = versionManager.GetCurrentVersionBaseType();
if (versionBaseType == VersionBaseType.Version)
{
Version fromVersion = versionManager.GetCurrentVersion();
Version toVersion = versionManager.GetVersion(toVersionName);
// Switch between versions
MapView.Active.Map.ChangeVersion(fromVersion, toVersion);
}
if (versionBaseType == VersionBaseType.HistoricalVersion)
{
HistoricalVersion fromHistoricalVersion = versionManager.GetCurrentHistoricalVersion();
HistoricalVersion toHistoricalVersion = versionManager.GetHistoricalVersion(toVersionName);
// Switch between historical versions
MapView.Active.Map.ChangeVersion(fromHistoricalVersion, toHistoricalVersion);
}
// Switch from HistoricalVersion to Version and vice-versa
// MapView.Active.Map.ChangeVersion(fromHistoricalVersion, toVersion);
// MapView.Active.Map.ChangeVersion(fromVersion, toHistoricalVersion);
}
}// Partial posting allows developers to post a subset of changes made in a version.
// One sample use case is an electric utility that uses a version to design the facilities in
// a new housing subdivision. At some point in the process, one block of new houses have been
// completed, while the rest of the subdivision remains unbuilt. Partial posting allows the user
// to post the completed work, while leaving not yet constructed features in the version to be
// posted later. Partial posting requires a branch-versioned feature service using ArcGIS
// Enterprise 10.9 and higher
// Specify a set of features that were constructed
QueryFilter constructedFilter = new QueryFilter()
{
WhereClause = "ConstructedStatus = 'True'"
};
// This selection represents the inserts and updates to the support
// structure feature class that we wish to post
using (Selection constructedSupportStructures = supportStructureFeatureClass.Select(constructedFilter, SelectionType.ObjectID, SelectionOption.Normal))
{
// Specifying which feature deletions you wish to post is slightly trickier, since you cannot issue
// a query to fetch a set of deleted features Instead, a list of ObjectIDs must be used
using (Selection deletedSupportStructures = supportStructureFeatureClass.Select(
null, SelectionType.ObjectID, SelectionOption.Empty))
{
deletedSupportStructures.Add(deletedSupportStructureObjectIDs); //deletedSupportStructureObjectIDs is
//defined as List<long>
//Perform the reconcile with partial post
//At 2.x -
//ReconcileDescription reconcileDescription = new ReconcileDescription();
//reconcileDescription.ConflictDetectionType = ConflictDetectionType.ByColumn;
//reconcileDescription.ConflictResolutionMethod = ConflictResolutionMethod.Continue;
//reconcileDescription.ConflictResolutionType = ConflictResolutionType.FavorEditVersion;
//reconcileDescription.PartialPostSelections = new List<Selection>() { constructedSupportStructures, deletedSupportStructures };
//reconcileDescription.WithPost = true;
//ReconcileResult reconcileResult = designVersion.Reconcile(reconcileDescription);
ReconcileOptions reconcileOptions = new ReconcileOptions();//reconcile against Default
reconcileOptions.ConflictDetectionType = ConflictDetectionType.ByColumn;
reconcileOptions.ConflictResolutionMethod = ConflictResolutionMethod.Continue;
reconcileOptions.ConflictResolutionType = ConflictResolutionType.FavorEditVersion;
PostOptions postOptions = new PostOptions();//post against Default
postOptions.PartialPostSelections = new List<Selection>() {
constructedSupportStructures, deletedSupportStructures };
postOptions.ServiceSynchronizationType = ServiceSynchronizationType.Synchronous;
ReconcileResult reconcileResult = designVersion.Reconcile(reconcileOptions, postOptions);
//TODO process result(s)
}
}public void IterateDatasetsFromAFeatureDataset(Geodatabase geodatabase, string featureDatasetName = "City", string featureClassInFeatureDataset = "Buildings")
{
// Open a feature dataset
using (FeatureDataset cityFeatureDataset = geodatabase.OpenDataset<FeatureDataset>(featureDatasetName))
{
// Get a feature class definition from a feature dataset
FeatureClassDefinition buildingsFeatureClassDefinition = cityFeatureDataset.GetDefinition<FeatureClassDefinition>(featureClassInFeatureDataset);
// Iterate dataset definition
IReadOnlyList<FeatureClassDefinition> cityFeatureClassDefinitions = cityFeatureDataset.GetDefinitions<FeatureClassDefinition>();
foreach (FeatureClassDefinition cityFeatureClassDefinition in cityFeatureClassDefinitions)
{
// Use feature class definition
}
}
}public void GetAttributeRules(Geodatabase geodatabase, string tableName)
{
using (TableDefinition tableDefinition = geodatabase.GetDefinition<TableDefinition>(tableName))
{
// Get all attribute rule types
IReadOnlyList<AttributeRuleDefinition> ruleDefinitions = tableDefinition.GetAttributeRules();
// Iterate rule definitions
foreach (AttributeRuleDefinition ruleDefinition in ruleDefinitions)
{
AttributeRuleType ruleType = ruleDefinition.GetAttributeRuleType();
string ruleDescription = ruleDefinition.GetDescription();
bool isAttributeFieldEditable = ruleDefinition.GetIsFieldEditable();
string arcadeVersionToSupportRule = ruleDefinition.GetMinimumArcadeVersion();
int ruleEvaluationOrder = ruleDefinition.GetEvaluationOrder();
AttributeRuleTriggers triggeringEvents = ruleDefinition.GetTriggeringEvents();
string scriptExpression = ruleDefinition.GetScriptExpression();
// more properties
}
}
}public void CreateRowBufferFromARow(Table table)
{
using (RowCursor rowCursor = table.Search())
{
if (rowCursor.MoveNext())
{
using (Row templateRow = rowCursor.Current)
{
RowBuffer rowBuffer = table.CreateRowBuffer(templateRow);
// Manipulate row buffer
// Doesn't allow copying values of ObjectID and GlobalID
//
// rowBuffer["Field"] = "Update";
//
// create a new row
table.CreateRow(rowBuffer);
}
}
}
}public void ExtensionIds1(Table table)
{
//Add an extension id to a table
//Check documentation for restrictions on backward compatibility - backward
//compatibility is limited to ArcGIS Pro 3.1 if an extension id is added.
//Note: This is an extension method. It is for use in addins only and not CoreHost.
string extension_id_string = "52d8f3be-b73d-4140-beaf-23d4f9b697ea";
Guid extension_id = Guid.Parse(extension_id_string);
//Note: Must be within the lambda of QueuedTask.Run(() => { ...
//register the extension id with the relevant table
table.AddActivationExtension(extension_id);
//Remove an extension id from a table
//Restores backward compatibility assuming no other compatibility limitations are
//in place.
//Note: This is an extension method. It is for use in addins only and not CoreHost.
table.RemoveActivationExtension(extension_id);
//Check if a given extension id is registered with a particular table.
//Note: This is an extension method. It is for use in addins only and not CoreHost.
if (table.GetHasActivationExtension(extension_id))
{
//TODO - implement custom logic relevant to presence of extension_id
}
//Enumerate all extension ids on a given table.
//Note: This is an extension method. It is for use in addins only and not CoreHost.
foreach (Guid ext_id in table.GetActivationExtensions())
{
//TODO - logic based on extension ids
}
}FieldDescription bigIntegerFieldDescription = new FieldDescription("BigInteger_64", FieldType.BigInteger);// 64-bit
FieldDescription oidFieldDescription_64 = new FieldDescription("ObjectID_64", FieldType.OID)
{
Length = 8
};
// 32-bit
FieldDescription oidFieldDescription_32 = new FieldDescription("ObjectID_32", FieldType.OID)
{
Length = 4
};// Earthquake occurrences date and time
// 9/28/2014 (DateOnly)
FieldDescription earthquakeDateOnlyFieldDescription = new FieldDescription("Earthquake_DateOnly", FieldType.DateOnly);
// 1:16:42 AM (TimeOnly)
FieldDescription earthquakeTimeOnlyFieldDescription = new FieldDescription("Earthquake_TimeOnly", FieldType.TimeOnly);
// 9/28/2014 1:16:42.000 AM -09:00 (Timestamp with Offset)
FieldDescription earthquakeTimestampOffsetFieldDescription = new FieldDescription("Earthquake_TimestampOffset_Local", FieldType.TimestampOffset);
// 9/28/2014 1:16:42 AM (DateTime)
FieldDescription earthquakeDateFieldDescription = new FieldDescription("Earthquake_Date", FieldType.Date);public void CreateTableSnippet(Geodatabase geodatabase, CodedValueDomain inspectionResultsDomain)
{
// Create a PoleInspection table with the following fields
// GlobalID
// ObjectID
// InspectionDate (date)
// InspectionResults (pre-existing InspectionResults coded value domain)
// InspectionNotes (string)
// This static helper routine creates a FieldDescription for a GlobalID field with default values
FieldDescription globalIDFieldDescription = FieldDescription.CreateGlobalIDField();
// This static helper routine creates a FieldDescription for an ObjectID field with default values
FieldDescription objectIDFieldDescription = FieldDescription.CreateObjectIDField();
// Create a FieldDescription for the InspectionDate field
FieldDescription inspectionDateFieldDescription = new FieldDescription("InspectionDate", FieldType.Date)
{
AliasName = "Inspection Date"
};
// This static helper routine creates a FieldDescription for a Domain field (from a pre-existing domain)
FieldDescription inspectionResultsFieldDescription = FieldDescription.CreateDomainField("InspectionResults", new CodedValueDomainDescription(inspectionResultsDomain));
inspectionResultsFieldDescription.AliasName = "Inspection Results";
// This static helper routine creates a FieldDescription for a string field
FieldDescription inspectionNotesFieldDescription = FieldDescription.CreateStringField("InspectionNotes", 512);
inspectionNotesFieldDescription.AliasName = "Inspection Notes";
// Assemble a list of all of our field descriptions
List<FieldDescription> fieldDescriptions = new List<FieldDescription>()
{ globalIDFieldDescription, objectIDFieldDescription, inspectionDateFieldDescription, inspectionResultsFieldDescription, inspectionNotesFieldDescription };
// Create a TableDescription object to describe the table to create
TableDescription tableDescription = new TableDescription("PoleInspection", fieldDescriptions);
// Create a SchemaBuilder object
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Add the creation of PoleInspection to our list of DDL tasks
schemaBuilder.Create(tableDescription);
// Execute the DDL
bool success = schemaBuilder.Build();
// Inspect error messages
if (!success)
{
IReadOnlyList<string> errorMessages = schemaBuilder.ErrorMessages;
//etc.
}
}public void CreateFeatureClassSnippet(Geodatabase geodatabase, FeatureClass existingFeatureClass, SpatialReference spatialReference)
{
// Create a Cities feature class with the following fields
// GlobalID
// ObjectID
// Name (string)
// Population (integer)
// This static helper routine creates a FieldDescription for a GlobalID field with default values
FieldDescription globalIDFieldDescription = FieldDescription.CreateGlobalIDField();
// This static helper routine creates a FieldDescription for an ObjectID field with default values
FieldDescription objectIDFieldDescription = FieldDescription.CreateObjectIDField();
// This static helper routine creates a FieldDescription for a string field
FieldDescription nameFieldDescription = FieldDescription.CreateStringField("Name", 255);
// This static helper routine creates a FieldDescription for an integer field
FieldDescription populationFieldDescription = FieldDescription.CreateIntegerField("Population");
// Assemble a list of all of our field descriptions
List<FieldDescription> fieldDescriptions = new List<FieldDescription>()
{ globalIDFieldDescription, objectIDFieldDescription, nameFieldDescription, populationFieldDescription };
// Create a ShapeDescription object
ShapeDescription shapeDescription = new ShapeDescription(GeometryType.Point, spatialReference);
// Alternatively, ShapeDescriptions can be created from another feature class. In this case, the new feature class will inherit the same shape properties of the existing class
ShapeDescription alternativeShapeDescription = new ShapeDescription(existingFeatureClass.GetDefinition());
// Create a FeatureClassDescription object to describe the feature class to create
FeatureClassDescription featureClassDescription =
new FeatureClassDescription("Cities", fieldDescriptions, shapeDescription);
// Create a SchemaBuilder object
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Add the creation of the Cities feature class to our list of DDL tasks
schemaBuilder.Create(featureClassDescription);
// Execute the DDL
bool success = schemaBuilder.Build();
// Inspect error messages
if (!success)
{
IReadOnlyList<string> errorMessages = schemaBuilder.ErrorMessages;
//etc.
}
}public void DeleteTableSnippet(Geodatabase geodatabase, Table table)
{
// Create a TableDescription object
TableDescription tableDescription = new TableDescription(table.GetDefinition());
// Create a SchemaBuilder object
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Add the deletion of the table to our list of DDL tasks
schemaBuilder.Delete(tableDescription);
// Execute the DDL
bool success = schemaBuilder.Build();
}public void DeleteFeatureClassSnippet(Geodatabase geodatabase, FeatureClass featureClass)
{
// Create a FeatureClassDescription object
FeatureClassDescription featureClassDescription = new FeatureClassDescription(featureClass.GetDefinition());
// Create a SchemaBuilder object
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Add the deletion fo the feature class to our list of DDL tasks
schemaBuilder.Delete(featureClassDescription);
// Execute the DDL
bool success = schemaBuilder.Build();
}public void OpenMemoryGeodatabase()
{
// Connects to the default memory geodatabase, if exists otherwise throws exception
MemoryConnectionProperties memoryConnectionProperties = new MemoryConnectionProperties();
// Alternatively, connects to memory geodatabase named as 'InterimMemoryGeodatabase'
// MemoryConnectionProperties memoryConnectionProperties = new MemoryConnectionProperties("InterimMemoryGeodatabase");
// Opens the memory geodatabase
using (Geodatabase geodatabase = new Geodatabase(memoryConnectionProperties))
{
// Use memory geodatabase
}
}public void CreateMemoryGeodatabaseSnippet()
{
// Create the memory connection properties to connect to default memory geodatabase
MemoryConnectionProperties memoryConnectionProperties = new MemoryConnectionProperties();
// Alternatively create the memory connection properties to connect to memory geodatabase named as 'InterimMemoryGeodatabase'
// MemoryConnectionProperties memoryConnectionProperties = new MemoryConnectionProperties("InterimMemoryGeodatabase");
// Creates the new memory geodatabase if it does not exist or connects to an existing one if it already exists
using (Geodatabase geodatabase = new Geodatabase(memoryConnectionProperties))
{
// Create additional schema here
}
}public void DeleteMemoryGeodatabaseSnippet()
{
// Create the memory connection properties to connect to default memory geodatabase
MemoryConnectionProperties memoryConnectionProperties = new MemoryConnectionProperties();
// Delete the memory geodatabase
SchemaBuilder.DeleteGeodatabase(memoryConnectionProperties);
}public void CreateFileGeodatabaseSnippet()
{
// Create a FileGeodatabaseConnectionPath with the name of the file geodatabase you wish to create
FileGeodatabaseConnectionPath fileGeodatabaseConnectionPath =
new FileGeodatabaseConnectionPath(new Uri(@"C:\Path-To-File-Geodatabase\YourName.gdb"));
// Create and use the file geodatabase
using (Geodatabase geodatabase =
SchemaBuilder.CreateGeodatabase(fileGeodatabaseConnectionPath))
{
// Create additional schema here
}
}public void DeleteFileGeodatabaseSnippet()
{
// Create a FileGeodatabaseConnectionPath with the name of the file geodatabase you wish to delete
FileGeodatabaseConnectionPath fileGeodatabaseConnectionPath = new FileGeodatabaseConnectionPath(new Uri(@"C:\Path-To-File-Geodatabase\YourName.gdb"));
// Delete the file geodatabase
SchemaBuilder.DeleteGeodatabase(fileGeodatabaseConnectionPath);
}public void CreateMobileGeodatabase()
{
// Create a MobileGeodatabaseConnectionPath with the name of the mobile geodatabase you wish to create
MobileGeodatabaseConnectionPath mobileGeodatabaseConnectionPath = new MobileGeodatabaseConnectionPath(new Uri(@"C:\Path-To-Mobile-Geodatabase\YourName.geodatabase"));
// Create and use the mobile geodatabase
using (Geodatabase geodatabase = SchemaBuilder.CreateGeodatabase(mobileGeodatabaseConnectionPath))
{
// Create additional schema here
}
}public void DeleteMobileGeodatabase()
{
// Create a MobileGeodatabaseConnectionPath with the name of the mobile geodatabase you wish to delete
MobileGeodatabaseConnectionPath mobileGeodatabaseConnectionPath =
new MobileGeodatabaseConnectionPath(new Uri(@"C:\Path-To-Mobile-Geodatabase\YourName.geodatabase"));
// Delete the mobile geodatabase
SchemaBuilder.DeleteGeodatabase(mobileGeodatabaseConnectionPath);
}public void CreateRangeDomainSnippet(Geodatabase geodatabase)
{
// Create a range description with minimum value = 0 and maximum value = 1000
RangeDomainDescription rangeDomainDescriptionMinMax = new RangeDomainDescription("RangeDomain_0_1000",
FieldType.Integer, 0, 1000)
{ Description = "Domain value ranges from 0 to 1000" };
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Create a range domain
schemaBuilder.Create(rangeDomainDescriptionMinMax);
schemaBuilder.Build();
}public void CreateCodedDomainSnippet(Geodatabase geodatabase)
{
// Create a CodedValueDomain description for water pipes
CodedValueDomainDescription codedValueDomainDescription = new CodedValueDomainDescription("WaterPipeTypes", FieldType.String,
new SortedList<object, string> { { "C_1", "Copper" }, { "S_2", "Steel" } })
{
SplitPolicy = SplitPolicy.Duplicate,
MergePolicy = MergePolicy.DefaultValue
};
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Create a coded value domain
CodedValueDomainToken codedValueDomainToken = schemaBuilder.Create(codedValueDomainDescription);
schemaBuilder.Build();
}public void CreateFeatureDatasetSnippet(Geodatabase geodatabase)
{
// Creating a FeatureDataset named as 'Parcel_Information'
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Create a FeatureDataset named as 'Parcel Information'
FeatureDatasetDescription featureDatasetDescription =
new FeatureDatasetDescription("Parcel_Information", SpatialReferences.WGS84);
schemaBuilder.Create(featureDatasetDescription);
// Build status
bool buildStatus = schemaBuilder.Build();
// Build errors
if (!buildStatus)
{
IReadOnlyList<string> errors = schemaBuilder.ErrorMessages;
}
}public void DeleteFeatureDatasetSnippet(Geodatabase geodatabase)
{
// Deleting a FeatureDataset named as 'Parcel_Information'
FeatureDatasetDefinition featureDatasetDefinition = geodatabase.GetDefinition<FeatureDatasetDefinition>("Parcel_Information");
FeatureDatasetDescription featureDatasetDescription =
new FeatureDatasetDescription(featureDatasetDefinition);
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Delete an existing feature dataset named as 'Parcel_Information'
schemaBuilder.Delete(featureDatasetDescription);
schemaBuilder.Build();
}public void RenameFeatureDatasetSnippet(Geodatabase geodatabase)
{
// Renaming a FeatureDataset from 'Parcel_Information' to 'Parcel_Information_With_Tax_Jurisdiction'
string originalDatasetName = "Parcel_Information";
string datasetRenameAs = "Parcel_Information_With_Tax_Jurisdiction";
FeatureDatasetDefinition originalDatasetDefinition =
geodatabase.GetDefinition<FeatureDatasetDefinition>(originalDatasetName);
FeatureDatasetDescription originalFeatureDatasetDescription = new FeatureDatasetDescription(originalDatasetDefinition);
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Rename the existing FeatureDataset, 'Parcel_Information' to 'Parcel_Information_With_Tax_Jurisdiction'
schemaBuilder.Rename(originalFeatureDatasetDescription, datasetRenameAs);
schemaBuilder.Build();
}public void CreateFeatureDatasetWithFeatureClassSnippet(Geodatabase geodatabase)
{
// Creating a FeatureDataset named as 'Parcel_Information' and a FeatureClass with name 'Parcels' in one operation
string featureDatasetName = "Parcel_Information";
string featureClassName = "Parcels";
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Create a FeatureDataset token
FeatureDatasetDescription featureDatasetDescription = new FeatureDatasetDescription(featureDatasetName, SpatialReferences.WGS84);
FeatureDatasetToken featureDatasetToken = schemaBuilder.Create(featureDatasetDescription);
// Create a FeatureClass description
FeatureClassDescription featureClassDescription = new FeatureClassDescription(featureClassName,
new List<FieldDescription>()
{
new FieldDescription("Id", FieldType.Integer),
new FieldDescription("Address", FieldType.String)
},
new ShapeDescription(GeometryType.Point, SpatialReferences.WGS84));
// Create a FeatureClass inside a FeatureDataset
FeatureClassToken featureClassToken = schemaBuilder.Create(new FeatureDatasetDescription(featureDatasetToken), featureClassDescription);
// Build status
bool buildStatus = schemaBuilder.Build();
// Build errors
if (!buildStatus)
{
IReadOnlyList<string> errors = schemaBuilder.ErrorMessages;
}
}public void CreateFeatureClassInsideFeatureDatasetSnippet(Geodatabase geodatabase)
{
// Creating a FeatureClass named as 'Tax_Jurisdiction' in existing FeatureDataset with name 'Parcels_Information'
string featureDatasetName = "Parcels_Information";
string featureClassName = "Tax_Jurisdiction";
// Create a FeatureClass description
FeatureClassDescription featureClassDescription = new FeatureClassDescription(featureClassName,
new List<FieldDescription>()
{
new FieldDescription("Tax_Id", FieldType.Integer),
new FieldDescription("Address", FieldType.String)
},
new ShapeDescription(GeometryType.Point, SpatialReferences.WGS84));
FeatureDatasetDefinition featureDatasetDefinition = geodatabase.GetDefinition<FeatureDatasetDefinition>(featureDatasetName);
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Create a FeatureClass inside a FeatureDataset using a FeatureDatasetDefinition
schemaBuilder.Create(new FeatureDatasetDescription(featureDatasetDefinition), featureClassDescription);
// Build status
bool buildStatus = schemaBuilder.Build();
// Build errors
if (!buildStatus)
{
IReadOnlyList<string> errors = schemaBuilder.ErrorMessages;
}
}public void AddFeatureClassToFeatureDatasetSnippet(Geodatabase geodatabase)
{
// Adding a FeatureClass with name 'Tax_Jurisdiction' into a FeatureDataset named as 'Parcels_Information'
string featureDatasetName = "Parcels_Information";
string featureClassNameToAdd = "Tax_Jurisdiction";
FeatureDatasetDefinition featureDatasetDefinition = geodatabase.GetDefinition<FeatureDatasetDefinition>(featureDatasetName);
FeatureDatasetDescription featureDatasetDescription = new FeatureDatasetDescription(featureDatasetDefinition);
FeatureClassDefinition featureClassDefinition = geodatabase.GetDefinition<FeatureClassDefinition>(featureClassNameToAdd);
FeatureClassDescription featureClassDescription = new FeatureClassDescription(featureClassDefinition);
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Add the 'Tax_Jurisdiction' FeatureClass to the 'Parcels_Information' FeatureDataset
schemaBuilder.AddFeatureClass(featureDatasetDescription, featureClassDescription);
bool addStatus = schemaBuilder.Build();
if (!addStatus)
{
IReadOnlyList<string> errors = schemaBuilder.ErrorMessages;
}
}public void RenameTableSnippet(Geodatabase geodatabase)
{
//Renaming a table from 'Original_Table' to 'Renamed_Table'
string tableToBeRenamed = "Original_Table";
string tableRenameAs = "Renamed_Table";
TableDefinition tableDefinition = geodatabase.GetDefinition<TableDefinition>(tableToBeRenamed);
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Table rename
schemaBuilder.Rename(new TableDescription(tableDefinition), tableRenameAs);
schemaBuilder.Build();
}public void AddFieldsInFeatureClassSnippet(Geodatabase geodatabase)
{
// Adding following fields to the 'Parcels' FeatureClass
// Global ID
// Parcel_ID
// Tax_Code
// Parcel_Address
// The FeatureClass to add fields
string featureClassName = "Parcels";
FeatureClassDefinition originalFeatureClassDefinition = geodatabase.GetDefinition<FeatureClassDefinition>(featureClassName);
FeatureClassDescription originalFeatureClassDescription = new FeatureClassDescription(originalFeatureClassDefinition);
// The four new fields to add on the 'Parcels' FeatureClass
FieldDescription globalIdField = FieldDescription.CreateGlobalIDField();
FieldDescription parcelIdDescription = new FieldDescription("Parcel_ID", FieldType.GUID);
FieldDescription taxCodeDescription = FieldDescription.CreateIntegerField("Tax_Code");
FieldDescription addressDescription = FieldDescription.CreateStringField("Parcel_Address", 150);
List<FieldDescription> fieldsToAdd = new List<FieldDescription> { globalIdField, parcelIdDescription,
taxCodeDescription, addressDescription };
// Add new fields on the new FieldDescription list
List<FieldDescription> modifiedFieldDescriptions = new List<FieldDescription>(originalFeatureClassDescription.FieldDescriptions);
modifiedFieldDescriptions.AddRange(fieldsToAdd);
// The new FeatureClassDescription with additional fields
FeatureClassDescription modifiedFeatureClassDescription = new FeatureClassDescription(originalFeatureClassDescription.Name,
modifiedFieldDescriptions, originalFeatureClassDescription.ShapeDescription);
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Update the 'Parcels' FeatureClass with newly added fields
schemaBuilder.Modify(modifiedFeatureClassDescription);
bool modifyStatus = schemaBuilder.Build();
if (!modifyStatus)
{
IReadOnlyList<string> errors = schemaBuilder.ErrorMessages;
}
}public void AddFieldWithDomainSnippet(Geodatabase geodatabase)
{
// Adding a field,'PipeType', which uses the coded value domain to the 'Pipes' FeatureClass
//The FeatureClass to add field
string featureClassName = "Pipes";
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Create a CodedValueDomain description for water pipes
CodedValueDomainDescription pipeDomainDescription =
new CodedValueDomainDescription("WaterPipeTypes", FieldType.String,
new SortedList<object, string> { { "C_1", "Copper" },
{ "S_2", "Steel" } })
{
SplitPolicy = SplitPolicy.Duplicate,
MergePolicy = MergePolicy.DefaultValue
};
// Create a coded value domain token
CodedValueDomainToken codedValueDomainToken = schemaBuilder.Create(pipeDomainDescription);
// Create a new description from domain token
CodedValueDomainDescription codedValueDomainDescription = new CodedValueDomainDescription(codedValueDomainToken);
// Create a field named as 'PipeType' using a domain description
FieldDescription domainFieldDescription = new FieldDescription("PipeType", FieldType.String);
domainFieldDescription.SetDomainDescription(codedValueDomainDescription);
//Retrieve existing information for 'Pipes' FeatureClass
FeatureClassDefinition originalFeatureClassDefinition = geodatabase.GetDefinition<FeatureClassDefinition>(featureClassName);
FeatureClassDescription originalFeatureClassDescription =
new FeatureClassDescription(originalFeatureClassDefinition);
// Add domain field on existing fields
List<FieldDescription> modifiedFieldDescriptions = new List<FieldDescription>(originalFeatureClassDescription.FieldDescriptions) { domainFieldDescription };
// Create a new description with updated fields for 'Pipes' FeatureClass
FeatureClassDescription featureClassDescription =
new FeatureClassDescription(originalFeatureClassDescription.Name, modifiedFieldDescriptions,
originalFeatureClassDescription.ShapeDescription);
// Update the 'Pipes' FeatureClass with domain field
schemaBuilder.Modify(featureClassDescription);
// Build status
bool buildStatus = schemaBuilder.Build();
// Build errors
if (!buildStatus)
{
IReadOnlyList<string> errors = schemaBuilder.ErrorMessages;
}
}public void RemoveFieldTableSnippet(Geodatabase geodatabase)
{
// Removing all fields from 'Parcels' table except following
// Tax_Code
// Parcel_Address
// The table to remove fields
string tableName = "Parcels";
TableDefinition tableDefinition = geodatabase.GetDefinition<TableDefinition>(tableName);
IReadOnlyList<Field> fields = tableDefinition.GetFields();
// Existing fields from 'Parcels' table
Field taxCodeField = fields.First(f => f.Name.Equals("Tax_Code"));
Field parcelAddressField = fields.First(f => f.Name.Equals("Parcel_Address"));
FieldDescription taxFieldDescription = new FieldDescription(taxCodeField);
FieldDescription parcelAddressFieldDescription = new FieldDescription(parcelAddressField);
// Fields to retain in modified table
List<FieldDescription> fieldsToBeRetained = new List<FieldDescription>()
{
taxFieldDescription, parcelAddressFieldDescription
};
// New description of the 'Parcels' table with the 'Tax_Code' and 'Parcel_Address' fields
TableDescription modifiedTableDescription = new TableDescription(tableName, fieldsToBeRetained);
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Remove all fields except the 'Tax_Code' and 'Parcel_Address' fields
schemaBuilder.Modify(modifiedTableDescription);
schemaBuilder.Build();
}public void CreateStandAloneAnnotationFeatureClass(Geodatabase geodatabase, SpatialReference spatialReference)
{
// Creating a Cities annotation feature class
// with following user defined fields
// Name
// GlobalID
// Annotation feature class name
string annotationFeatureClassName = "CitiesAnnotation";
// Create user defined attribute fields for annotation feature class
FieldDescription globalIDFieldDescription = FieldDescription.CreateGlobalIDField();
FieldDescription nameFieldDescription = FieldDescription.CreateStringField("Name", 255);
// Create a list of all field descriptions
List<FieldDescription> fieldDescriptions = new List<FieldDescription> { globalIDFieldDescription, nameFieldDescription };
// Create a ShapeDescription object
ShapeDescription shapeDescription = new ShapeDescription(GeometryType.Polygon, spatialReference);
// Create general placement properties for Maplex engine
CIMMaplexGeneralPlacementProperties generalPlacementProperties =
new CIMMaplexGeneralPlacementProperties
{
AllowBorderOverlap = true,
PlacementQuality = MaplexQualityType.High,
DrawUnplacedLabels = true,
InvertedLabelTolerance = 1.0,
RotateLabelWithDisplay = true,
UnplacedLabelColor = new CIMRGBColor
{
R = 0,
G = 255,
B = 0,
Alpha = 0.5f // Green
}
};
// Create general placement properties for Standard engine
//CIMStandardGeneralPlacementProperties generalPlacementProperties =
// new CIMStandardGeneralPlacementProperties
// {
// DrawUnplacedLabels = true,
// InvertedLabelTolerance = 3.0,
// RotateLabelWithDisplay = true,
// UnplacedLabelColor = new CIMRGBColor
// {
// R = 255, G = 0, B = 0, Alpha = 0.5f // Red
// }
// };
// Create annotation label classes
// Green label
CIMLabelClass greenLabelClass = new CIMLabelClass
{
Name = "Green",
ExpressionTitle = "Expression-Green",
ExpressionEngine = LabelExpressionEngine.Arcade,
Expression = "$feature.OBJECTID",
ID = 1,
Priority = 0,
Visibility = true,
TextSymbol = new CIMSymbolReference
{
Symbol = new CIMTextSymbol()
{
Angle = 45,
FontType = FontType.Type1,
FontFamilyName = "Tahoma",
FontEffects = FontEffects.Normal,
HaloSize = 2.0,
Symbol = new CIMPolygonSymbol
{
SymbolLayers = new CIMSymbolLayer[]
{
new CIMSolidFill
{
Color = CIMColor.CreateRGBColor(0, 255, 0)
}
},
UseRealWorldSymbolSizes = true
}
},
MaxScale = 0,
MinScale = 0,
SymbolName = "TextSymbol-Green"
},
StandardLabelPlacementProperties = new CIMStandardLabelPlacementProperties
{
AllowOverlappingLabels = true,
LineOffset = 1.0
},
MaplexLabelPlacementProperties = new CIMMaplexLabelPlacementProperties
{
AlignLabelToLineDirection = true,
AvoidPolygonHoles = true
}
};
// Blue label
CIMLabelClass blueLabelClass = new CIMLabelClass
{
Name = "Blue",
ExpressionTitle = "Expression-Blue",
ExpressionEngine = LabelExpressionEngine.Arcade,
Expression = "$feature.OBJECTID",
ID = 2,
Priority = 0,
Visibility = true,
TextSymbol = new CIMSymbolReference
{
Symbol = new CIMTextSymbol()
{
Angle = 45,
FontType = FontType.Type1,
FontFamilyName = "Consolas",
FontEffects = FontEffects.Normal,
HaloSize = 2.0,
Symbol = new CIMPolygonSymbol
{
SymbolLayers = new CIMSymbolLayer[]
{
new CIMSolidFill
{
Color = CIMColor.CreateRGBColor(0, 0, 255)
}
},
UseRealWorldSymbolSizes = true
}
},
MaxScale = 0,
MinScale = 0,
SymbolName = "TextSymbol-Blue"
},
StandardLabelPlacementProperties = new CIMStandardLabelPlacementProperties
{
AllowOverlappingLabels = true,
LineOffset = 1.0
},
MaplexLabelPlacementProperties = new CIMMaplexLabelPlacementProperties
{
AlignLabelToLineDirection = true,
AvoidPolygonHoles = true
}
};
// Create a list of labels
List<CIMLabelClass> labelClasses = new List<CIMLabelClass> { greenLabelClass, blueLabelClass };
// Create an annotation feature class description object to describe the feature class to create
AnnotationFeatureClassDescription annotationFeatureClassDescription =
new AnnotationFeatureClassDescription(annotationFeatureClassName, fieldDescriptions, shapeDescription,
generalPlacementProperties, labelClasses)
{
IsAutoCreate = true,
IsSymbolIDRequired = false,
IsUpdatedOnShapeChange = true
};
// Create a SchemaBuilder object
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Add the creation of the Cities annotation feature class to the list of DDL tasks
schemaBuilder.Create(annotationFeatureClassDescription);
// Execute the DDL
bool success = schemaBuilder.Build();
// Inspect error messages
if (!success)
{
IReadOnlyList<string> errorMessages = schemaBuilder.ErrorMessages;
//etc.
}
}public void CreateFeatureLinkedAnnotationFeatureClass(Geodatabase geodatabase, SpatialReference spatialReference)
{
// Creating a feature-linked annotation feature class between water pipe and valve in water distribution network
// with following user defined fields
// PipeName
// GlobalID
// Annotation feature class name
string annotationFeatureClassName = "WaterPipeAnnotation";
// Create user defined attribute fields for annotation feature class
FieldDescription pipeGlobalID = FieldDescription.CreateGlobalIDField();
FieldDescription nameFieldDescription = FieldDescription.CreateStringField("Name", 255);
// Create a list of all field descriptions
List<FieldDescription> fieldDescriptions = new List<FieldDescription> { pipeGlobalID, nameFieldDescription };
// Create a ShapeDescription object
ShapeDescription shapeDescription = new ShapeDescription(GeometryType.Polygon, spatialReference);
// Create general placement properties for Maplex engine
CIMMaplexGeneralPlacementProperties generalPlacementProperties = new CIMMaplexGeneralPlacementProperties
{
AllowBorderOverlap = true,
PlacementQuality = MaplexQualityType.High,
DrawUnplacedLabels = true,
InvertedLabelTolerance = 1.0,
RotateLabelWithDisplay = true,
UnplacedLabelColor = new CIMRGBColor
{
R = 255,
G = 0,
B = 0,
Alpha = 0.5f
}
};
// Create annotation label classes
// Green label
CIMLabelClass greenLabelClass = new CIMLabelClass
{
Name = "Green",
ExpressionTitle = "Expression-Green",
ExpressionEngine = LabelExpressionEngine.Arcade,
Expression = "$feature.OBJECTID",
ID = 1,
Priority = 0,
Visibility = true,
TextSymbol = new CIMSymbolReference
{
Symbol = new CIMTextSymbol()
{
Angle = 45,
FontType = FontType.Type1,
FontFamilyName = "Tahoma",
FontEffects = FontEffects.Normal,
HaloSize = 2.0,
Symbol = new CIMPolygonSymbol
{
SymbolLayers = new CIMSymbolLayer[]
{
new CIMSolidFill
{
Color = CIMColor.CreateRGBColor(0, 255, 0)
}
},
UseRealWorldSymbolSizes = true
}
},
MaxScale = 0,
MinScale = 0,
SymbolName = "TextSymbol-Green"
},
StandardLabelPlacementProperties = new CIMStandardLabelPlacementProperties
{
AllowOverlappingLabels = true,
LineOffset = 1.0
},
MaplexLabelPlacementProperties = new CIMMaplexLabelPlacementProperties
{
AlignLabelToLineDirection = true,
AvoidPolygonHoles = true
}
};
// Blue label
CIMLabelClass blueLabelClass = new CIMLabelClass
{
Name = "Blue",
ExpressionTitle = "Expression-Blue",
ExpressionEngine = LabelExpressionEngine.Arcade,
Expression = "$feature.OBJECTID",
ID = 2,
Priority = 0,
Visibility = true,
TextSymbol = new CIMSymbolReference
{
Symbol = new CIMTextSymbol()
{
Angle = 45,
FontType = FontType.Type1,
FontFamilyName = "Consolas",
FontEffects = FontEffects.Normal,
HaloSize = 2.0,
Symbol = new CIMPolygonSymbol
{
SymbolLayers = new CIMSymbolLayer[]
{
new CIMSolidFill
{
Color = CIMColor.CreateRGBColor(0, 0, 255)
}
},
UseRealWorldSymbolSizes = true
}
},
MaxScale = 0,
MinScale = 0,
SymbolName = "TextSymbol-Blue"
},
StandardLabelPlacementProperties = new CIMStandardLabelPlacementProperties
{
AllowOverlappingLabels = true,
LineOffset = 1.0
},
MaplexLabelPlacementProperties = new CIMMaplexLabelPlacementProperties
{
AlignLabelToLineDirection = true,
AvoidPolygonHoles = true
}
};
// Create a list of labels
List<CIMLabelClass> labelClasses = new List<CIMLabelClass> { greenLabelClass, blueLabelClass };
// Create linked feature description
// Linked feature class name
string linkedFeatureClassName = "WaterPipe";
// Create fields for water pipe
FieldDescription waterPipeGlobalID = FieldDescription.CreateGlobalIDField();
FieldDescription pipeName = FieldDescription.CreateStringField("PipeName", 255);
// Create a list of water pipe field descriptions
List<FieldDescription> pipeFieldDescriptions = new List<FieldDescription> { waterPipeGlobalID, pipeName };
// Create a linked feature class description
FeatureClassDescription linkedFeatureClassDescription = new FeatureClassDescription(linkedFeatureClassName, pipeFieldDescriptions,
new ShapeDescription(GeometryType.Polyline, spatialReference));
// Create a SchemaBuilder object
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Add the creation of the linked feature class to the list of DDL tasks
FeatureClassToken linkedFeatureClassToken = schemaBuilder.Create(linkedFeatureClassDescription);
// Create an annotation feature class description object to describe the feature class to create
AnnotationFeatureClassDescription annotationFeatureClassDescription =
new AnnotationFeatureClassDescription(annotationFeatureClassName, fieldDescriptions, shapeDescription,
generalPlacementProperties, labelClasses, new FeatureClassDescription(linkedFeatureClassToken))
{
IsAutoCreate = true,
IsSymbolIDRequired = false,
IsUpdatedOnShapeChange = true
};
// Add the creation of the annotation feature class to the list of DDL tasks
schemaBuilder.Create(annotationFeatureClassDescription);
// Execute the DDL
bool success = schemaBuilder.Build();
// Inspect error messages
if (!success)
{
IReadOnlyList<string> errorMessages = schemaBuilder.ErrorMessages;
//etc.
}
}public void CreateAnnotationFeatureClassUsingExistingAnnotationFeatureClassInDataset(Geodatabase geodatabase)
{
// Create a Cities annotation feature class inside Places feature dataset using existing annotation feature class
// Feature dataset name
string featureDatasetName = "Places";
// Annotation feature class name
string annotationFeatureClassName = "CitiesAnnotation";
// Create a SchemaBuilder object
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
// Open existing annotation feature class name
using (AnnotationFeatureClass existingAnnotationFeatureClass = geodatabase.OpenDataset<AnnotationFeatureClass>("ExistingAnnotationFeatureClass"))
{
// Create Feature dataset description
FeatureDatasetDescription featureDatasetDescription =
new FeatureDatasetDescription(featureDatasetName, existingAnnotationFeatureClass.GetDefinition().GetSpatialReference());
// Add the creation of the Places dataset to DDL task
FeatureDatasetToken featureDatasetToken = schemaBuilder.Create(featureDatasetDescription);
// Create an annotation feature class description using existing annotation feature class
AnnotationFeatureClassDescription annotationFeatureClassDescription = new AnnotationFeatureClassDescription(annotationFeatureClassName, existingAnnotationFeatureClass.GetDefinition())
{
IsAutoCreate = true,
IsSymbolIDRequired = false,
IsUpdatedOnShapeChange = true
};
// Add the creation of the Cities annotation feature class inside Places feature dataset
schemaBuilder.Create(new FeatureDatasetDescription(featureDatasetToken), annotationFeatureClassDescription);
// Execute the DDL
bool success = schemaBuilder.Build();
// Inspect error messages
if (!success)
{
IReadOnlyList<string> errorMessages = schemaBuilder.ErrorMessages;
//etc.
}
}
}public Geodatabase GetMemoryGeodatabase()
{
// Creates the default memory geodatabase if not exist or connects to an existing one if already exists
Geodatabase memoryGeodatabase = new Geodatabase(new MemoryConnectionProperties());
// Creates schema
SchemaBuilder schemaBuilder = new SchemaBuilder(memoryGeodatabase);
schemaBuilder.Create(new TableDescription("MyTable", new List<FieldDescription>()));
schemaBuilder.Build();
return memoryGeodatabase;
}public void FindSpatiallyRelatedFeaturesUsingDE9IMPredicate(Geodatabase geodatabase, FeatureClass polygonFeatureClass, FeatureClass polylineFeatureClass)
{
using (RowCursor polygonRowCursor = polygonFeatureClass.Search(new QueryFilter()))
{
if (polygonRowCursor.MoveNext())
{
using (Feature polygonFeature = polygonRowCursor.Current as Feature)
{
// DE9IM predicate string to find overlapping features
string overlappingDE9IM = "1*T***T**";
SpatialQueryFilter spatialQueryFilter = new SpatialQueryFilter()
{
FilterGeometry = polygonFeature.GetShape(),
SpatialRelationship = SpatialRelationship.Relation,
SpatialRelationshipDescription = overlappingDE9IM
};
using (RowCursor overlappingPolyline = polylineFeatureClass.Search(spatialQueryFilter))
{
while (overlappingPolyline.MoveNext())
{
// Overlapping polylines on the polygon
}
}
}
}
}
}public bool IsTableVersioned(Geodatabase geodatabase, string tableName)
{
using (Table table = geodatabase.OpenDataset<Table>(tableName))
{
// Check table version type
RegistrationType registrationType = table.GetRegistrationType();
if (registrationType == RegistrationType.Versioned)
{
return true;
}
}
return false;
}public void CreatingTableWithIndex(SchemaBuilder schemaBuilder)
{
FieldDescription nameFieldDescription = FieldDescription.CreateStringField("Name", 50);
FieldDescription addressFieldDescription = FieldDescription.CreateStringField("Address", 200);
// Creating a feature class, 'Buildings' with two fields
TableDescription tableDescription = new TableDescription("Buildings", new List<FieldDescription>() { nameFieldDescription, addressFieldDescription });
// Enqueue DDL operation to create a table
TableToken tableToken = schemaBuilder.Create(tableDescription);
// Creating an attribute index named as 'Idx'
AttributeIndexDescription attributeIndexDescription = new AttributeIndexDescription("Idx", new TableDescription(tableToken),
new List<string> { nameFieldDescription.Name, addressFieldDescription.Name });
// Enqueue DDL operation to create an attribute index
schemaBuilder.Create(attributeIndexDescription);
// Execute build indexes operation
bool isBuildSuccess = schemaBuilder.Build();
}public void AddingIndexes(SchemaBuilder schemaBuilder, FeatureClassDefinition featureClassDefinition)
{
// Field names to add in the attribute index
string fieldName = featureClassDefinition.GetFields().First(f => f.AliasName.Contains("Name")).Name;
string fieldAddress = featureClassDefinition.GetFields().First(f => f.AliasName.Contains("Address")).Name;
// Creating an attribute index with index name 'Idx' and two participating fields' name
AttributeIndexDescription attributeIndexDescription = new AttributeIndexDescription("Idx", new TableDescription(featureClassDefinition), new List<string> { fieldName, fieldAddress });
// Enqueue DDL operation for an attribute index creation
schemaBuilder.Create(attributeIndexDescription);
// Creating the spatial index
SpatialIndexDescription spatialIndexDescription = new SpatialIndexDescription(new FeatureClassDescription(featureClassDefinition));
// Enqueue DDL operation for the spatial index creation
schemaBuilder.Create(spatialIndexDescription);
// Execute build indexes operation
bool isBuildSuccess = schemaBuilder.Build();
if (!isBuildSuccess)
{
IReadOnlyList<string> errors = schemaBuilder.ErrorMessages;
// Iterate and handle errors
}
}public void RemoveAttributeIndex(SchemaBuilder schemaBuilder, FeatureClassDefinition featureClassDefinition, string attributeIndexName)
{
// Find a index to be removed
ArcGIS.Core.Data.Index indexToRemove = featureClassDefinition.GetIndexes().First(f => f.GetName().Equals(attributeIndexName));
// Index description of the index to be removed
AttributeIndexDescription indexDescriptionToRemove = new AttributeIndexDescription(indexToRemove, new TableDescription(featureClassDefinition));
// Enqueue the DDL operation to remove index
schemaBuilder.Delete(indexDescriptionToRemove);
// Execute the delete index operation
bool isDeleteIndexSuccess = schemaBuilder.Build();
}public void RemoveSpatialIndex(SchemaBuilder schemaBuilder, FeatureClassDefinition featureClassDefinition)
{
// Create a spatial description
SpatialIndexDescription spatialIndexDescription = new SpatialIndexDescription(new FeatureClassDescription(featureClassDefinition));
// Enqueue the DDL operation to remove index
schemaBuilder.Delete(spatialIndexDescription);
// Execute the delete index operation
bool isDeleteIndexSuccess = schemaBuilder.Build();
}public void ModifyDomain(Geodatabase geodatabase, string codedValueDomainName = "Pipe")
{
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
CodedValueDomain codedValueDomain = geodatabase.GetDomains().First(f => f.GetName().Equals(codedValueDomainName)) as CodedValueDomain;
CodedValueDomainDescription codedValueDomainDescription = new CodedValueDomainDescription(codedValueDomain);
// Update domain description
codedValueDomainDescription.Description = "Water Pipe Domain";
// Adding code/value pair
codedValueDomainDescription.CodedValuePairs.Add("C", "Copper");
schemaBuilder.Modify(codedValueDomainDescription);
// To modify the orders of coded value domain
// schemaBuilder.Modify(codedValueDomainDescription,SortBy.Name,SortOrder.Ascending);
schemaBuilder.Build();
}public void RenameDomain(Geodatabase geodatabase, string rangeDomainOldName = "PipeDiameter", string rangeDomainNewName = "PipeDiam")
{
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
RangeDomain rangeDomain = geodatabase.GetDomains().First(f => f.GetName().Equals(rangeDomainOldName)) as RangeDomain;
// Renaming a domain
schemaBuilder.Rename(new RangeDomainDescription(rangeDomain), rangeDomainNewName);
schemaBuilder.Build();
}public void DeleteDomain(Geodatabase geodatabase, string domainNameToBeDeleted = "PipeMaterial")
{
SchemaBuilder schemaBuilder = new SchemaBuilder(geodatabase);
CodedValueDomain codedValueDomain = geodatabase.GetDomains().First(f => f.GetName().Equals(domainNameToBeDeleted)) as CodedValueDomain;
CodedValueDomainDescription codedValueDomainDescription = new CodedValueDomainDescription(codedValueDomain);
// Deleting a coded value domain
schemaBuilder.Delete(codedValueDomainDescription);
schemaBuilder.Build();
}public void CreateTableWithSubtypes(SchemaBuilder schemaBuilder)
{
// Creating a 'Building' table with the subtype field 'BuildingType'
FieldDescription buildingType = new FieldDescription("BuildingType", FieldType.Integer);
FieldDescription buildingName = new FieldDescription("Name", FieldType.String);
TableDescription tableDescription = new TableDescription("Building", new List<FieldDescription> { buildingName, buildingType });
// Add the building type subtype with three subtypes - Business, Marketing, Security
tableDescription.SubtypeFieldDescription = new SubtypeFieldDescription(buildingType.Name, new Dictionary<int, string> { { 1, "Business" }, { 2, "Marketing" }, { 3, "Security" } })
{
DefaultSubtypeCode = 3 // Assigning 'Security' building type as the default subtype
};
schemaBuilder.Create(tableDescription);
schemaBuilder.Build();
}public void DeleteSubtypeField(SchemaBuilder schemaBuilder, FeatureClassDefinition featureClassDefinition)
{
FeatureClassDescription featureClassDescription = new FeatureClassDescription(featureClassDefinition);
// Set subtype field to null to remove the subtype field designation
featureClassDescription.SubtypeFieldDescription = null;
schemaBuilder.Modify(featureClassDescription);
schemaBuilder.Build();
}public void ModifySubtypes(SchemaBuilder schemaBuilder, TableDefinition tableDefinition)
{
TableDescription tableDescription = new TableDescription(tableDefinition);
// Remove the first subtype from the table
IReadOnlyList<Subtype> subtypes = tableDefinition.GetSubtypes();
tableDescription.SubtypeFieldDescription.Subtypes.Remove(subtypes.First().GetCode());
// Adding a new subtype, 'Utility', in the existing table
tableDescription.SubtypeFieldDescription.Subtypes.Add(4, "Utility");
// Assigning 'Utility' subtype as the default subtype
tableDescription.SubtypeFieldDescription.DefaultSubtypeCode = 4;
schemaBuilder.Modify(tableDescription);
schemaBuilder.Build();
}public void CreateRelationshipWithRelationshipRules(SchemaBuilder schemaBuilder)
{
// Creating a 'BuildingType' table with two fields - BuildingType and BuildingTypeDescription
FieldDescription buildingType = FieldDescription.CreateIntegerField("BuildingType");
FieldDescription buildingTypeeDescription = FieldDescription.CreateStringField("BuildingTypeDescription", 100);
TableDescription buildingTypeDescription = new TableDescription("BuildingType", new List<FieldDescription>() { buildingType, buildingTypeeDescription });
TableToken buildingtypeToken = schemaBuilder.Create(buildingTypeDescription);
// Creating a 'Building' feature class with three fields - BuildingId, Address, and BuildingType
FieldDescription buildingId = FieldDescription.CreateIntegerField("BuildingId");
FieldDescription buildingAddress = FieldDescription.CreateStringField("Address", 100);
FieldDescription usageSubType = FieldDescription.CreateIntegerField("UsageSubtype");
FeatureClassDescription featureClassDescription = new FeatureClassDescription("Building", new List<FieldDescription> { buildingId, buildingAddress, buildingType, usageSubType }, new ShapeDescription(GeometryType.Polygon, SpatialReferences.WGS84));
// Set subtype details (optional)
featureClassDescription.SubtypeFieldDescription = new SubtypeFieldDescription(usageSubType.Name, new Dictionary<int, string> { { 1, "Marketing" }, { 2, "Utility" } });
FeatureClassToken buildingToken = schemaBuilder.Create(featureClassDescription);
// Creating a 1:M relationship between the 'Building' feature class and 'BuildingType' table
RelationshipClassDescription relationshipClassDescription = new RelationshipClassDescription("BuildingToBuildingType", new FeatureClassDescription(buildingToken), new TableDescription(buildingtypeToken),
RelationshipCardinality.OneToMany, buildingType.Name, buildingType.Name)
{
RelationshipType = RelationshipType.Composite
};
// Adding relationship rules for the 'Marketing' subtype
relationshipClassDescription.RelationshipRuleDescriptions.Add(new RelationshipRuleDescription(1, null));
schemaBuilder.Create(relationshipClassDescription);
schemaBuilder.Build();
}public void CreateAttributedRelationship(SchemaBuilder schemaBuilder)
{
// Creating a 'BuildingType' table with two fields - BuildingType and BuildingTypeDescription
FieldDescription buildingType = FieldDescription.CreateIntegerField("BuildingType");
FieldDescription buildingTypeeDescription = FieldDescription.CreateStringField("BuildingTypeDescription", 100);
TableDescription buildingTypeDescription = new TableDescription("BuildingType", new List<FieldDescription>() { buildingType, buildingTypeeDescription });
TableToken buildingtypeToken = schemaBuilder.Create(buildingTypeDescription);
// Creating a 'Building' feature class with three fields - BuildingId, Address, and BuildingType
FieldDescription buildingId = FieldDescription.CreateIntegerField("BuildingId");
FieldDescription buildingAddress = FieldDescription.CreateStringField("Address", 100);
FeatureClassDescription featureClassDescription = new FeatureClassDescription("Building", new List<FieldDescription> { buildingId, buildingAddress, buildingType }, new ShapeDescription(GeometryType.Polygon, SpatialReferences.WGS84));
FeatureClassToken buildingToken = schemaBuilder.Create(featureClassDescription);
// Creating M:M relationship between the 'Building' feature class and 'BuildingType' table
AttributedRelationshipClassDescription attributedRelationshipClassDescription = new AttributedRelationshipClassDescription("BuildingToBuildingType", new FeatureClassDescription(buildingToken),
new TableDescription(buildingtypeToken), RelationshipCardinality.ManyToMany, "OBJECTID", "BuildingID", "OBJECTID", "BuildingTypeID");
// Adding optional attribute field in the intermediate table - 'OwnershipPercentage' field
attributedRelationshipClassDescription.FieldDescriptions.Add(FieldDescription.CreateIntegerField("OwnershipPercentage"));
schemaBuilder.Create(attributedRelationshipClassDescription);
schemaBuilder.Build();
}public void ModifyRelationshipClass(SchemaBuilder schemaBuilder, AttributedRelationshipClassDefinition attributedRelationshipClassDefinition)
{
AttributedRelationshipClassDescription attributedRelationshipClassDescription = new AttributedRelationshipClassDescription(attributedRelationshipClassDefinition);
// Update the relationship split policy
attributedRelationshipClassDescription.RelationshipSplitPolicy = RelationshipSplitPolicy.UseDefault;
// Add field in the intermediate table
attributedRelationshipClassDescription.FieldDescriptions.Add(FieldDescription.CreateIntegerField("RelationshipStatus"));
// Add relationship rules based on subtypes,if available
// Assuming origin class has subtype with code 1
attributedRelationshipClassDescription.RelationshipRuleDescriptions.Add(new RelationshipRuleDescription(1, null));
// Enqueue modify operation
schemaBuilder.Modify(attributedRelationshipClassDescription);
// Execute modify DDL operation
schemaBuilder.Build();
}public void DeleteRelationshipClass(SchemaBuilder schemaBuilder, RelationshipClassDefinition relationshipClassDefinition)
{
schemaBuilder.Delete(new RelationshipClassDescription(relationshipClassDefinition));
schemaBuilder.Build();
}public void MoveRelationshipClass(SchemaBuilder schemaBuilder, FeatureDatasetDefinition featureDatasetDefinition, RelationshipClassDefinition relationshipClassDefinition)
{
FeatureDatasetDescription featureDatasetDescription = new FeatureDatasetDescription(featureDatasetDefinition);
RelationshipClassDescription relationshipClassDescription = new RelationshipClassDescription(relationshipClassDefinition);
// Remove relationship class from the feature dataset
schemaBuilder.RemoveRelationshipClass(featureDatasetDescription, relationshipClassDescription);
// Add relationship class inside the feature dataset
// schemaBuilder.AddRelationshipClass(featureDatasetDescription, relationshipClassDescription);
schemaBuilder.Build();
}public void ModifyAnnotationLabelAndSymbols(SchemaBuilder schemaBuilder, AnnotationFeatureClassDefinition annotationFeatureClassDefinition)
{
AnnotationFeatureClassDescription annotationFeatureClassDescription = new AnnotationFeatureClassDescription(annotationFeatureClassDefinition);
IReadOnlyList<CIMLabelClass> labelClasses = annotationFeatureClassDescription.LabelClasses;
// Adding a new annotation label class
List<CIMLabelClass> modifiedLabelClasses = new List<CIMLabelClass>(labelClasses);
modifiedLabelClasses.Add(new CIMLabelClass()
{
Name = "RedSymbol",
TextSymbol = new CIMSymbolReference
{
Symbol = new CIMTextSymbol()
{
Angle = 45,
FontType = FontType.Type1,
FontFamilyName = "Arial",
FontEffects = FontEffects.Normal,
HaloSize = 2.0,
Symbol = new CIMPolygonSymbol { SymbolLayers = new CIMSymbolLayer[] { new CIMSolidFill { Color = CIMColor.CreateRGBColor(255, 0, 0) } }, UseRealWorldSymbolSizes = true }
},
MaxScale = 0,
MinScale = 0,
SymbolName = "TextSymbol-RED"
},
});
// Adding a new symbol
annotationFeatureClassDescription.Symbols.Add(new CIMSymbolIdentifier()
{
ID = 1001,
Name = "ID_10001",
Symbol = new CIMTextSymbol()
{
Angle = 43,
FontEffects = FontEffects.Subscript,
FontType = FontType.TTOpenType,
FontStyleName = "Regular",
FontFamilyName = "Tahoma",
TextCase = TextCase.Allcaps
}
});
// Modify annotation feature class
AnnotationFeatureClassDescription modifiedAnnotationFeatureClassDescription = new AnnotationFeatureClassDescription(annotationFeatureClassDescription.Name, annotationFeatureClassDescription.FieldDescriptions, annotationFeatureClassDescription.ShapeDescription, annotationFeatureClassDescription.GeneralPlacementProperties, modifiedLabelClasses);
// Enqueue modify
schemaBuilder.Modify(modifiedAnnotationFeatureClassDescription);
// DDL execute
schemaBuilder.Build();
}public void Rename(SchemaBuilder schemaBuilder, AnnotationFeatureClassDefinition annotationFeatureClassDefinition, string featureClassNewName)
{
AnnotationFeatureClassDescription annotationFeatureClassDescription = new AnnotationFeatureClassDescription(annotationFeatureClassDefinition);
// Enqueue rename operation
schemaBuilder.Rename(annotationFeatureClassDescription, featureClassNewName);
// Execute DDL
schemaBuilder.Build();
}private void ModifyExistingField(SchemaBuilder schemaBuilder, TableDefinition tableDefinition, string fieldNameToBeModified = "PropertyAddress")
{
Field field = tableDefinition.GetFields().FirstOrDefault(f => f.Name.Contains(fieldNameToBeModified));
// Update field's alias name and length
FieldDescription fieldDescription = new FieldDescription(field)
{
AliasName = "Physical Property Address",
Length = 50
};
// Update the default value
fieldDescription.SetDefaultValue("123 Main St");
// Enqueue modify operation
schemaBuilder.Modify(new TableDescription(tableDefinition), field.Name, fieldDescription);
// Execute DDL
schemaBuilder.Build();
} 