/// <summary> /// Illustrates how to use the HasValueChanged() method. /// </summary> /// <returns></returns> private static async Task FileGeodatabaseWorkFlow() { using (Geodatabase fileGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb")))) using (FeatureClass featureClass = fileGeodatabase.OpenDataset <FeatureClass>("PollingPlace")) { EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { QueryFilter queryFilter = new QueryFilter { WhereClause = "FULLADD LIKE '///%Lily Cache Ln///%'" }; using (RowCursor rowCursor = featureClass.Search(queryFilter, false)) { FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition(); int shapeFieldIndex = featureClassDefinition.FindField(featureClassDefinition.GetShapeField()); while (rowCursor.MoveNext()) { using (Feature feature = (Feature)rowCursor.Current) { MapPoint mapPoint = feature.GetShape() as MapPoint; // Will be false. bool beforeChange = feature.HasValueChanged(shapeFieldIndex); // 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); MapPoint newShape = new MapPointBuilder(mapPoint.X + 10, mapPoint.Y, mapPoint.SpatialReference).ToGeometry(); feature.SetShape(newShape); // Will be true. bool afterChange = feature.HasValueChanged(shapeFieldIndex); feature.Store(); //Will be false. bool afterStore = feature.HasValueChanged(shapeFieldIndex); // Has to be called after the store too context.Invalidate(feature); } } } }, featureClass); bool editResult = editOperation.Execute(); //This is required to persist the changes to the disk. bool saveResult = await Project.Current.SaveEditsAsync(); } }
public void MainMethodCode() { // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) using (FeatureClassDefinition featureClassDefinition = geodatabase.GetDefinition <FeatureClassDefinition>("LocalGovernment.GDB.ServiceRequestComment")) { int rankIndex = featureClassDefinition.FindField("RANK"); Field field = featureClassDefinition.GetFields()[rankIndex]; Domain domain = field.GetDomain(); RangeDomain rangeDomain = (RangeDomain)domain; // Will be "ServiceRequestRanking". string name = rangeDomain.GetName(); // Will be FieldType.Integer. FieldType fieldType = rangeDomain.GetFieldType(); // Will be "A factor assigned to unassigned service requests indicating importance". string description = rangeDomain.GetDescription(); // Will be 1. int minValue = Convert.ToInt32(rangeDomain.GetMinValue()); // Will be 5. int maxValue = Convert.ToInt32(rangeDomain.GetMaxValue()); } }
protected override WorkListStatusSchema CreateStatusSchemaCore(FeatureClassDefinition definition) { int fieldIndex; try { fieldIndex = definition.FindField(_statusFieldName); if (fieldIndex < 0) { throw new ArgumentException($"No field {_statusFieldName}"); } } catch (Exception e) { _msg.Error($"Error find field {_statusFieldName} in {definition.GetName()}", e); throw; } return(new WorkListStatusSchema(_statusFieldName, fieldIndex, (int)IssueCorrectionStatus.NotCorrected, (int)IssueCorrectionStatus.Corrected)); }
private async Task <string> AddFeatureToLayer(Geometry geom, EllipseAttributes attributes) { string message = String.Empty; if (attributes == null) { message = "Attributes are Empty"; // For debug does not need to be resource return(message); } FeatureClass ellipseFeatureClass = await GetFeatureClass(addToMapIfNotPresent : true); if (ellipseFeatureClass == null) { message = DistanceAndDirectionLibrary.Properties.Resources.ErrorFeatureClassNotFound + this.GetLayerName(); return(message); } bool creationResult = false; FeatureClassDefinition ellipseDefinition = ellipseFeatureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Name = "Ellipse Feature Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = ellipseFeatureClass.CreateRowBuffer(); if (ellipseDefinition.FindField("Major") >= 0) { rowBuffer["Major"] = attributes.majorAxis; // Text } if (ellipseDefinition.FindField("Minor") >= 0) { rowBuffer["Minor"] = attributes.minorAxis; // Double } if (ellipseDefinition.FindField("DistUnit") >= 0) { rowBuffer["DistUnit"] = attributes.distanceunit; // Text } if (ellipseDefinition.FindField("Angle") >= 0) { rowBuffer["Angle"] = attributes.angle; // Double } if (ellipseDefinition.FindField("AngleUnit") >= 0) { rowBuffer["AngleUnit"] = attributes.angleunit; // Text } if (ellipseDefinition.FindField("CenterX") >= 0) { rowBuffer["CenterX"] = attributes.centerx; // Double } if (ellipseDefinition.FindField("CenterY") >= 0) { rowBuffer["CenterY"] = attributes.centery; // Double } rowBuffer["Shape"] = GeometryEngine.Instance.Project(geom, ellipseDefinition.GetSpatialReference()); Feature feature = ellipseFeatureClass.CreateRow(rowBuffer); feature.Store(); //To indicate that the attribute table has to be updated context.Invalidate(feature); } catch (GeodatabaseException geodatabaseException) { message = geodatabaseException.Message; } catch (Exception ex) { message = ex.Message; } }, ellipseFeatureClass); await QueuedTask.Run(async() => { creationResult = await editOperation.ExecuteAsync(); }); if (!creationResult) { message = editOperation.ErrorMessage; } return(message); }
private async Task <string> AddFeatureToLayer(Geometry geom, RangeAttributes attributes) { string message = String.Empty; if (attributes == null) { message = "Attributes are Empty"; // For debug does not need to be resource return(message); } FeatureClass ringFeatureClass = await GetFeatureClass(addToMapIfNotPresent : true); if (ringFeatureClass == null) { message = DistanceAndDirectionLibrary.Properties.Resources.ErrorFeatureClassNotFound + this.GetLayerName(); return(message); } bool creationResult = false; FeatureClassDefinition ringDefinition = ringFeatureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Name = "Ring Feature Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = ringFeatureClass.CreateRowBuffer(); if (ringDefinition.FindField("Distance") >= 0) { rowBuffer["Distance"] = attributes.distance; // Double } if (ringDefinition.FindField("DistUnit") >= 0) { rowBuffer["DistUnit"] = attributes.distanceunit; // Text } if (ringDefinition.FindField("Rings") >= 0) { rowBuffer["Rings"] = attributes.numRings; // Double } if (ringDefinition.FindField("CenterX") >= 0) { rowBuffer["CenterX"] = attributes.centerx; // Double } if (ringDefinition.FindField("CenterY") >= 0) { rowBuffer["CenterY"] = attributes.centery; // Double } if (ringDefinition.FindField("RRType") >= 0) { rowBuffer["RRType"] = attributes.ringorradial; // Double } // Ensure Z removed (this feature class does not have Z) var geoNoZ = geom; if (geom.HasZ) { PolylineBuilder pb = new PolylineBuilder((Polyline)geom); pb.HasZ = false; geoNoZ = pb.ToGeometry(); } rowBuffer["Shape"] = GeometryEngine.Instance.Project(geoNoZ, ringDefinition.GetSpatialReference()); Feature feature = ringFeatureClass.CreateRow(rowBuffer); feature.Store(); //To Indicate that the attribute table has to be updated context.Invalidate(feature); } catch (GeodatabaseException geodatabaseException) { message = geodatabaseException.Message; } catch (Exception ex) { message = ex.Message; } }, ringFeatureClass); await QueuedTask.Run(async() => { creationResult = await editOperation.ExecuteAsync(); }); if (!creationResult) { message = editOperation.ErrorMessage; } return(message); }
private async Task <string> AddFeatureToLayer(Geometry geom, CircleAttributes attributes) { string message = String.Empty; if (attributes == null) { message = "Attributes are Empty"; // For debug does not need to be resource return(message); } FeatureClass circleFeatureClass = await GetFeatureClass(addToMapIfNotPresent : true); if (circleFeatureClass == null) { message = DistanceAndDirectionLibrary.Properties.Resources.ErrorFeatureClassNotFound + this.GetLayerName(); return(message); } bool creationResult = false; FeatureClassDefinition circleDefinition = circleFeatureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Name = "Circular Feature Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = circleFeatureClass.CreateRowBuffer(); double distance = attributes.distance; if (IsDistanceCalcExpanded && (CircleType == CircleFromTypes.Diameter)) { distance *= 2.0; } if (circleDefinition.FindField("Distance") >= 0) { rowBuffer["Distance"] = distance; // Double } if (circleDefinition.FindField("DistUnit") >= 0) { rowBuffer["DistUnit"] = attributes.distanceunit; // Text } if (circleDefinition.FindField("DistType") >= 0) { rowBuffer["DistType"] = attributes.circletype; // Text } if (circleDefinition.FindField("CenterX") >= 0) { rowBuffer["CenterX"] = attributes.centerx; // Double } if (circleDefinition.FindField("CenterY") >= 0) { rowBuffer["CenterY"] = attributes.centery; // Double } rowBuffer["Shape"] = GeometryEngine.Instance.Project(geom, circleDefinition.GetSpatialReference()); Feature feature = circleFeatureClass.CreateRow(rowBuffer); feature.Store(); //To Indicate that the attribute table has to be updated context.Invalidate(feature); } catch (GeodatabaseException geodatabaseException) { message = geodatabaseException.Message; } catch (Exception ex) { message = ex.Message; } }, circleFeatureClass); await QueuedTask.Run(async() => { creationResult = await editOperation.ExecuteAsync(); }); if (!creationResult) { message = editOperation.ErrorMessage; await Project.Current.DiscardEditsAsync(); } else { await Project.Current.SaveEditsAsync(); } return(message); }
private static async Task EnterpriseGeodabaseWorkFlow() { // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.FacilitySite")) { EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { RowBuffer rowBuffer = null; Feature feature = null; try { FeatureClassDefinition facilitySiteDefinition = enterpriseFeatureClass.GetDefinition(); int facilityIdIndex = facilitySiteDefinition.FindField("FACILITYID"); rowBuffer = enterpriseFeatureClass.CreateRowBuffer(); // Either the field index or the field name can be used in the indexer. rowBuffer[facilityIdIndex] = "FAC-400"; 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 PolygonBuilder(newCoordinates).ToGeometry(); feature = enterpriseFeatureClass.CreateRow(rowBuffer); //To Indicate that the Map has to draw this feature and/or the attribute table to be updated context.Invalidate(feature); long objectID = feature.GetObjectID(); Polygon polygon = feature.GetShape() as Polygon; // Do some other processing with the newly-created feature. } catch (GeodatabaseException exObj) { Console.WriteLine(exObj); } finally { if (rowBuffer != null) { rowBuffer.Dispose(); } if (feature != null) { feature.Dispose(); } } }, enterpriseFeatureClass); bool editResult = editOperation.Execute(); // If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted. bool saveResult = await Project.Current.SaveEditsAsync(); } }
// Illustrates creating a feature in a File GDB. private static async Task FileGeodatabaseWorkFlow() { using (Geodatabase fileGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb")))) using (FeatureClass featureClass = fileGeodatabase.OpenDataset <FeatureClass>("PollingPlace")) { RowBuffer rowBuffer = null; Feature feature = null; try { EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition(); int nameIndex = featureClassDefinition.FindField("NAME"); rowBuffer = featureClass.CreateRowBuffer(); // Either the field index or the field name can be used in the indexer. rowBuffer[nameIndex] = "New School"; rowBuffer["POLLINGID"] = "260"; rowBuffer["FULLADD"] = "100 New Street"; rowBuffer["CITY"] = "Naperville"; rowBuffer["STATE"] = "IL"; rowBuffer["OPERHOURS"] = "Yes"; rowBuffer["HANDICAP"] = "6.00am=7.00pm"; rowBuffer["NEXTELECT"] = "11/6/2012"; rowBuffer["REGDATE"] = "8/6/2012"; rowBuffer["PHONE"] = "815-740-4782"; rowBuffer["EMAIL"] = "*****@*****.**"; rowBuffer[featureClassDefinition.GetShapeField()] = new MapPointBuilder(1028367, 1809789).ToGeometry(); feature = featureClass.CreateRow(rowBuffer); //To Indicate that the Map has to draw this feature and/or the attribute table to be updated context.Invalidate(feature); // Do some other processing with the newly-created feature. }, featureClass); bool editResult = editOperation.Execute(); // At this point the changes are visible in the process, but not persisted/visible outside. long objectID = feature.GetObjectID(); MapPoint mapPoint = feature.GetShape() as MapPoint; // If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted. bool saveResult = await Project.Current.SaveEditsAsync(); } catch (GeodatabaseException exObj) { Console.WriteLine(exObj); throw; } finally { if (rowBuffer != null) { rowBuffer.Dispose(); } if (feature != null) { feature.Dispose(); } } } }
public void MainMethodCode() { // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.FacilitySite")) { FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition(); int facilityCodeIndex = featureClassDefinition.FindField("FCODE"); Field field = featureClassDefinition.GetFields()[facilityCodeIndex]; Domain domain = field.GetDomain(featureClassDefinition.GetSubtypes().FirstOrDefault( subtype => subtype.GetName().ToLowerInvariant().Contains("agriculture"))); CodedValueDomain codedValueDomain = (CodedValueDomain)domain; // Will be "Agriculture Food and Livestock FCode"'. string name = codedValueDomain.GetName(); // Will be FieldType.String'. FieldType fieldType = codedValueDomain.GetFieldType(); // Will be "The type of agriculture, food and livestock facility"'. string description = codedValueDomain.GetDescription(); // Will be 13 since there are 13 code value pairs in this domain'. int numberOfcodedValues = codedValueDomain.GetCount(); // This will be a the code value pairs sorted (in this case) by the codes' increasing integer value. SortedList <object, string> codedValuePairs = codedValueDomain.GetCodedValuePairs(); FeatureClassDefinition siteAddressPointDefinition = geodatabase.GetDefinition <FeatureClassDefinition>("LocalGovernment.GDB.SiteAddressPoint"); int unitTypeIndex = siteAddressPointDefinition.FindField("UNITTYPE"); Field unitTypeField = siteAddressPointDefinition.GetFields()[unitTypeIndex]; Domain addressUnitTypeDomain = unitTypeField.GetDomain(); CodedValueDomain valueDomain = (CodedValueDomain)addressUnitTypeDomain; // Will be Apartment. string aptCodeDescription = valueDomain.GetName("APT"); // Will be Basement. string bsmtCodeDescription = valueDomain.GetName("BSMT"); // Will be DEPT. Make sure you know the domain's FieldType is String before cast. string departmentCode = valueDomain.GetCodedValue("Department") as string; // Will be FL. string floorCode = valueDomain.GetCodedValue("Floor") as string; } }
private static async Task EnterpriseGeodabaseWorkFlow() { // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.FacilitySite")) { 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 PolygonBuilder(newCoordinates).ToGeometry()); } feature.Store(); // Has to be called after the store too context.Invalidate(feature); } } } }, enterpriseFeatureClass); bool editResult = editOperation.Execute(); // If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted. bool saveResult = await Project.Current.SaveEditsAsync(); } }
private async Task <string> AddFeatureToLayer(Geometry geom, LineAttributes attributes) { string message = String.Empty; if (attributes == null) { message = "Attributes are Empty"; // For debug does not need to be resource return(message); } FeatureClass lineFeatureClass = await GetFeatureClass(addToMapIfNotPresent : true); if (lineFeatureClass == null) { message = DistanceAndDirectionLibrary.Properties.Resources.ErrorFeatureClassNotFound + this.GetLayerName(); return(message); } bool creationResult = false; FeatureClassDefinition lineDefinition = lineFeatureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Name = "Line Feature Insert"; editOperation.Callback(context => { try { RowBuffer rowBuffer = lineFeatureClass.CreateRowBuffer(); if (lineDefinition.FindField("Distance") >= 0) { rowBuffer["Distance"] = attributes.distance; // Double } if (lineDefinition.FindField("DistUnit") >= 0) { rowBuffer["DistUnit"] = attributes.distanceunit; // Text } if (lineDefinition.FindField("Angle") >= 0) { rowBuffer["Angle"] = attributes.angle; // Double } if (lineDefinition.FindField("AngleUnit") >= 0) { rowBuffer["AngleUnit"] = attributes.angleunit; // Text } if (lineDefinition.FindField("OriginX") >= 0) { rowBuffer["OriginX"] = attributes.originx; // Double } if (lineDefinition.FindField("OriginY") >= 0) { rowBuffer["OriginY"] = attributes.originy; // Double } if (lineDefinition.FindField("DestX") >= 0) { rowBuffer["DestX"] = attributes.destinationx; // Double } if (lineDefinition.FindField("DestY") >= 0) { rowBuffer["DestY"] = attributes.destinationy; // Double } // Ensure Geometry Has Z var geomZ = geom; if (!geom.HasZ) { PolylineBuilder pb = new PolylineBuilder((Polyline)geom); pb.HasZ = true; geomZ = pb.ToGeometry(); } rowBuffer["Shape"] = GeometryEngine.Instance.Project(geomZ, lineDefinition.GetSpatialReference()); Feature feature = lineFeatureClass.CreateRow(rowBuffer); feature.Store(); //To Indicate that the attribute table has to be updated context.Invalidate(feature); } catch (GeodatabaseException geodatabaseException) { message = geodatabaseException.Message; } catch (Exception ex) { message = ex.Message; } }, lineFeatureClass); await QueuedTask.Run(async() => { creationResult = await editOperation.ExecuteAsync(); }); if (!creationResult) { message = editOperation.ErrorMessage; } return(message); }
public void MainMethodCode() { // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.FacilitySite")) { FeatureClassDefinition facilitySiteDefinition = enterpriseFeatureClass.GetDefinition(); int facilityCodeIndex = facilitySiteDefinition.FindField("FCODE"); int subtypeFieldIndex = facilitySiteDefinition.FindField(facilitySiteDefinition.GetSubtypeField()); // Agriculture, Food and Livestock subtype. Subtype agricultureSubtype = facilitySiteDefinition.GetSubtypes().First(subtype => subtype.GetCode() == 701); // Industry Subtype. Subtype industrySubtype = facilitySiteDefinition.GetSubtypes().First(subtype => subtype.GetName().Equals("Industry")); Field faclilityCodeField = facilitySiteDefinition.GetFields()[facilityCodeIndex]; // This will be true since FCODE is a Text field. if (faclilityCodeField.FieldType.Equals(FieldType.String)) { // This will be null since at the field level there is no default value. string fieldLevelDefaultValue = faclilityCodeField.GetDefaultValue() as String; // This will be "Agriculture or Livestock Structure". string defaultValueForAgricultureSubtype = faclilityCodeField.GetDefaultValue(agricultureSubtype) as String; // This will be "Industrial Facility". string defaultValueForIndustrySubtype = faclilityCodeField.GetDefaultValue(industrySubtype) as String; } Field subtypeField = facilitySiteDefinition.GetFields()[subtypeFieldIndex]; // This will be true since SUBTYPEFIELD is a Long Integer field. if (subtypeField.FieldType.Equals(FieldType.Integer)) { // This will be 701 since at the field level the default value is set. int fieldLevelDefaultValue = Convert.ToInt32(subtypeField.GetDefaultValue()); // This will give you 701 since it is Agriculture, Food and Livestock subtype subtype. int defaultValueForAgricultureSubtype = Convert.ToInt32(subtypeField.GetDefaultValue(agricultureSubtype)); // This will give you 710 since it is Industry subtype. int defaultValueForIndustrySubtype = Convert.ToInt32(subtypeField.GetDefaultValue(industrySubtype)); } } }
public async Task MainMethodCode() { // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) 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")) { FeatureClassDefinition overviewDefinition = overviewFeatureClass.GetDefinition(); // Because the following fields are used in 2 places, it is more inefficient to get their respective indexes so that they can be resued. int projectManagerIndex = overviewDefinition.FindField("PROJECTMAN"); int fundSourceIndex = overviewDefinition.FindField("FUNDSOUR"); RelationshipClassDefinition relationshipClassDefinition = relationshipClass.GetDefinition(); // This will be PROJNAME. This can be used to get the field index or used directly as the field name. string originKeyField = relationshipClassDefinition.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. RowBuffer projectsRowBuffer = projectsFeatureClass.CreateRowBuffer(); projectsRowBuffer["TOTCOST"] = 500000; RowBuffer overviewRowBufferWithoutPKValue = overviewFeatureClass.CreateRowBuffer(); overviewRowBufferWithoutPKValue[projectManagerIndex] = "John Doe"; overviewRowBufferWithoutPKValue[fundSourceIndex] = "Public"; RowBuffer overviewRowBuffer = overviewFeatureClass.CreateRowBuffer(); overviewRowBuffer["PROJNAME"] = "LibraryConstruction"; overviewRowBuffer[projectManagerIndex] = "John Doe"; overviewRowBuffer[fundSourceIndex] = "Public"; using (Row projectsRow = projectsFeatureClass.CreateRow(projectsRowBuffer)) using (Row overviewRowWithoutPKValue = overviewFeatureClass.CreateRow(overviewRowBufferWithoutPKValue)) using (Row overviewRow = overviewFeatureClass.CreateRow(overviewRowBuffer)) { try { Relationship failingRelationship = relationshipClass.CreateRelationship(overviewRowWithoutPKValue, projectsRow); } catch (GeodatabaseRelationshipClassException exception) { // This will have a message "Unable to obtain origin primary key value.". So, the origin row needs to have the origin *primary* // key value referenced by the origin *foreign* key value in the RelationshipClass. Console.WriteLine(exception); } 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(); //If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted. bool saveResult = await Project.Current.SaveEditsAsync(); } }
public void MainMethodCode() { using (Geodatabase fileGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(@"C:\Data\LocalGovernment.gdb")))) using (FeatureClass featureClass = fileGeodatabase.OpenDataset <FeatureClass>("PollingPlace")) { FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition(); int areaFieldIndex = featureClassDefinition.FindField(featureClassDefinition.GetAreaField()); // ******************** WITHOUT USING RECYCLING ******************** QueryFilter queryFilter = new QueryFilter { WhereClause = "CITY = 'Plainfield'" }; List <Feature> features = new List <Feature>(); // Searching is similar to that of Table when using Queryfilter. using (RowCursor cursor = featureClass.Search(queryFilter, false)) { while (cursor.MoveNext()) { // Each object returned by RowCursor.Current can be cast to a Feature object if the Search was performed on a FeatureClass. features.Add(cursor.Current as Feature); } } IEnumerable <Feature> featuresHavingShapePopulated = features.Where(feature => !feature.GetShape().IsEmpty); // Since Feature encapsulates unmanaged resources, it is important to remember to call Dispose() on every entry in the list when // the list is no longer in use. Alternatively, do not add the features to the list. Instead, process each of them inside the cursor. Dispose(features); // ******************** USING RECYCLING ******************** using (RowCursor recyclingCursor = featureClass.Search(queryFilter)) { while (recyclingCursor.MoveNext()) { // Similar to a RowCursor on a Table, when a MoveNext is executed, the same feature object is populated with the next feature's details // So any processing should be done on the Current Feature before the MoveNext is called again. Feature feature = (Feature)recyclingCursor.Current; if (Convert.ToDouble(feature[areaFieldIndex]) > 500) { Console.WriteLine(feature.GetShape().ToXML()); } } } } // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) 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 PolygonBuilder(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. Console.WriteLine(feature.GetObjectID()); } } } } }
public static async Task <BA_ReturnCode> UpdateFeatureAttributesAsync(Uri gdbUri, string featureClassName, QueryFilter oQueryFilter, IDictionary <string, string> dictEdits) { bool modificationResult = false; string errorMsg = ""; await QueuedTask.Run(() => { using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(gdbUri))) using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>(featureClassName)) { FeatureClassDefinition featureClassDefinition = featureClass.GetDefinition(); EditOperation editOperation = new EditOperation(); editOperation.Callback(context => { using (RowCursor rowCursor = featureClass.Search(oQueryFilter, false)) { while (rowCursor.MoveNext()) { using (Feature feature = (Feature)rowCursor.Current) { // In order to update the the attribute table has to be called before any changes are made to the row context.Invalidate(feature); // Loop through fields to update foreach (string strKey in dictEdits.Keys) { int idxRow = featureClassDefinition.FindField(strKey); if (idxRow > -1) { feature[idxRow] = dictEdits[strKey]; } } feature.Store(); // Has to be called after the store too context.Invalidate(feature); } } } }, featureClass); try { modificationResult = editOperation.Execute(); if (!modificationResult) { errorMsg = editOperation.ErrorMessage; } } catch (GeodatabaseException exObj) { errorMsg = exObj.Message; } } }); if (String.IsNullOrEmpty(errorMsg)) { await Project.Current.SaveEditsAsync(); return(BA_ReturnCode.Success); } else { if (Project.Current.HasEdits) { await Project.Current.DiscardEditsAsync(); } Module1.Current.ModuleLogManager.LogError(nameof(UpdateFeatureAttributesAsync), "Exception: " + errorMsg); return(BA_ReturnCode.UnknownError); } }
public void MainMethodCode() { // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) using (FeatureClass enterpriseFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.FacilitySite")) { FeatureClassDefinition facilitySiteDefinition = enterpriseFeatureClass.GetDefinition(); int facilityCodeIndex = facilitySiteDefinition.FindField("FCODE"); int ownerTypeIndex = facilitySiteDefinition.FindField("OWNTYPE"); int subtypeFieldIndex = facilitySiteDefinition.FindField(facilitySiteDefinition.GetSubtypeField()); // Agriculture, Food and Livestock subtype. Subtype agricultureSubtype = facilitySiteDefinition.GetSubtypes().First(subtype => subtype.GetCode() == 701); // Industry Subtype. Subtype industrySubtype = facilitySiteDefinition.GetSubtypes().First(subtype => subtype.GetName().Equals("Industry")); Field faclilityCodeField = facilitySiteDefinition.GetFields()[facilityCodeIndex]; // This will be null since there is not domain assigned at the field level. Domain facilityCodeFieldLevelDomain = faclilityCodeField.GetDomain(); Domain facilityCodeAgricultureSubtypeDomain = faclilityCodeField.GetDomain(agricultureSubtype); // This will be "Agriculture Food and Livestock FCode". string facilityCodeAgricultureSubtypeDomainName = facilityCodeAgricultureSubtypeDomain.GetName(); Domain facilityCodeIndustrySubtypeDomain = faclilityCodeField.GetDomain(industrySubtype); // This will be "Industry FCode" string facilityCodeIndustrySubtypeDomainName = facilityCodeIndustrySubtypeDomain.GetName(); Field ownerTypeField = facilitySiteDefinition.GetFields()[ownerTypeIndex]; Domain ownerTypeFieldLevelDomain = ownerTypeField.GetDomain(); // This will be "OwnerType". string ownerTypeFieldLevelDomainName = ownerTypeFieldLevelDomain.GetName(); Domain ownerTypeAgricultureSubtypeDomain = ownerTypeField.GetDomain(agricultureSubtype); // This will be "OwnerType" because the same domain has been set at the subtype level. string ownerTypeAgricultureSubtypeDomainName = ownerTypeAgricultureSubtypeDomain.GetName(); Domain ownerTypeIndustrySubtypeDomain = ownerTypeField.GetDomain(industrySubtype); // This will be "OwnerType" because the same domain has been set at the subtype level. string ownerTypeIndustrySubtypeDomainName = ownerTypeIndustrySubtypeDomain.GetName(); Field subtypeField = facilitySiteDefinition.GetFields()[subtypeFieldIndex]; // This will be null. Domain subtypeField_FieldLevelDomain = subtypeField.GetDomain(); // This will be null. Domain subtypeField_AgricultureSubtypeDomain = subtypeField.GetDomain(agricultureSubtype); // This will be null. Domain subtypeField_IndustrySubtypeDomain = subtypeField.GetDomain(industrySubtype); } }
public static async Task <IList <BA_Objects.Interval> > GetUniqueSortedValuesAsync(Uri gdbUri, string featClassName, string valueFieldName, string nameFieldName, double upperBound, double lowerBound) { IList <BA_Objects.Interval> lstInterval = new List <BA_Objects.Interval>(); if (gdbUri.IsFile) { string strFolderPath = System.IO.Path.GetDirectoryName(gdbUri.LocalPath); if (System.IO.Directory.Exists(strFolderPath)) { await QueuedTask.Run(() => { //get Dictionary of unique elevations from the vector att IDictionary <String, String> dictElev = new Dictionary <String, String>(); using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(gdbUri))) using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>(featClassName)) { FeatureClassDefinition def = featureClass.GetDefinition(); int idxElev = def.FindField(valueFieldName); int idxName = def.FindField(nameFieldName); if (idxElev < 0 || idxName < 0) { Module1.Current.ModuleLogManager.LogError(nameof(GetUniqueSortedValuesAsync), "A required field was missing from " + featClassName + ". Process failed!"); return; } using (RowCursor rowCursor = featureClass.Search(new QueryFilter(), false)) { while (rowCursor.MoveNext()) { using (Feature feature = (Feature)rowCursor.Current) { string strElev = Convert.ToString(feature[idxElev]); string strName = ""; if (feature[idxName] == null) { strName = "Name missing"; } else { strName = Convert.ToString(feature[idxName]); if (String.IsNullOrEmpty(strName)) { strName = "Name missing"; } } if (dictElev.ContainsKey(strElev)) { strName = dictElev[strElev] + ", " + strName; dictElev[strElev] = strName; } else { dictElev.Add(strElev, strName); } } } } } List <double> lstValidValues = new List <double>(); int nuniquevalue = dictElev.Keys.Count; double value = -1.0F; bool bSuccess = false; foreach (var strElev in dictElev.Keys) { bSuccess = Double.TryParse(strElev, out value); if ((int)(value - 0.5) < (int)upperBound && (int)value + 0.5 > (int)lowerBound) { lstValidValues.Add(value); } else if (value > upperBound || value < lowerBound) //invalid data in the attribute field, out of bound { Module1.Current.ModuleLogManager.LogError(nameof(GetUniqueSortedValuesAsync), "WARNING!! A monitoring site is ignored in the analysis! The site's elevation (" + value + ") is outside the DEM range (" + lowerBound + ", " + upperBound + ")!"); } } //add upper and lower bnds to the dictionary if (!dictElev.ContainsKey(Convert.ToString(upperBound))) { dictElev.Add(Convert.ToString(upperBound), "Not represented"); lstValidValues.Add(upperBound); } if (!dictElev.ContainsKey(Convert.ToString(lowerBound))) { dictElev.Add(Convert.ToString(lowerBound), "Min Value"); lstValidValues.Add(lowerBound); } // Sort the list lstValidValues.Sort(); // Add lower bound to interval list for (int i = 0; i < lstValidValues.Count - 1; i++) { BA_Objects.Interval interval = new BA_Objects.Interval(); interval.Value = i + 1; interval.LowerBound = lstValidValues[i]; double nextItem = lstValidValues[i + 1]; interval.UpperBound = nextItem; interval.Name = dictElev[Convert.ToString(nextItem)]; // use the upperbnd name to represent the interval lstInterval.Add(interval); } }); } } return(lstInterval); }
public void MainMethodCode() { // 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 = "******", Password = "******", Version = "dbo.DEFAULT" }; using (Geodatabase geodatabase = new Geodatabase(connectionProperties)) 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///%'" }; // If you need to *cache* the rows retrieved from the cursor for processing later, it is important that you don't use recycling in // the Search() method (i.e., useRecyclingCursor must be set to *false*). Also, the returned rows/features cached in the list // should be disposed when no longer in use so that unmanaged resources are not held on to longer than necessary. 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'" }; Selection selection = inspectionTable.Select(filter, SelectionType.ObjectID, SelectionOption.Normal); relatedOriginRows = relationshipClass.GetRowsRelatedToDestinationRows(selection.GetObjectIDs()); // Find out if any of 1st Notice inspections were from Jefferson Avenue. FeatureClassDefinition featureClassDefinition = violationsFeatureClass.GetDefinition(); int locationDescriptionIndex = featureClassDefinition.FindField("LOCDESC"); bool containsJeffersonAve = relatedOriginRows.Any(row => Convert.ToString(row[locationDescriptionIndex]).Contains("Jefferson")); List <long> jeffersonAveViolationObjectIds = jeffersonAveViolations.Select(row => row.GetObjectID()).ToList(); relatedDestinationRows = relationshipClass.GetRowsRelatedToOriginRows(jeffersonAveViolationObjectIds); //Find out if any Jefferson Ave Violations have 1st Notice Inspections TableDefinition tableDefinition = inspectionTable.GetDefinition(); int actionFieldIndex = tableDefinition.FindField("ACTION"); bool hasFirstNoticeInspections = relatedDestinationRows.Any(row => Convert.ToString(row[actionFieldIndex]).Contains("1st Notice")); } finally { Dispose(jeffersonAveViolations); Dispose(relatedOriginRows); Dispose(relatedDestinationRows); } } }