Geodatabase

• Engine
• ArcGIS for Desktop Basic
• ArcGIS for Desktop Standard
• ArcGIS for Desktop Advanced
• Server

• ESRI.ArcGIS.Geodatabase
• ESRI.ArcGIS.GeoDatabaseDistributed
• ESRI.ArcGIS.Geometry
• ESRI.ArcGIS.System (ESRI.ArcGIS.esriSystem)

• Core geodatabase
• Geometric network
• Topology
• Data elements
• TIN
• Data transfer
• Versioning
• Archiving
• Name objects
• Relationship query table
• Raster
• Metadata
• Plug-in data sources
• Network dataset
• Representation class

Core geodatabase

• Workspace in the geodatabase data model corresponds to a geodatabase, an ArcInfo coverage workspace, or a folder with shapefiles.
• Dataset is the highest level data container.
• Geodataset is a dataset that contains geographic data.
• FeatureDataset is comprised of feature classes, geometric networks, and topologies.
• Table is a collection of rows that have attributes stored in columns.
• Row is a record in a table. All rows in a table share the same set of fields.
• ObjectClass is a type of table that stores non-spatial objects.
• Object is a row with an object identifier.
• FeatureClass is a type of object class that stores spatial objects.
• Feature is an object with a geometric shape.
• RelationshipClass represents relationships through embedded foreign keys.
• Relationship is an association between objects or features; it controls behavior when objects or features are moved or deleted.
• AttributedRelationshipClass is a type of table that stores relationships.
• AttributedRelationship can represent many-to-many relationships as well as attributes on relationships.

• Raster workspace - Contains grids and images.
• TIN workspace - Contains triangulated irregular networks (TINs).
• CAD workspace - Contains computer-aided design (CAD) drawings.
• VPF workspace - Contains Vector Product Format (VPF) data.

// Create a property set with connection properties.
IPropertySet propertySet=new PropertySetClass();
propertySet.SetProperty("SERVER", "cuillin");
propertySet.SetProperty("INSTANCE", "esri_sde");
propertySet.SetProperty("USER", "scott");
propertySet.SetProperty("PASSWORD", "tiger");
propertySet.SetProperty("VERSION", "SDE.DEFAULT");
propertySet.SetProperty("AUTHENTICATION_MODE", "DBMS");

// Create an SDE workspace factory and open the workspace.
Type factoryType=Type.GetTypeFromProgID("esriDataSourcesGDB.SdeWorkspaceFactory");
IWorkspaceFactory workspaceFactory=(IWorkspaceFactory)Activator.CreateInstance
    (factoryType);
IWorkspace workspace=workspaceFactory.Open(propertySet, 0);

' Create a property set with connection properties.
Dim propertySet As IPropertySet=New PropertySetClass()

propertySet.SetProperty("SERVER", "cuillin")

    propertySet.SetProperty("INSTANCE", "esri_sde")

        propertySet.SetProperty("USER", "scott")

            propertySet.SetProperty("PASSWORD", "tiger")

                propertySet.SetProperty("VERSION", "SDE.DEFAULT")

                    propertySet.SetProperty("AUTHENTICATION_MODE", "DBMS")
                        
                        ' Create an SDE workspace factory and open the workspace.
                        Dim factoryType As Type=Type.GetTypeFromProgID("esriDataSourcesGDB.SdeWorkspaceFactory")
                        Dim workspaceFactory As IWorkspaceFactory=CType(Activator.CreateInstance(factoryType), IWorkspaceFactory)
                        Dim workspace As IWorkspace=WorkspaceFactory.Open(propertySet, 0)

// Create a shapefile workspace factory and open a folder of shapefiles as a workspace.
Type factoryType=Type.GetTypeFromProgID(
    "esriDataSourcesFile.ShapefileWorkspaceFactory");
IWorkspaceFactory workspaceFactory=(IWorkspaceFactory)Activator.CreateInstance
    (factoryType);
IWorkspace workspace=workspaceFactory.OpenFromFile(@"C:\Data\USA", 0);

// Use the IFeatureWorkspace interface to open a shapefile.
IFeatureWorkspace featureWorkspace=(IFeatureWorkspace)workspace;
IFeatureClass featureClass=featureWorkspace.OpenFeatureClass("States");

// Write the number of features to the console.
Console.WriteLine("Feature Count: {0}", featureClass.FeatureCount(null));

' Create a shapefile workspace factory and open a folder of shapefiles as a workspace.
Dim factoryType As Type=Type.GetTypeFromProgID("esriDataSourcesFile.ShapefileWorkspaceFactory")
Dim workspaceFactory As IWorkspaceFactory=CType(Activator.CreateInstance(factoryType), IWorkspaceFactory)
Dim workspace As IWorkspace=workspaceFactory.OpenFromFile("C:\Data\USA", 0)

' Use the IFeatureWorkspace interface to open a shapefile.
Dim featureWorkspace As IFeatureWorkspace=CType(workspace, IFeatureWorkspace)
Dim featureClass As IFeatureClass=featureWorkspace.OpenFeatureClass("States")

' Write the number of features to the console.
Console.WriteLine("Feature Count: {0}", featureClass.FeatureCount(Nothing))

• esriSQL_WildcardManyMatch ( % in SQL_92, * in Jet 4.0)
• esriSQL_WildcardSingleMatch ( _ in SQL_92, ? in Jet 4.0)
• esriSQL_DelimitedIdentifierPrefix ( " in SQL-92, [ in Jet 4.0)
• esriSQL_DelimitedIdentifierSuffix (" in SQL-92, ] in Jet 4.0)

// Create a set of connection properties.
IPropertySet propertySet=new PropertySetClass();
propertySet.SetProperty("SERVER", "bigsky");
propertySet.SetProperty("INSTANCE", "5151");
propertySet.SetProperty("USER", "gdb");
propertySet.SetProperty("PASSWORD", "gdb");
propertySet.SetProperty("VERSION", "sde.DEFAULT");

// Create a workspace factory and connect to the geodatabase.
Type factoryType=Type.GetTypeFromProgID("esriDataSourcesGDB.SdeWorkspaceFactory");
IWorkspaceFactory workspaceFactory=(IWorkspaceFactory)Activator.CreateInstance
    (factoryType);
IWorkspace workspace=workspaceFactory.Open(propertySet, 0);

// Open the feature class to be edited.
IFeatureWorkspace featureWorkspace=(IFeatureWorkspace)workspace;
IFeatureClass featureClass=featureWorkspace.OpenFeatureClass("States");

// Start a non-versioned edit session on the workspace.
IWorkspaceEdit workspaceEdit=(IWorkspaceEdit)featureWorkspace;
IMultiuserWorkspaceEdit muWorkspaceEdit=(IMultiuserWorkspaceEdit)featureWorkspace;
muWorkspaceEdit.StartMultiuserEditing
    (esriMultiuserEditSessionMode.esriMESMNonVersioned);

// Within an edit operation, retrieve and delete a single feature.
workspaceEdit.StartEditOperation();
IFeature feature=featureClass.GetFeature(1);
feature.Delete();
workspaceEdit.StopEditOperation();

// Stop editing, specifying that the edit should be saved. 
// Use a value of false here to discard edits.
workspaceEdit.StopEditing(true);

' Create a set of connection properties.
Dim propertySet As IPropertySet=New PropertySetClass()

propertySet.SetProperty("SERVER", "bigsky")

    propertySet.SetProperty("INSTANCE", "5151")

        propertySet.SetProperty("USER", "gdb")

            propertySet.SetProperty("PASSWORD", "gdb")

                propertySet.SetProperty("VERSION", "sde.DEFAULT")
                    
                    ' Create a workspace factory and connect to the geodatabase.
                    Dim factoryType As Type=Type.GetTypeFromProgID("esriDataSourcesGDB.SdeWorkspaceFactory")
                    Dim workspaceFactory As IWorkspaceFactory=CType(Activator.CreateInstance(factoryType), IWorkspaceFactory)
                    Dim workspace As IWorkspace=workspaceFactory.Open(propertySet, 0)
                    
                    ' Open the feature class to be edited.
                    Dim featureWorkspace As IFeatureWorkspace=CType(workspace, IFeatureWorkspace)
                    Dim featureClass As IFeatureClass=featureWorkspace.OpenFeatureClass("States")
                    
                    ' Start a non-versioned edit session on the workspace.
                    Dim workspaceEdit As IWorkspaceEdit=CType(featureWorkspace, IWorkspaceEdit)
                    Dim muWorkspaceEdit As IMultiuserWorkspaceEdit=CType(featureWorkspace, IMultiuserWorkspaceEdit)
                    muWorkspaceEdit.StartMultiuserEditing(esriMultiuserEditSessionMode.esriMESMNonVersioned)
                    
                    ' Within an edit operation, retrieve and delete a single feature.
                    workspaceEdit.StartEditOperation()
                    Dim feature As IFeature=featureClass.GetFeature(1)
                    feature.Delete()
                    workspaceEdit.StopEditOperation()
                    
                    ' Stop editing, specifying that the edit should be saved.
                    ' Use a value of false here to discard edits.
                    workspaceEdit.StopEditing(True)

• All object editing should be done within an edit session.
• Group changes into edit operations.
• Discard all references to row objects retrieved at the edit session boundary (on StartEditing). If references to row objects will be maintained across edit operations, discard all references and refetch objects in response to the undo, redo, and abort edit operation calls made by the application, as well as the reconcile call made within an edit session on versioned databases. In the context of ArcMap, these calls are made by the Editor, which broadcasts corresponding editor events via the IEditEvents and IEditEvents2 interfaces. Personal and ArcSDE geodatabase workspaces support the IWorkspaceEditEvents and IVersionEvents outbound interfaces and directly broadcast these events.
• Use nonrecycling search cursors to fetch objects that are to be updated (using any of the Search, GetRow, or GetRows methods supported by tables, feature classes, and selection sets). Recycling search cursors should only be used for drawing and read-only access to object states.
• Always fetch all properties of the objects to be edited. Query filters should always use "*" for the subfields property (attempts to instantiate nonrecycling cursors with less than all fields will still result in all row object fields being hydrated).
• After changing a row object, call the IRow.Store method to mark the object as changed and trigger propagation of the OnChanged method; propagate messages to related objects by calling the IRow.Store method on the object. Delete objects by calling the IRow.Delete method on the object, which triggers the OnDelete method. Stored and deleted objects within an edit operation are automatically and periodically flushed to the underlying database as needed to ensure read/query consistency and update efficiency. Use the set versions of these methods (for example, IRowEdit.DeleteSet) if updates or deletions are made to a set of objects to increase performance.
• Update and insert cursors are bulk data-loading and data-update APIs designed to perform direct updates and inserts outside an edit session on simple data during the data-loading phase of a project. Following the editing rules in this section will help ensure geodatabase integrity, particularly where custom objects and geodatabase behavior is concerned. Avoid using these APIs in editing applications. Using these APIs within an edit session, on complex objects (objects with nonsimple row or feature behavior), or on objects participating in composite relationships or relationships with notification negates any performance advantages they may have.

// This excerpt won't work for stand-alone feature classes.
IFeatureDataset featureDataset=featureClass.FeatureDataset;
IWorkspace workspace=featureDataset.Workspace;

' This excerpt won't work for stand-alone feature classes.
Dim featureDataset As IFeatureDataset=featureClass.FeatureDataset
Dim workspace As IWorkspace=featureDataset.Workspace

IDataset dataset=(IDataset)featureClass;
IWorkspace workspace=dataset.Workspace;

Dim dataset As IDataset=CType(featureClass, IDataset)
Dim workspace As IWorkspace=dataset.Workspace

// Create a File GDB workspace factory and open a File GDB as a workspace.
Type factoryType=Type.GetTypeFromProgID(
    "esriDataSourcesGDB.FileGDBWorkspaceFactory");
IWorkspaceFactory workspaceFactory=(IWorkspaceFactory)Activator.CreateInstance
    (factoryType);
IWorkspace workspace=workspaceFactory.OpenFromFile(@"C:\Data\USA.gdb", 0);

// Use the IFeatureWorkspace interface to open a feature class.
IFeatureWorkspace featureWorkspace=(IFeatureWorkspace)workspace;
IFeatureClass featureClass=featureWorkspace.OpenFeatureClass("States");

' Create a File GDB workspace factory and open a File GDB as a workspace.
Dim factoryType As Type=Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory")
Dim workspaceFactory As IWorkspaceFactory=CType(Activator.CreateInstance(factoryType), IWorkspaceFactory)
Dim workspace As IWorkspace=workspaceFactory.OpenFromFile("C:\Data\USA.gdb", 0)

' Use the IFeatureWorkspace interface to open a feature class.
Dim featureWorkspace As IFeatureWorkspace=CType(workspace, IFeatureWorkspace)
Dim featureClass As IFeatureClass=featureWorkspace.OpenFeatureClass("States")

// Find the position of any fields that will be edited.
int fieldIndex=table.FindField("Name");

// Create a new row.
IRow row=table.CreateRow();
row.set_Value(fieldIndex, "Exploits");
row.Store();

// Update the row.
row.set_Value(fieldIndex, "Badger");
row.Store();

// Delete the row.
row.Delete();

' Find the position of any fields that will be edited.
Dim fieldIndex As Integer=table.FindField("Name")

' Create a new row.
Dim row As IRow=table.CreateRow()
row.Value(fieldIndex)="Exploits"
row.Store()

' Update the row.
row.Value(fieldIndex)="Badger"
row.Store()

' Delete the row.
row.Delete()

// Get the default subtype code for the feature class.
ISubtypes subtypes=(ISubtypes)featureClass;
int defaultSubtype=subtypes.DefaultSubtypeCode;

// Create a new feature.
IFeature feature=featureClass.CreateFeature();

// Set the subtype and initialize the default values for the feature.
IRowSubtypes rowSubtypes=(IRowSubtypes)feature;
rowSubtypes.SubtypeCode=defaultSubtype;
rowSubtypes.InitDefaultValues();

' Get the default subtype code for the feature class.
Dim subtypes As ISubtypes=CType(featureClass, ISubtypes)
Dim defaultSubtype As Integer=subtypes.DefaultSubtypeCode

' Create a new feature.
Dim feature As IFeature=featureClass.CreateFeature()

' Set the subtype and initialize the default values for the feature.
Dim rowSubtypes As IRowSubtypes=CType(feature, IRowSubtypes)
rowSubtypes.SubtypeCode=defaultSubtype
rowSubtypes.InitDefaultValues()

// Create a recycling cursor to return every row.
ICursor cursor=table.Search(null, true);

// Iterate through the cursor's rows, writing the values to the console.
IRow row=null;
while ((row=cursor.NextRow()) != null)
{
    Console.WriteLine(row.get_Value(0));
}

' Create a recycling cursor to return every row.
Dim cursor As ICursor=table.Search(Nothing, True)

' Iterate through the cursor's rows, writing the values to the console.
Dim row As IRow=cursor.NextRow()
While Not row Is Nothing
    Console.WriteLine(row.Value(0))
    row=cursor.NextRow()
End While

// Create the query filter and apply a where clause.
IQueryFilter queryFilter=new QueryFilterClass();
queryFilter.WhereClause="STATE_NAME='California'";

// Select the features with a STATE_NAME of "California".
ISelectionSet selectionSet=featureClass.Select(queryFilter,
    esriSelectionType.esriSelectionTypeIDSet,
    esriSelectionOption.esriSelectionOptionNormal, null);

' Create the query filter and apply a where clause.
Dim queryFilter As IQueryFilter=New QueryFilterClass()
queryFilter.WhereClause="STATE_NAME='California'"

' Select the features with a STATE_NAME of "California".
Dim selectionSet As ISelectionSet=featureClass.Select(queryFilter, esriSelectionType.esriSelectionTypeIDSet, esriSelectionOption.esriSelectionOptionNormal, Nothing)

Console.WriteLine("Feature Count: {0}", featureClass.FeatureCount(null));

Console.WriteLine("Feature Count: {0}", featureClass.FeatureCount(Nothing))

• Selecting features that overlap a search area
• Finding features near another feature
• Defining a limited geographic area for feature display

// Create the filter.
ISpatialFilter spatialFilter=new SpatialFilterClass
{
    Geometry=geometry, GeometryField=featureClass.ShapeFieldName, SpatialRel =
        esriSpatialRelEnum.esriSpatialRelIntersects
};

// Select the features that satisfy the filter's constraints.
ISelectionSet selectionSet=featureClass.Select(spatialFilter,
    esriSelectionType.esriSelectionTypeIDSet,
    esriSelectionOption.esriSelectionOptionNormal, null);

' Create the filter.
Dim spatialFilter As ISpatialFilter=New SpatialFilterClass With _
                                      { _
                                      .Geometry=geometry, _
                                      .GeometryField=featureClass.ShapeFieldName, _
                                      .SpatialRel=esriSpatialRelEnum.esriSpatialRelIntersects _
                                      }

' Select the features that satisfy the filter's constraints.
Dim selectionSet As ISelectionSet=featureClass.Select(spatialFilter, esriSelectionType.esriSelectionTypeIDSet, esriSelectionOption.esriSelectionOptionNormal, Nothing)

// Create a selection set using a spatial filter.
ISelectionSet selectionSet=featureClass.Select(spatialFilter,
    esriSelectionType.esriSelectionTypeIDSet,
    esriSelectionOption.esriSelectionOptionNormal, null);

// Create a geometry enumerator and bind it to the selection set.
IEnumGeometry enumGeometry=new EnumFeatureGeometryClass();
IEnumGeometryBind enumGeometryBind=(IEnumGeometryBind)enumGeometry;
enumGeometryBind.BindGeometrySource(null, selectionSet);

// Use the GeometryEnvironment class to create a new geometry.
IGeometryFactory geomFactory=new GeometryEnvironmentClass();
IGeometry newGeometry=geomFactory.CreateGeometryFromEnumerator(enumGeometry);

' Create a selection set using a spatial filter.
Dim selectionSet As ISelectionSet=featureClass.Select(spatialFilter, esriSelectionType.esriSelectionTypeIDSet, esriSelectionOption.esriSelectionOptionNormal, Nothing)

' Create a geometry enumerator and bind it to the selection set.
Dim enumGeometry As IEnumGeometry=New EnumFeatureGeometryClass()
Dim enumGeometryBind As IEnumGeometryBind=CType(enumGeometry, IEnumGeometryBind)
enumGeometryBind.BindGeometrySource(Nothing, selectionSet)

' Use the GeometryEnvironment class to create a new geometry.
Dim geomFactory As IGeometryFactory=New GeometryEnvironmentClass()
Dim newGeometry As IGeometry=geomFactory.CreateGeometryFromEnumerator(enumGeometry)

ISelectionSet selectionSet=featureClass.Select(queryFilter,
    esriSelectionType.esriSelectionTypeIDSet,
    esriSelectionOption.esriSelectionOptionNormal, null);

Dim selectionSet As ISelectionSet=featureClass.Select(queryFilter, esriSelectionType.esriSelectionTypeIDSet, esriSelectionOption.esriSelectionOptionNormal, Nothing)

// Create a QueryDef and set its properties.
IQueryDef2 queryDef2=(IQueryDef2)featureWorkspace.CreateQueryDef();
queryDef2.Tables="Counties, States";
queryDef2.SubFields="COUNTIES.Shape, COUNTIES.NAME, STATES.STATE_ABBR";
queryDef2.WhereClause="COUNTIES.STATE_FIPS=STATES.STATE_FIPS";
queryDef2.PostfixClause="ORDER BY COUNTIES.NAME";

// Get a recycling cursor by evaluating the QueryDef.
ICursor cursor=queryDef2.Evaluate2(true);

' Create a QueryDef and set its properties.
Dim queryDef2 As IQueryDef2=CType(featureWorkspace.CreateQueryDef(), IQueryDef2)
queryDef2.Tables="Counties, States"
queryDef2.SubFields="COUNTIES.Shape, COUNTIES.NAME, STATES.STATE_ABBR"
queryDef2.WhereClause="COUNTIES.STATE_FIPS=STATES.STATE_FIPS"
queryDef2.PostfixClause="ORDER BY COUNTIES.NAME"

' Get a recycling cursor by evaluating the QueryDef.
Dim cursor As ICursor=queryDef2.Evaluate2(True)

// Open the feature query as a feature class in a feature dataset.
IFeatureDataset featureDataset=featureWorkspace.OpenFeatureQuery("CountiesStates",
    queryDef);
IFeatureClassContainer featureClassContainer=(IFeatureClassContainer)
    featureDataset;
IFeatureClass featureClass=null;
if (featureClassContainer.ClassCount == 1)
{
    featureClass=featureClassContainer.get_Class(0);
}

' Open the feature query as a feature class in a feature dataset.
Dim featureDataset As IFeatureDataset=featureWorkspace.OpenFeatureQuery("CountiesStates", queryDef)
Dim featureClassContainer As IFeatureClassContainer=CType(featureDataset, IFeatureClassContainer)
Dim featureClass As IFeatureClass=Nothing
If featureClassContainer.ClassCount=1 Then
    featureClass=featureClassContainer.Class(0)
End If

// Define a filter for which relationships will be deleted.
IQueryFilter queryFilter=new QueryFilterClass();
queryFilter.WhereClause="OWNER='Rusty Shackleford'";

// Create a set of all features satisfying the filter's where clause.
ISet featureSet=new SetClass();
using(ComReleaser comReleaser=new ComReleaser())
{
    // Create a cursor and iterate through the features.
    IFeatureCursor featureCursor=featureClass.Search(queryFilter, false);
    comReleaser.ManageLifetime(featureCursor);
    IFeature feature=null;
    while ((feature=featureCursor.NextFeature()) != null)
    {
        featureSet.Add(feature);
    }
}

// Delete the relationships for the set's features.
featureSet.Reset();
relationshipClass.DeleteRelationshipsForObjectSet(featureSet);

' Define a filter for which relationships will be deleted.
Dim queryFilter As IQueryFilter=New QueryFilterClass()
queryFilter.WhereClause="OWNER='Rusty Shackleford'"

' Create a set of all features satisfying the filter's where clause.
Dim featureSet As ISet=New SetClass()
Using comReleaser As ComReleaser=New ComReleaser()
' Create a cursor and iterate through the features.
Dim featureCursor As IFeatureCursor=featureClass.Search(queryFilter, False)
comReleaser.ManageLifetime(featureCursor)
Dim feature As IFeature=featureCursor.NextFeature()
While Not feature Is Nothing
    featureSet.Add(feature)
    feature=featureCursor.NextFeature()
End While
End Using

' Delete the relationships for the set's features.
featureSet.Reset()
relationshipClass.DeleteRelationshipsForObjectSet(featureSet)

• IObjectInspector - Allows you to replace the ArcMap default Object Inspector with a custom one. Custom object inspectors are easily implemented using a form that implements IObjectInspector.
• IObjectClassValidation - Provides custom validation of objects. This validation is in addition to geodatabase validation of domains, relationship rules, and connectivity rules. After successfully completing all native validation in the geodatabase, the ValidateRow method is called. Effectively, this is the last type of validation performed when validating an object.
• IRelatedObjectClassEvents - Implemented to receive messages about newly created objects in related ObjectClasses.
• IRelatedObjectClassEvents2 - Implemented to receive messages about changed and moved objects, either individually or in a set, in related ObjectClasses.
• IConfirmSendRelatedObjectEvents - Used to confirm the messaging of related objects. When an object that participates in a relationship is modified, moved, or rotated (alone or in a set), its related objects will be messaged if relationship notification is set in that direction. Typically, a related object is only involved in certain changes to an object. The properties of this interface allow ObjectClassExtension to prevent or confirm that messages should be sent.
• IObjectClassEvents - Implemented to monitor changes to the objects in ObjectClass. The events on this interface will be called by ObjectClass before notifying other related and external objects. The OnCreate event is called when an object is created. The OnChange event is called when an existing object is modified. The OnDelete event is called when objects in that class are deleted.
• IObjectClassInfo2 - Implemented to indicate whether a class required Store to be called when inserting or updating features, even when insert or update cursors are used. This ensures that ObjectClass and RelationshipClass events are broadcast.
• IFeatureClassCreation - Used to specify that new features of this class can be created with a single point. If features can be created from a point, the CanCreateFromPoint property returns true.
• IFeatureClassDraw - Used to specify custom drawing behavior in ArcMap.
• IFeatureClassEdit - Used to specify advanced editing configurations. Implementing this interface allows you to control whether the class can be edited in a spatial reference different from the class. This class extension also allows you to override the default behavior of relationships when a feature in the class is split. When a feature with related objects is split, the geodatabase will automatically maintain or delete the related objects depending on the type of relationship. 
  
  The following table of esriRelationshipSplitPolicy enumeration values summarizes how this behavior can be overridden:
  

• ITopologyClassEvents - Provides access to the OnValidate event and fires each time a dirty area is validated in the topology in which the class is participating. The event returns an IGeometry object corresponding to the area that was validated.

• AttributeRule
• RelationshipRule
• TopologyRule
• ConnectivityRule
  • JunctionConnectivityRule
  • EdgeConnectivityRule

// Use the IValidation interface to get the class' rules.
IValidation validation=(IValidation)objectClass;
IEnumRule enumRule=validation.Rules;
enumRule.Reset();

// Iterate through the rules.
IRule rule=null;
while ((rule=enumRule.Next()) != null)
{
    if (rule.Type == esriRuleType.esriRTAttribute)
    {
        IAttributeRule attributeRule=(IAttributeRule)rule;
        Console.WriteLine("Field: {0}", attributeRule.FieldName);
        Console.WriteLine("Subtype code: {0}", attributeRule.SubtypeCode);
        Console.WriteLine("Domain name: {0}", attributeRule.DomainName);
    }
}

' Use the IValidation interface to get the class' rules.
Dim validation As IValidation=CType(objectClass, IValidation)
Dim enumRule As IEnumRule=validation.Rules
enumRule.Reset()

' Iterate through the rules.
Dim rule As IRule=enumRule.Next()
While Not rule Is Nothing
    If rule.Type=esriRuleType.esriRTAttribute Then
        Dim attributeRule As IAttributeRule=CType(rule, IAttributeRule)
        Console.WriteLine("Field: {0}", attributeRule.FieldName)
        Console.WriteLine("Subtype code: {0}", attributeRule.SubtypeCode)
        Console.WriteLine("Domain name: {0}", attributeRule.DomainName)
    End If
    rule=enumRule.Next()
End While

// Use the ICodedValueDomain interface.
ICodedValueDomain codedValueDomain=(ICodedValueDomain)domain;

// Iterate through the code/value pairs.
for (int i=0; i < codedValueDomain.CodeCount; i++)
{
    String name=codedValueDomain.get_Name(i);
    object value=codedValueDomain.get_Value(i);
    Console.WriteLine("Name: {0}, Value: {1}", name, value);
}

' Use the ICodedValueDomain interface.
Dim codedValueDomain As ICodedValueDomain=CType(domain, ICodedValueDomain)

' Iterate through the code/value pairs.
Dim i As Integer=0
For i=0 To codedValueDomain.CodeCount - 1
    Dim Name As String=codedValueDomain.Name(i)
    Dim Value As Object=codedValueDomain.Value(i)
    Console.WriteLine("Name: {0}, Value: {1}", Name, Value)
Next

Geometric network

• The end user attempts to build a geometric network from data that has illegal geometry.
• Logic errors in the software implementation (as the software matures, this will become less and less likely).
• Applications or tools that do not correctly abort edit operations that the geometric network returns as an error.
• Third-party tools that attempt to manipulate the geometric network at a low level (for example, at the logical network level) and have logic errors in their software implementation.

• EdgeFeature
• EdgeFeatureCount
• EID

// Use the ISimpleJunctionFeature interface.
ISimpleJunctionFeature simpleJuncFeature=(ISimpleJunctionFeature)junctionFeature;
for (int i=0; i < simpleJuncFeature.EdgeFeatureCount; i++)
{
    // Display the edge feature's Object ID.
    IEdgeFeature edgeFeature=simpleJuncFeature.get_EdgeFeature(i);
    IRow row=(IRow)edgeFeature;
    Console.WriteLine("Edge feature [{0}] OID={1}", i, row.OID);
}

' Use the ISimpleJunctionFeature interface.
Dim simpleJuncFeature As ISimpleJunctionFeature=CType(junctionFeature, ISimpleJunctionFeature)
Dim i As Integer=0
For i=0 To simpleJuncFeature.EdgeFeatureCount - 1
    ' Display the edge feature's Object ID.
    Dim edgeFeature As IEdgeFeature=simpleJuncFeature.EdgeFeature(i)
    Dim row As IRow=CType(edgeFeature, IRow)
    Console.WriteLine("Edge feature [{0}] OID={1}", i, row.OID)
Next

For further information see:

Topology

IFeatureDataset featureDataset=featureWorkspace.OpenFeatureDataset("Landbase");
ITopologyContainer topologyContainer=(ITopologyContainer)featureDataset;
ITopology topology=topologyContainer.get_TopologyByName("Landbase_Topology");

Dim featureDataset As IFeatureDataset=featureWorkspace.OpenFeatureDataset("Landbase")
Dim topologyContainer As ITopologyContainer=CType(featureDataset, ITopologyContainer)
Dim topology As ITopology=topologyContainer.TopologyByName("Landbase_Topology")

// Use the IGeoDataset interface to get the topology's extent.
IGeoDataset geoDataset=(IGeoDataset)topology;
IPolygon searchArea=new PolygonClass();
ISegmentCollection segmentCollection=(ISegmentCollection)searchArea;
segmentCollection.SetRectangle(geoDataset.Extent);

// Check the entire topology for the dirty area.
IPolygon dirtyArea=topology.get_DirtyArea(searchArea);

' Use the IGeoDataset interface to get the topology's extent.
Dim geoDataset As IGeoDataset=CType(topology, IGeoDataset)
Dim searchArea As IPolygon=New PolygonClass()
Dim segmentCollection As ISegmentCollection=CType(searchArea, ISegmentCollection)
segmentCollection.SetRectangle(geoDataset.Extent)

' Check the entire topology for the dirty area.
Dim dirtyArea As IPolygon=topology.DirtyArea(searchArea)

// Validate the entire topology.
IGeoDataset geoDataset=(IGeoDataset)topology;
IEnvelope extent=geoDataset.Extent;
topology.ValidateTopology(extent);

' Validate the entire topology.
Dim geoDataset As IGeoDataset=CType(topology, IGeoDataset)
Dim extent As IEnvelope=geoDataset.Extent
topology.ValidateTopology(extent)

// Use the IGeoDataset interface to get the topology's extent.
IGeoDataset geoDataset=(IGeoDataset)topology;
IPolygon searchArea=new PolygonClass();
ISegmentCollection segmentCollection=(ISegmentCollection)searchArea;
segmentCollection.SetRectangle(geoDataset.Extent);

// Check the entire topology for the dirty area.
IPolygon dirtyArea=topology.get_DirtyArea(searchArea);

// Validate the topology based on the dirty area's envelope.
IEnvelope dirtyAreaEnvelope=dirtyArea.Envelope;
topology.ValidateTopology(dirtyAreaEnvelope);

' Use the IGeoDataset interface to get the topology's extent.
Dim geoDataset As IGeoDataset=CType(topology, IGeoDataset)
Dim searchArea As IPolygon=New PolygonClass()
Dim segmentCollection As ISegmentCollection=CType(searchArea, ISegmentCollection)
segmentCollection.SetRectangle(geoDataset.Extent)

' Check the entire topology for the dirty area.
Dim dirtyArea As IPolygon=topology.DirtyArea(searchArea)

' Validate the topology based on the dirty area's envelope.
Dim dirtyAreaEnvelope As IEnvelope=dirtyArea.Envelope
topology.ValidateTopology(dirtyAreaEnvelope)

• An identical rule is already present in the topology.
• A topology rule of the same rule type with the same origin and destination feature class is already present in the topology, but the rule being added is defined at the subtype level.
• The topology rule has been specified to use subtypes; however, subtypes are defined for the relevant feature class.

• esriTRTAreaNoOverlap
• esriTRTAreaNoOverlapArea
• esriTRTLineNoOverlap
• esriTRTLineNoIntersection
• esriTRTLineNoOverlapLine
• esriTRTLineNoIntersectOrInteriorTouch

• Navigate through it
• Modify the geometry of the topology elements
• Discover the relationship between features
• Modify the connectivity between features

• All elements - Use the ITopologyGraph.Edges or ITopologyGraph.Nodes property.
• The selected element - Use ITopologyGraph.EdgeSelection or ITopologyGraph.NodeSelection.
• Elements associated with a specific feature - Use the ITopologyGraph.GetParentEdges or ITopologyGraph.GetParentNodes method. You must have a pointer to the feature before using either of these methods.
• Elements using a geometry - Use the ITopologyGraph.HitTest or ITopologyGraph.SelectByGeometry method. This allows you to locate an element based on a user's click or other geometry.

• FromTopologyNode and ToTopologyNode associated with an edge - Use the ITopologyEdge.FromNode or ITopologyEdge.ToNode property.
• The set of edges incident to a TopologyNode - use the ITopologyNode.Edges property. The edges can be returned in clockwise or counterclockwise order.

• All parents associated with either an edge or a node - Use the ITopologyElement.Parents property.
• The left and right parent of an edge - Use the ITopologyEdge.LeftParents and ITopologyEdge.RightParents properties.

• Moving topology elements while respecting geometric relationships - Use the ITopologyGraph.TransformSelection method. The topology elements can be transformed using any supported transformation type, from the simple translation to the affine transformation.
• Moving topology elements without respecting geometric relationships - Use ITopologyGraph.SplitMoveNode. This modifies the elements of a topology in a way that may break the existing topology relationships (connectivity and adjacency). This operation is only successful if a valid topology relationship is recreated. For example, the operation will be aborted if a polygon becomes degenerated during SplitMoveNode.
• Changing the shape of a TopologyEdge geometry - The ITopologyGraph.ReshapeEdgeGeometry method can be used to modify the geometry of the edge based on another geometry. For example, this method is used by the Reshape Edge Task in the editor.
• Replacing the geometry of TopologyEdge - ITopologyGraph.SetEdgeGeometry replaces the current geometry of TopologyEdge with the input geometry. For example, this method is used by the Modify Edge task in the editor. This method does not allow the modification of TopologyEdge endpoints.

Data elements

• /V=/FD=USA/FC=Capitals
• /V=SDE.DEFAULT/FD=Landbase/FC=Parcels

// Get a name object for the first feature class in the workspace.
IEnumDatasetName enumDatasetName=workspace.get_DatasetNames
    (esriDatasetType.esriDTFeatureClass);
enumDatasetName.Reset();
IDatasetName datasetName=enumDatasetName.Next();

// Create a DEBrowseOptions object to define how the data element is populated.
IDEBrowseOptions deBrowseOptions=new DEBrowseOptionsClass
{
    RetrieveFullProperties=false, ExpandType=esriDEExpandType.esriDEExpandNone
};

// Generate a data element for the feature class.
IWorkspaceDataElements workspaceDataElements=(IWorkspaceDataElements)workspace;
IDataElement dataElement=workspaceDataElements.GetDatasetDataElement(datasetName,
    deBrowseOptions);

' Get a name object for the first feature class in the workspace.
Dim enumDatasetName As IEnumDatasetName=workspace.DatasetNames(esriDatasetType.esriDTFeatureClass)
enumDatasetName.Reset()
Dim datasetName As IDatasetName=enumDatasetName.Next()

' Create a DEBrowseOptions object to define how the data element is populated.
Dim deBrowseOptions As IDEBrowseOptions=New DEBrowseOptionsClass With _
                                          { _
                                          .RetrieveFullProperties=False, _
                                          .ExpandType=esriDEExpandType.esriDEExpandNone _
                                          }

' Generate a data element for the feature class.
Dim workspaceDataElements As IWorkspaceDataElements=CType(workspace, IWorkspaceDataElements)
Dim dataElement As IDataElement=workspaceDataElements.GetDatasetDataElement(datasetName, deBrowseOptions)

// Open a feature class.
IFeatureClass featureClass=featureWorkspace.OpenFeatureClass("Parcels");

// Create a DEBrowseOptions object to define how the data element is populated.
IDEBrowseOptions deBrowseOptions=new DEBrowseOptionsClass
{
    RetrieveFullProperties=true, ExpandType=esriDEExpandType.esriDEExpandNone
};

// Generate a data element for the feature class.
IWorkspaceDataElements workspaceDataElements=(IWorkspaceDataElements)workspace;
IDataElement dataElement=workspaceDataElements.GetDatasetDataElement(featureClass,
    deBrowseOptions);

' Open a feature class.
Dim featureClass As IFeatureClass=featureWorkspace.OpenFeatureClass("Parcels")

' Create a DEBrowseOptions object to define how the data element is populated.
Dim deBrowseOptions As IDEBrowseOptions=New DEBrowseOptionsClass With _
                                          { _
                                          .RetrieveFullProperties=True, _
                                          .ExpandType=esriDEExpandType.esriDEExpandNone _
                                          }

' Generate a data element for the feature class.
Dim workspaceDataElements As IWorkspaceDataElements=CType(workspace, IWorkspaceDataElements)
Dim dataElement As IDataElement=workspaceDataElements.GetDatasetDataElement(featureClass, deBrowseOptions)

// Open a feature class from the source workspace.
IFeatureWorkspace featureWorkspace=(IFeatureWorkspace)sourceWorkspace;
IFeatureClass featureClass=featureWorkspace.OpenFeatureClass("Parcels");

// Create a data element for the feature class.
IWorkspaceDataElements workspaceDataElements=(IWorkspaceDataElements)
    sourceWorkspace;
IDEBrowseOptions deBrowseOptions=new DEBrowseOptionsClass
{
    ExpandType=esriDEExpandType.esriDEExpandNone, RetrieveFullProperties=true
};
IDataElement dataElement=workspaceDataElements.GetDatasetDataElement(featureClass,
    deBrowseOptions);

// Create an array for the data element.
IArray dataElementArray=new ArrayClass();
dataElementArray.Add(dataElement);

// Generate a name mapping enumerator for the target workspace.
IGdbSchemaCreator gdbSchemaCreator=new GdbSchemaCreatorClass();
IEnumNameMapping enumNameMapping=null;
Boolean conflictsFound=false;
gdbSchemaCreator.GenerateNameMapping(targetWorkspace, dataElementArray, null, out
    enumNameMapping, out conflictsFound);
enumNameMapping.Reset();

// Create the schema in the target workspace.
gdbSchemaCreator.CreateSchema(targetWorkspace, enumNameMapping);

' Open a feature class from the source workspace.
Dim featureWorkspace As IFeatureWorkspace=CType(sourceWorkspace, IFeatureWorkspace)
Dim featureClass As IFeatureClass=featureWorkspace.OpenFeatureClass("Parcels")

' Create a data element for the feature class.
Dim workspaceDataElements As IWorkspaceDataElements=CType(sourceWorkspace, IWorkspaceDataElements)
Dim deBrowseOptions As IDEBrowseOptions=New DEBrowseOptionsClass With _
                                          { _
                                          .ExpandType=esriDEExpandType.esriDEExpandNone, _
                                          .RetrieveFullProperties=True _
                                          }
Dim dataElement As IDataElement=workspaceDataElements.GetDatasetDataElement(featureClass, deBrowseOptions)

' Create an array for the data element.
Dim dataElementArray As IArray=New ArrayClass()
dataElementArray.Add(dataElement)

' Generate a name mapping enumerator for the target workspace.
Dim gdbSchemaCreator As IGdbSchemaCreator=New GdbSchemaCreatorClass()
Dim enumNameMapping As IEnumNameMapping=Nothing
Dim conflictsFound As Boolean=False
gdbSchemaCreator.GenerateNameMapping(targetWorkspace, dataElementArray, Nothing, enumNameMapping, conflictsFound)
enumNameMapping.Reset()

' Create the schema in the target workspace.
gdbSchemaCreator.CreateSchema(targetWorkspace, enumNameMapping)

• DataElement (abstract)
• DEDataset (abstract)
• DEGeoDataset (abstract)
• DEFeatureDataset
• DETable
• DEFeatureClass
• DERasterCatalog
• DETopology
• DEGeometricNetwork
• DERelationshipClass
• DERasterDataset
• DERasterBand
• DEToolbox

TIN

// Create a TIN workspace factory.
Type factoryType=Type.GetTypeFromProgID("esriDataSourcesFile.TinWorkspaceFactory");
IWorkspaceFactory workspaceFactory=(IWorkspaceFactory)Activator.CreateInstance
    (factoryType);

// Open a directory containing TINs as a workspace.
IWorkspace workspace=workspaceFactory.OpenFromFile(@"C:\Data\Tin", 0);
ITinWorkspace tinWorkspace=(ITinWorkspace)workspace;

// Open a TIN from the workspace.
ITin tin=tinWorkspace.OpenTin("Shelbyville");

' Create a TIN workspace factory.
Dim factoryType As Type=Type.GetTypeFromProgID("esriDataSourcesFile.TinWorkspaceFactory")
Dim workspaceFactory As IWorkspaceFactory=CType(Activator.CreateInstance(factoryType), IWorkspaceFactory)

' Open a directory containing TINs as a workspace.
Dim workspace As IWorkspace=workspaceFactory.OpenFromFile("C:\Data\Tin", 0)
Dim tinWorkspace As ITinWorkspace=CType(workspace, ITinWorkspace)

' Open a TIN from the workspace.
Dim tin As ITin=tinWorkspace.OpenTin("Shelbyville")

• TinDataElementFilter
• TinValueFilter
• TinNodeSourceFilter
• TinEdgeTypeFilter
• TinTriangleFilter

Data transfer

• Check for potential problems in your field names with IFieldChecker.
• Inspect data that is rejected during the conversion process with IEnumInvalidObject.
• Keep the end user informed with IFeatureProgress.

public void ConvertFeatureClass(IFeatureClass sourceClass, IWorkspace
    targetWorkspace)
{
    // Create name objects for the source dataset and its workspace.
    IDataset sourceDataset=(IDataset)sourceClass;
    IFeatureClassName sourceFeatureClassName=(IFeatureClassName)
        sourceDataset.FullName;
    IWorkspace sourceWorkspace=sourceDataset.Workspace;

    // Create a name object for the target workspace.
    IDataset targetWorkspaceDataset=(IDataset)targetWorkspace;
    IWorkspaceName targetWorkspaceName=(IWorkspaceName)
        targetWorkspaceDataset.FullName;

    // Create a name object for the target dataset.
    IFeatureClassName targetFeatureClassName=new FeatureClassNameClass
    {
        Name="NewFeatClass1", WorkspaceName=targetWorkspaceName
    };

    // Use the field checker to perform field validation.
    IFieldChecker fieldChecker=new FieldCheckerClass
    {
        InputWorkspace=sourceWorkspace, ValidateWorkspace=targetWorkspace
    };
    IFields targetFields=null;
    IEnumFieldError enumFieldError=null;
    fieldChecker.Validate(sourceClass.Fields, out enumFieldError, out targetFields);

    // Convert the data.
    IFeatureDataConverter featureDataConverter=new FeatureDataConverterClass();
    featureDataConverter.ConvertFeatureClass(sourceFeatureClassName, null, null,
        targetFeatureClassName, null, targetFields, null, 1000, 0);
}

Public Shared Sub ConvertFeatureClass(ByVal sourceClass As IFeatureClass, ByVal targetWorkspace As IWorkspace)
' Create name objects for the source dataset and its workspace.
Dim sourceDataset As IDataset=CType(sourceClass, IDataset)
Dim sourceFeatureClassName As IFeatureClassName=CType(sourceDataset.FullName, IFeatureClassName)
Dim sourceWorkspace As IWorkspace=sourceDataset.Workspace

' Create a name object for the target workspace.
Dim targetWorkspaceDataset As IDataset=CType(targetWorkspace, IDataset)
Dim targetWorkspaceName As IWorkspaceName=CType(targetWorkspaceDataset.FullName, IWorkspaceName)

' Create a name object for the target dataset.
Dim targetFeatureClassName As IFeatureClassName=New FeatureClassNameClass With _
                                                  { _
                                                  .Name="NewFeatClass1", _
                                                  .WorkspaceName=targetWorkspaceName _
                                                  }

' Use the field checker to perform field validation.
Dim fieldChecker As IFieldChecker=New FieldCheckerClass With _
                                    { _
                                    .InputWorkspace=sourceWorkspace, _
                                    .ValidateWorkspace=targetWorkspace _
                                    }
Dim targetFields As IFields=Nothing
Dim enumFieldError As IEnumFieldError=Nothing
fieldChecker.Validate(sourceClass.Fields, enumFieldError, targetFields)

' Convert the data.
Dim featureDataConverter As IFeatureDataConverter=New FeatureDataConverterClass()
featureDataConverter.ConvertFeatureClass(sourceFeatureClassName, Nothing, Nothing, targetFeatureClassName, Nothing, targetFields, Nothing, 1000, 0)
End Sub

For further information see:

Versioning

IVersion version=(IVersion)workspace;
IVersionInfo versionInfo=version.VersionInfo;
if (versionInfo.IsOwner())
{
    version.Access=esriVersionAccess.esriVersionAccessPublic;
}

Dim Version As IVersion=CType(workspace, IVersion)
Dim versionInfo As IVersionInfo=Version.VersionInfo
If versionInfo.IsOwner() Then
    Version.Access=esriVersionAccess.esriVersionAccessPublic
End If

// Use IVersionEdit4 to reconcile.
IVersionEdit4 versionEdit4=(IVersionEdit4)workspace;
Boolean conflictsFound=versionEdit4.Reconcile4("SDE.DEFAULT", true, false, false,
    true);

// Post.
if (versionEdit4.CanPost())
{
    versionEdit4.Post("SDE.DEFAULT");
}

' Use IVersionEdit4 to reconcile.
Dim versionEdit4 As IVersionEdit4=CType(workspace, IVersionEdit4)
Dim conflictsFound As Boolean=versionEdit4.Reconcile4("SDE.DEFAULT", True, False, False, True)

' Post.
If versionEdit4.CanPost() Then
    versionEdit4.Post("SDE.DEFAULT")
End If

Archiving

For a class to participate in archiving, it must be archiving enabled. This can be achieved through the IArchivableObject interface. Before enabling archiving on a class, it is good programming practice to check if the archive is already archiving through the IsArchiving property. The EnableArchiving method will enable archiving on a versioned object.

// Use IHistoricalWorkspace to get an enumerator of historical markers.
IHistoricalWorkspace historicalWorkspace=(IHistoricalWorkspace)workspace;
IEnumHistoricalMarker enumHistoricalMarker=historicalWorkspace.HistoricalMarkers;
enumHistoricalMarker.Reset();

// Iterate through the historical markers, displaying the properties of each.
IHistoricalMarker historicalMarker=null;
while ((historicalMarker=enumHistoricalMarker.Next()) != null)
{
    Console.WriteLine("Name: '{0}', Time: '{1}'", historicalMarker.Name,
        historicalMarker.TimeStamp);
}

' Use IHistoricalWorkspace to get an enumerator of historical markers.
Dim historicalWorkspace As IHistoricalWorkspace=CType(workspace, IHistoricalWorkspace)
Dim enumHistoricalMarker As IEnumHistoricalMarker=historicalWorkspace.HistoricalMarkers
enumHistoricalMarker.Reset()

' Iterate through the historical markers, displaying the properties of each.
Dim historicalMarker As IHistoricalMarker=enumHistoricalMarker.Next()
While Not historicalMarker Is Nothing
    Console.WriteLine("Name: '{0}', Time: '{1}'", historicalMarker.Name, historicalMarker.TimeStamp)
    historicalMarker=enumHistoricalMarker.Next()
End While

Name objects

IWorkspaceName workspaceName=new WorkspaceNameClass
{
    WorkspaceFactoryProgID="esriDataSourcesGDB.FileGDBWorkspaceFactory", PathName 
       =@"C:\Data\Usa.gdb"
};

Dim workspaceName As IWorkspaceName=New WorkspaceNameClass With _
                                      { _
                                      .WorkspaceFactoryProgID="esriDataSourcesGDB.FileGDBWorkspaceFactory", _
                                      .PathName="C:\Data\Usa.gdb" _
                                      }

IDataset dataset=(IDataset)workspace;
IWorkspaceName workspaceName=(IWorkspaceName)dataset.FullName;

Dim dataset As IDataset=CType(workspace, IDataset)
Dim workspaceName As IWorkspaceName=CType(dataset.FullName, IWorkspaceName)

IDataset dataset=(IDataset)featureClass;
IFeatureClassName featureClassName=(IFeatureClassName)dataset.FullName;

Dim dataset As IDataset=CType(featureClass, IDataset)
Dim featureClassName As IFeatureClassName=CType(dataset.FullName, IFeatureClassName)

// Create a workspace name object.
IWorkspaceName workspaceName=new WorkspaceNameClass
{
    WorkspaceFactoryProgID="esriDataSourcesGDB.FileGDBWorkspaceFactory", PathName 
       =@"C:\Data\Usa.gdb"
};

// Create a feature class name object.
IDatasetName datasetName=new FeatureClassNameClass();
datasetName.WorkspaceName=workspaceName;
datasetName.Name="Land_Use";

' Create a workspace name object.
Dim workspaceName As IWorkspaceName=New WorkspaceNameClass With _
                                      { _
                                      .WorkspaceFactoryProgID="esriDataSourcesGDB.FileGDBWorkspaceFactory", _
                                      .PathName="C:\Data\Usa.gdb" _
                                      }

' Create a feature class name object.
Dim datasetName As IDatasetName=New FeatureClassNameClass()
datasetName.WorkspaceName=workspaceName
datasetName.Name="Land_Use"

// Use a bitwise OR to create a combination of privileges.
int privileges=(int)esriSQLPrivilege.esriSelectPrivilege | (int)
    esriSQLPrivilege.esriUpdatePrivilege;

// Use ISQLPrivilege to grant the privileges.
ISQLPrivilege sqlPrivilege=(ISQLPrivilege)datasetName;
sqlPrivilege.Grant("Scott", privileges, true);

' Use a bitwise OR to create a combination of privileges.
Dim privileges As Integer=CInt(esriSQLPrivilege.esriSelectPrivilege) Or CInt(esriSQLPrivilege.esriUpdatePrivilege)

' Use ISQLPrivilege to grant the privileges.
Dim sqlPrivilege As ISQLPrivilege=CType(datasetName, ISQLPrivilege)
sqlPrivilege.Grant("Scott", privileges, True)

• RelQueryTableName
• TableQueryName
• FeatureQueryName
• FeatureDatasetName
• RelationshipClassName
• MemoryRelationshipClassName
• TableName
• ObjectClassName
• FeatureClassName
• GeometricNetworkName
• TopologyName
• XYEventSourceName
• RasterCatalogName
• RasterDatasetName
• RasterBandName

Relationship query table

// Open the origin and destination classes.
IFeatureWorkspace featureWorkspace=(IFeatureWorkspace)workspace;
IFeatureClass originClass=featureWorkspace.OpenFeatureClass("us_states");
IObjectClass destinationClass=(IObjectClass)featureWorkspace.OpenTable(
    "us_counties");

// Create a memory relationship class factory and open a relationship class with it.
Type relClassFactoryType=Type.GetTypeFromProgID(
    "esriGeodatabase.MemoryRelationshipClassFactory");
IMemoryRelationshipClassFactory memRelClassFactory=
    (IMemoryRelationshipClassFactory)Activator.CreateInstance(relClassFactoryType);
IRelationshipClass memRelClass=memRelClassFactory.Open("StatesCounties",
    originClass, "STATE_ID", destinationClass, "STATE_ID", "Contains", "Is in",
    esriRelCardinality.esriRelCardinalityOneToMany);

// Find the counties related to the state with an ObjectID of 1.
IFeature originFeature=originClass.GetFeature(1);
ISet relatedSet=memRelClass.GetObjectsRelatedToObject(originFeature);
relatedSet.Reset();

// Iterate through the set while finding the names of the counties.
int nameIndex=destinationClass.FindField("NAME");
object setObject=null;
while ((setObject=relatedSet.Next()) != null)
{
    IRow row=(IRow)setObject;
    Console.WriteLine("OID: {0}, NAME: {1}", row.OID, row.get_Value(nameIndex));
}

' Open the origin and destination classes.
Dim featureWorkspace As IFeatureWorkspace=CType(workspace, IFeatureWorkspace)
Dim originClass As IFeatureClass=featureWorkspace.OpenFeatureClass("us_states")
Dim destinationClass As IObjectClass=CType(featureWorkspace.OpenTable("us_counties"), IObjectClass)

' Create a memory relationship class factory and open a relationship class with it.
Dim relClassFactoryType As Type=Type.GetTypeFromProgID("esriGeodatabase.MemoryRelationshipClassFactory")
Dim memRelClassFactory As IMemoryRelationshipClassFactory=CType(Activator.CreateInstance(relClassFactoryType), IMemoryRelationshipClassFactory)
Dim memRelClass As IRelationshipClass=memRelClassFactory.Open("StatesCounties", originClass, "STATE_ID", _
                                        destinationClass, "STATE_ID", "Contains", "Is in", esriRelCardinality.esriRelCardinalityOneToMany)

' Find the counties related to the state with an ObjectID of 1.
Dim originFeature As IFeature=originClass.GetFeature(1)
Dim relatedSet As ISet=memRelClass.GetObjectsRelatedToObject(originFeature)
relatedSet.Reset()

' Iterate through the set while finding the names of the counties.
Dim nameIndex As Integer=destinationClass.FindField("NAME")
Dim setObject As Object=relatedSet.Next()
While Not setObject Is Nothing
    Dim row As IRow=CType(setObject, IRow)
    Console.WriteLine("OID: {0}, NAME: {1}", row.OID, row.Value(nameIndex))
    setObject=relatedSet.Next()
End While

// Create a RelQueryTableFactory.
Type rqtFactoryType=Type.GetTypeFromProgID("esriGeodatabase.RelQueryTableFactory");
IRelQueryTableFactory rqtFactory=(IRelQueryTableFactory)Activator.CreateInstance
    (rqtFactoryType);

// Open a RelQueryTable using a memory relationship class.
IRelQueryTable relQueryTable=rqtFactory.Open(memRelClass, false, null, null, null,
    true, true);

// Display the number of rows in the RelQueryTable.
ITable table=(ITable)relQueryTable;
Console.WriteLine("RelQueryTable row count: {0}", table.RowCount(null));

' Create a RelQueryTableFactory.
Dim rqtFactoryType As Type=Type.GetTypeFromProgID("esriGeodatabase.RelQueryTableFactory")
Dim rqtFactory As IRelQueryTableFactory=CType(Activator.CreateInstance(rqtFactoryType), IRelQueryTableFactory)

' Open a RelQueryTable using a memory relationship class.
Dim relQueryTable As IRelQueryTable=rqtFactory.Open(memRelClass, False, Nothing, Nothing, Nothing, True, True)

' Display the number of rows in the RelQueryTable.
Dim table As ITable=CType(relQueryTable, ITable)
Console.WriteLine("RelQueryTable row count: {0}", table.RowCount(Nothing))

 

// Create a new memory relationship class name object.
IMemoryRelationshipClassName memRelClassName=new MemoryRelationshipClassNameClass
{
    Name="StatesCounties", OriginName=originName, DestinationName =
        destinationName, OriginPrimaryKey="STATE_ID", OriginForeignKey=
        "STATE_ID", ForwardPathLabel="Contains", BackwardPathLabel="Is in",
        Cardinality=esriRelCardinality.esriRelCardinalityOneToMany
};

// Open the memory relationship class using IName.Open.
IName name=(IName)memRelClassName;
IRelationshipClass memRelClass=(IRelationshipClass)name.Open();

' Create a new memory relationship class name object.
Dim memRelClassName As IMemoryRelationshipClassName=New MemoryRelationshipClassNameClass With _
                                                      { _
                                                      .Name="StatesCounties", _
                                                      .OriginName=originName, _
                                                      .DestinationName=destinationName, _
                                                      .OriginPrimaryKey="PROPERTY_I", _
                                                      .OriginForeignKey="PROPERTY_ID", _
                                                      .ForwardPathLabel="Contains", _
                                                      .BackwardPathLabel="Is in", _
                                                      .Cardinality=esriRelCardinality.esriRelCardinalityOneToMany _
                                                      }

' Open the memory relationship class using IName.Open.
Dim Name As IName=CType(memRelClassName, IName)
Dim memRelClass As IRelationshipClass=CType(Name.Open(), IRelationshipClass)

// Create a new RelQueryTable name object.
IRelQueryTableName relQueryTableName=new RelQueryTableNameClass
{
    RelationshipClassName=(IName)memRelClassName, ForwardDirection=false,
        SrcQueryFilter=null, SrcSelectionSet=null, TargetColumns=null,
        DoNotPushJoinToDB=true, LeftOuterJoin=true
};

// Open the RelQueryTable using IName.Open.
IName name=(IName)relQueryTableName;
IRelQueryTable relQueryTable=(IRelQueryTable)name.Open();

' Create a new RelQueryTable name object.
Dim relQueryTableName As IRelQueryTableName=New RelQueryTableNameClass With _
                                              { _
                                              .RelationshipClassName=CType(memRelClassName, IName), _
                                              .ForwardDirection=False, _
                                              .SrcQueryFilter=Nothing, _
                                              .SrcSelectionSet=Nothing, _
                                              .TargetColumns=Nothing, _
                                              .DoNotPushJoinToDB=True, _
                                              .LeftOuterJoin=True _
                                              }

' Open the RelQueryTable using IName.Open.
Dim Name As IName=CType(relQueryTableName, IName)
Dim relQueryTable As IRelQueryTable=CType(Name.Open(), IRelQueryTable)

Raster

// Create a raster workspace factory and open a folder of rasters as a workspace.
Type factoryType=Type.GetTypeFromProgID(
    "esriDataSourcesRaster.RasterWorkspaceFactory");
IWorkspaceFactory workspaceFactory=(IWorkspaceFactory)Activator.CreateInstance
    (factoryType);
IWorkspace workspace=workspaceFactory.OpenFromFile(@"C:\Data\Rasters", 0);
IRasterWorkspace2 rasterWorkspace2=(IRasterWorkspace2)workspace;

' Create a raster workspace factory and open a folder of rasters as a workspace.
Dim factoryType As Type=Type.GetTypeFromProgID("esriDataSourcesRaster.RasterWorkspaceFactory")
Dim workspaceFactory As IWorkspaceFactory=CType(Activator.CreateInstance(factoryType), IWorkspaceFactory)
Dim workspace As IWorkspace=workspaceFactory.OpenFromFile("C:\Data\Rasters", 0)
Dim rasterWorkspace2 As IRasterWorkspace2=CType(workspace, IRasterWorkspace2)

// Create a file GDB workspace factory and open a geodatabase as a workspace.
Type factoryType=Type.GetTypeFromProgID(
    "esriDataSourcesGDB.FileGDBWorkspaceFactory");
IWorkspaceFactory workspaceFactory=(IWorkspaceFactory)Activator.CreateInstance
    (factoryType);
IWorkspace workspace=workspaceFactory.OpenFromFile(@"C:\Data\Public.gdb", 0);
IRasterWorkspaceEx rasterWorkspaceEx=(IRasterWorkspaceEx)workspace;

' Create a file GDB workspace factory and open a geodatabase as a workspace.
Dim factoryType As Type=Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory")
Dim workspaceFactory As IWorkspaceFactory=CType(Activator.CreateInstance(factoryType), IWorkspaceFactory)
Dim workspace As IWorkspace=workspaceFactory.OpenFromFile("C:\Data\Public.gdb", 0)
Dim rasterWorkspaceEx As IRasterWorkspaceEx=CType(workspace, IRasterWorkspaceEx)

// Open a raster dataset from a file-based raster workspace.
IRasterDataset rasterDataset=rasterWorkspace2.OpenRasterDataset("airphoto.img");

' Open a raster dataset from a file-based raster workspace.
Dim rasterDataset As IRasterDataset=rasterWorkspace2.OpenRasterDataset("airphoto.img")

// Create a new raster dataset.
IRasterDataset rasterDataset=rasterWorkspace2.CreateRasterDataset("MyImage.img", 
    "IMAGINE Image", originPoint, 200, 100, 1, 1, 1, rstPixelType.PT_UCHAR,
    spatialReference, true);

' Create a new raster dataset.
Dim rasterDataset As IRasterDataset=rasterWorkspace2.CreateRasterDataset("MyImage.img", "IMAGINE Image", originPoint, 200, 100, 1, 1, 1, rstPixelType.PT_UCHAR, spatialReference, True)

// Open a raster dataset from a geodatabase.
IRasterDataset rasterDataset=rasterWorkspaceEx.OpenRasterDataset("airphoto");

// Open a raster catalog from a geodatabase.
IRasterCatalog rasterCatalog=rasterWorkspaceEx.OpenRasterCatalog("airphoto_cat");

' Open a raster dataset from a geodatabase.
Dim rasterDataset As IRasterDataset=rasterWorkspaceEx.OpenRasterDataset("airphoto")

' Open a raster catalog from a geodatabase.
Dim rasterCatalog As IRasterCatalog=rasterWorkspaceEx.OpenRasterCatalog("airphoto_cat")

// Create a RasterStorageDef object.
IRasterStorageDef rasterStorageDef=new RasterStorageDefClass();
rasterStorageDef.CompressionType =
    esriRasterCompressionType.esriRasterCompressionJPEG2000;

// Create a RasterDef object.
IRasterDef rasterDef=new RasterDefClass();
rasterDef.SpatialReference=spatialReference;

// Create the raster dataset.
IRasterDataset rasterDataset=rasterWorkspaceEx.CreateRasterDataset("Redlands", 1,
    rstPixelType.PT_UCHAR, rasterStorageDef, null, rasterDef, null);

' Create a RasterStorageDef object.
Dim rasterStorageDef As IRasterStorageDef=New RasterStorageDefClass()
rasterStorageDef.CompressionType=esriRasterCompressionType.esriRasterCompressionJPEG2000

' Create a RasterDef object.
Dim rasterDef As IRasterDef=New RasterDefClass()
rasterDef.SpatialReference=spatialReference

' Create the raster dataset.
Dim rasterDataset As IRasterDataset=rasterWorkspaceEx.CreateRasterDataset("Redlands", 1, rstPixelType.PT_UCHAR, rasterStorageDef, Nothing, rasterDef, Nothing)

// Alter the raster dataset's colormap and mosaic pixels from the raster to the dataset.
IRasterDatasetEdit rasterDatasetEdit=(IRasterDatasetEdit)rasterDataset;
rasterDatasetEdit.AlterColormap(rasterColormap);
rasterDatasetEdit.Mosaic(raster, 0.5);

' Alter the raster dataset's colormap and mosaic pixels from the raster to the dataset.
Dim rasterDatasetEdit As IRasterDatasetEdit=CType(rasterDataset, IRasterDatasetEdit)
rasterDatasetEdit.AlterColormap(rasterColormap)
rasterDatasetEdit.Mosaic(raster, 0.5)

ISaveAs saveAs=(ISaveAs)rasterDataset;
saveAs.SaveAs("Redlands.img", rasterWorkspace, "IMAGINE Image");
saveAs.SaveAs("Redlands", workspace, "SDR");

Dim saveAs As ISaveAs=CType(rasterDataset, ISaveAs)
saveAs.SaveAs("Redlands.img", rasterWorkspace, "IMAGINE Image")
saveAs.SaveAs("Redlands", workspace, "SDR")

IRasterBandCollection rasterBandCollection=(IRasterBandCollection)rasterDataset;
IRasterBand rasterBand=rasterBandCollection.Item(0);

Dim rasterBandCollection As IRasterBandCollection=CType(rasterDataset, IRasterBandCollection)
Dim rasterBands As IRasterBand=rasterBandCollection.Item(0)

IRasterBandCollection bandCollection=(IRasterBandCollection)raster;
IRasterBand rasterBand=bandCollection.Item(0);
IRasterDataset rasterDataset=rasterBand.RasterDataset;

Dim bandCollection As IRasterBandCollection=CType(raster, IRasterBandCollection)
Dim rasterBand As IRasterBand=bandCollection.Item(0)
Dim rasterDataset As IRasterDataset=rasterBand.RasterDataset

Boolean hasColormap=false;
rasterBand.HasColormap(out hasColormap);
if (hasColormap)
{
    IRasterColormap rasterColormap=rasterBand.Colormap;
    // Use the colormap...
}

Dim hasColormap As Boolean=False
rasterBand.HasColormap(hasColormap)
If hasColormap Then
    Dim rasterColormap As IRasterColormap=rasterBand.Colormap
    ' Use the colormap...
End If

// Set the raster's resampling method and apply a spatial reference.
raster.ResampleMethod=rstResamplingTypes.RSP_BilinearInterpolation;
IRasterProps rasterProps=(IRasterProps)raster;
rasterProps.SpatialReference=spatialReference;

// Save the raster as a GRID.
ISaveAs saveAs=(ISaveAs)raster;
saveAs.SaveAs("MyRaster", rasterWorkspace, "GRID");

' Set the raster's resampling method and apply a spatial reference.
raster.ResampleMethod=rstResamplingTypes.RSP_BilinearInterpolation
Dim rasterProps As IRasterProps=CType(raster, IRasterProps)
rasterProps.SpatialReference=spatialReference

' Save the raster as a grid.
Dim saveAs As ISaveAs=CType(raster, ISaveAs)
saveAs.SaveAs("MyRaster", rasterWorkspace, "GRID")

// Define the pixel block size.
IPnt size=new PntClass();
size.SetCoords(512, 512);

// Create the pixel block from a raster.
IPixelBlock pixelBlock=raster.CreatePixelBlock(size);

// Create the pixel block from a band.
IRawPixels rawPixels=(IRawPixels)rasterBand;
pixelBlock=rawPixels.CreatePixelBlock(size);

// Define the starting pixel in pixel space to read.
IPnt topLeft=new PntClass();
topLeft.SetCoords(0, 0);

// Read the pixel block from a band.
rawPixels.Read(topLeft, pixelBlock);

' Define the pixel block size.
Dim Size As IPnt=New PntClass()
Size.SetCoords(512, 512)

' Create the pixel block from a raster.
Dim pixelBlock As IPixelBlock=raster.CreatePixelBlock(Size)

' Create the pixel block from a band.
Dim rawPixels As IRawPixels=CType(rasterBand, IRawPixels)
pixelBlock=rawPixels.CreatePixelBlock(Size)

' Define the starting pixel in pixel space to read.
Dim topLeft As IPnt=New PntClass()
topLeft.SetCoords(0, 0)

' Read the pixel block from a band.
rawPixels.Read(topLeft, pixelBlock)

// Create a raster value from an open raster dataset.
IRasterValue rasterValue=new RasterValueClass();
rasterValue.RasterDataset=rasterDataset;

// Cast an open raster catalog to the IFeatureClass interface.
IFeatureClass featureClass=(IFeatureClass)rasterCatalog;

// Create a row, set the raster value, and call store.
IFeature feature=featureClass.CreateFeature();
feature.set_Value(rasterCatalog.RasterFieldIndex, rasterValue);
feature.Store();

' Create a raster value from an open raster dataset.
Dim rasterValue As IRasterValue=New RasterValueClass()
rasterValue.RasterDataset=rasterDataset

' Cast an open raster catalog to the IFeatureClass interface.
Dim featureClass As IFeatureClass=CType(rasterCatalog, IFeatureClass)

' Create a row, set the raster value, and call store.
Dim feature As IFeature=featureClass.CreateFeature()
feature.Value(rasterCatalog.RasterFieldIndex)=rasterValue
feature.Store()

IFeatureClass featureClass=(IFeatureClass)rasterCatalog;
IRasterCatalogItem rasterCatalogItem=(IRasterCatalogItem)featureClass.GetFeature(1)
    ;
IRasterDataset rasterDataset=rasterCatalogItem.RasterDataset;

Dim featureClass As IFeatureClass=CType(rasterCatalog, IFeatureClass)
Dim rasterCatalogItem As IRasterCatalogItem=CType(featureClass.GetFeature(1), IRasterCatalogItem)
Dim rasterDataset As IRasterDataset=rasterCatalogItem.RasterDataset

Metadata

Plug-in data sources

Network dataset

• NetworkConstantEvaluator - Assigns a constant attribute value to all elements generated by the given source.
• NetworkFieldEvaluator - Assigns attribute values from the values of a single field on the source feature class, or from a mathematical expression involving values from multiple fields.
• NetworkFunctionEvaluator - Derives attribute values by applying a multiplicative or comparative function to the values from another network attribute.
• NetworkGlobalTurnDelayEvaluator - Assigns attribute values for turn elements based on the turn deflection angle and road classes of the streets at the intersection.
• NetworkScriptEvaluator - Calculates the attribute value from a script involving the properties of each network element.

For further information see:

Representation class

IWorkspaceExtensionManager extensionManager=(IWorkspaceExtensionManager)workspace;
UID uid=new UIDClass();
uid.Value="esriGeodatabase.RepresentationWorkspaceExtension";
IRepresentationWorkspaceExtension repExtension=(IRepresentationWorkspaceExtension)
    extensionManager.FindExtension(uid);

Dim extensionManager As IWorkspaceExtensionManager=CType(workspace, IWorkspaceExtensionManager)
Dim uid As UID=New UIDClass()
uid.Value="esriGeodatabase.RepresentationWorkspaceExtension"
Dim repExtension As IRepresentationWorkspaceExtension=CType(extensionManager.FindExtension(uid), IRepresentationWorkspaceExtension)

IRepresentationRules rules=new RepresentationRules();
IRepresentationClass repClass=repExtension.CreateRepresentationClass(featureClass,
    "Cities_Rep", "My_RuleID", "My_Override", false, rules, null);

Dim rules As IRepresentationRules=New RepresentationRules()
Dim repClass As IRepresentationClass=repExtension.CreateRepresentationClass(featureClass, "Cities_Rep", "My_RuleID", "My_Override", False, rules, Nothing)

// Create a map context using a feature class' spatial reference.
IGeoDataset geoDataset=(IGeoDataset)featureClass;
IMapContext mapContext=new MapContextClass();
mapContext.Init(geoDataset.SpatialReference, 10000, geoDataset.Extent);

// Get a feature with a known ObjectID from the feature class.
IFeature feature=featureClass.GetFeature(1);

// Get the feature's representation from the representation class.
repClass.GetRepresentation(feature, mapContext);

' Create a map context using a feature class' spatial reference.
Dim geoDataset As IGeoDataset=CType(featureClass, IGeoDataset)
Dim mapContext As IMapContext=New MapContextClass()
mapContext.Init(geoDataset.SpatialReference, 10000, geoDataset.Extent)

' Get a feature with a known ObjectID from the feature class.
Dim feature As IFeature=featureClass.GetFeature(1)

' Get the feature's representation from the representation class.
repClass.GetRepresentation(feature, mapContext)