Geodatabase

              // 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))

              // 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)

              // 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 AsInteger = 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 AsInteger = 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()
WhileNot row IsNothing
    Console.WriteLine(row.Value(0))
    row = cursor.NextRow()
EndWhile

              // 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))

              // 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 = NothingIf featureClassContainer.ClassCount = 1 Then
    featureClass = featureClassContainer.Class(0)
EndIf

              // 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()
WhileNot feature IsNothing
    featureSet.Add(feature)
    feature = featureCursor.NextFeature()
EndWhileEnd Using

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

              // 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()
WhileNot rule IsNothingIf rule.Type = esriRuleType.esriRTAttribute ThenDim 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)
    EndIf
    rule = enumRule.Next()
EndWhile

              // 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);
    objectvalue = 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 AsInteger = 0
For i = 0 To codedValueDomain.CodeCount - 1
    Dim Name AsString = codedValueDomain.Name(i)
    Dim Value AsObject = codedValueDomain.Value(i)
    Console.WriteLine("Name: {0}, Value: {1}", Name, Value)
Next

              // 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 AsInteger = 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

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)

              // 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 = NothingDim conflictsFound AsBoolean = False
gdbSchemaCreator.GenerateNameMapping(targetWorkspace, dataElementArray, Nothing, enumNameMapping, conflictsFound)
enumNameMapping.Reset()

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

              // 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")

              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 = NothingDim 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)
EndSub

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
EndIf

              // 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 AsBoolean = versionEdit4.Reconcile4("SDE.DEFAULT", True, False, False, True)

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

              // 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()
WhileNot historicalMarker IsNothing
    Console.WriteLine("Name: '{0}', Time: '{1}'", historicalMarker.Name, historicalMarker.TimeStamp)
    historicalMarker = enumHistoricalMarker.Next()
EndWhile

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 AsInteger = CInt(esriSQLPrivilege.esriSelectPrivilege) OrCInt(esriSQLPrivilege.esriUpdatePrivilege)

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

              // 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 AsInteger = destinationClass.FindField("NAME")
Dim setObject AsObject = relatedSet.Next()
WhileNot setObject IsNothingDim row As IRow = CType(setObject, IRow)
    Console.WriteLine("OID: {0}, NAME: {1}", row.OID, row.Value(nameIndex))
    setObject = relatedSet.Next()
EndWhile

              // 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)

              // 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 AsBoolean = False
rasterBand.HasColormap(hasColormap)
If hasColormap ThenDim rasterColormap As IRasterColormap = rasterBand.Colormap
    ' Use the colormap...EndIf

              // 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

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)