Creating class extensions

In this topic

• Common uses of class extensions
• Creating a class extension
• Applying a class extension
• Implementing interfaces
  • IClassExtension
  • Working with extension properties
  • IObjectClassExtension and IFeatureClassExtension
  • IObjectClassEvents
  • IObjectClassValidation
  • IObjectClassInfo and IObjectClassInfo2
  • IRelatedObjectClassEvents and IRelatedObjectClassEvents2
  • IConfirmSendRelatedObjectEvents
  • IObjectInspector
  • IFeatureClassEdit
  • IFeatureClassDraw
• Creating custom class descriptions

Common uses of class extensions

• Handling events triggered by object creation, deletion, or modification - The IObjectClassEvents interface can be implemented to obtain this functionality.
• Validation rules too specific or complex to be applied out-of-the-box - The IObjectClassValidation interface allows extensions to customize the validation process.
• Handling events from related datasets - The following interfaces can be used, depending on the requirements of the class extension: IRelatedObjectClassEvents, IRelatedObjectClassEvents2, and IConfirmSendRelatedObjectEvents.
• Defining custom split policies for relationship classes - The IFeatureClassEdit interface can be used and despite its name, it can be used with feature or object class extensions.
• Specifying custom renderers for feature classes - The IFeatureClassDraw interface can be implemented to associate a custom renderer with a feature class, with the option of making it the exclusive renderer for the class.
• Storage of data associated with the class, such as text, numbers, or objects - This data can be stored in member variables and used by public and private extension members. These key-value pairs are referred to as class extension properties.
• Methods and properties defined by a custom interface (or no interface) can be implemented by a class extension - This is a useful place to define properties to access and modify extension properties or to implement methods for extension specific behavior.

• Three attributes from the System.Runtime.InteropServices namespace: globally unique identifier (GUID), ClassInterface, and ProgID
• Component Object Model (COM) register and unregister methods, which call ArcGIS component category registration and unregistration methods

[Guid("a78421ba-0d38-4104-be58-b049b16f637c")][ClassInterface
    (ClassInterfaceType.None)][ProgId("SampleClassExt.SampleClassExtension")
    ][ComVisible(true)]
public class SampleClassExtension: IClassExtension, IObjectClassExtension
{
    // Class members here...
}

<Guid("a78421ba-0d38-4104-be58-b049b16f637c"), _
      ClassInterface(ClassInterfaceType.None), _
      ProgId("ClassExtensionArticle.SampleClassExtension"), _
      ComVisible(True)> _
      Public Class SampleClassExtension
    Implements IClassExtension, IObjectClassExtension
    
    ' Class members here...
    
End Class

[ComRegisterFunction()][ComVisible(false)] static void RegisterFunction(Type
    registerType)
{
    string regKey=string.Format("HKEY_CLASSES_ROOT\\CLSID\\{{{0}}}",
        registerType.GUID);
    GeoObjectClassExtensions.Register(regKey);
}

[ComUnregisterFunction()][ComVisible(false)] static void UnregisterFunction(Type
    registerType)
{
    string regKey=string.Format("HKEY_CLASSES_ROOT\\CLSID\\{{{0}}}",
        registerType.GUID);
    GeoObjectClassExtensions.Unregister(regKey);
}

<ComRegisterFunction(), ComVisible(False)> _
                     Shared Sub RegisterFunction(ByVal registerType As Type)
    Dim regKey As String=String.Format("HKEY_CLASSES_ROOT\CLSID\{{{0}}}", registerType.GUID)
    GeoObjectClassExtensions.Register(regKey)
End Sub

<ComUnregisterFunction(), ComVisible(False)> _
                       Shared Sub UnregisterFunction(ByVal registerType As Type)
    Dim regKey As String=String.Format("HKEY_CLASSES_ROOT\CLSID\{{{0}}}", registerType.GUID)
    GeoObjectClassExtensions.Unregister(regKey)
End Sub

1. On the Solution Explorer, right-click the project that contains the class extension, click Add, then click New Item. The Add New Item dialog box appears. See the following screenshot:
   
   
   
   
2. On the Add New Item dialog box, click ArcGIS under the Categories pane and click ArcGIS Class under the Templates pane. Type an appropriate name for the class extension in the Name text box and click Add. The ArcGIS Add Class Wizard dialog box appears. See the following  screenshot:
   
   
   
3. On the ArcGIS Add Class Wizard, under Customization Group, click the first drop-down arrow and choose All, then choose Geodatabase from the second drop-down arrow. Click Class Extension under Base Component and click Next. The ESRI GeoObject Class Extensions component category appears. See the following screen shot:
   
   
   
   
4. Select the ESRI GeoObject Class Extensions check box and click Next. A list of available optional interfaces appear, which is only a subset of the optional interfaces. Despite being termed optional, always choose IObjectClassExtension from this list and if the class extension applies to feature classes, also choose IFeatureClassExtension. Choose any other interfaces to implement and click Finish. See the following screen shot:
   
   

Applying a class extension

public void ChangeClassExtension(IObjectClass objectClass, String extensionUID,
    IPropertySet extensionProperties)
{
    ISchemaLock schemaLock=(ISchemaLock)objectClass;

    try
    {
        // Attempt to get an exclusive schema lock.
        schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);

        // Cast the object class to the IClassSchemaEdit2 interface.
        IClassSchemaEdit2 classSchemaEdit=(IClassSchemaEdit2)objectClass;

        if (!String.IsNullOrEmpty(extensionUID))
        {
            // Create a unique identifier (UID) object and change the extension.
            UID extUID=new UIDClass();
            extUID.Value=extensionUID;
            classSchemaEdit.AlterClassExtensionCLSID(extUID, extensionProperties);
        }
        else
        {
            // Clear the class extension.
            classSchemaEdit.AlterClassExtensionCLSID(null, null);
        }
    }
    catch (COMException comExc)
    {
        throw new Exception("Could not change class extension.", comExc);
    }
    finally
    {
        schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
    }
}

Public Sub ChangeClassExtension(ByVal objectClass As IObjectClass, ByVal extensionUID As String, ByVal extensionProperties As IPropertySet)
    Dim schemaLock As ISchemaLock=CType(objectClass, ISchemaLock)
    Try
    ' Attempt to get an exclusive schema lock.
    schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock)
    
    ' Cast the object class to the IClassSchemaEdit2 interface.
    Dim classSchemaEdit As IClassSchemaEdit=CType(objectClass, IClassSchemaEdit)
    If Not String.IsNullOrEmpty(extensionUID) Then
        ' Create a unique identifier (UID) object and change the extension.
        Dim extUID As UID=New UIDClass()
        extUID.Value=extensionUID
        classSchemaEdit.AlterClassExtensionCLSID(extUID, extensionProperties)
    Else
        ' Clear the class extension.
        classSchemaEdit.AlterClassExtensionCLSID(Nothing, Nothing)
    End If
    Catch comExc As COMException
    Throw New Exception("Could not change class extension.", comExc)
    Finally
    schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock)
    End Try
End Sub

Implementing interfaces

• IObjectClassValidation
• IObjectClassEvents
• IObjectClassInfo and IObjectClassInfo2
• IRelatedObjectClassEvents and IRelatedObjectClassEvents2
• IConfirmSendRelatedObjectEvents
• IFeatureClassEdit
• IFeatureClassDraw (feature class extensions only)
• IFeatureClassCreation (feature class extensions only)

IClassExtension

private IClassHelper classHelper=null;

public void Init(IClassHelper classHelper, IPropertySet extensionProperties)
{
    // Store the class helper reference.
    this.classHelper=classHelper;
}

Private classHelper As IClassHelper=Nothing
    
    Public Sub Init(ByVal classHelper As IClassHelper, ByVal extensionProperties As IPropertySet) Implements IClassExtension.Init
        ' Store the class helper reference.
        Me.classHelper=classHelper
    End Sub

Working with extension properties

private IPropertySet extensionProperties=null;
private IClassHelper classHelper=null;

private const String LOGFILE_PROPERTY="LogFile";
private const String DEFAULT_LOGFILE=@"C:\Temp\LogFile.txt";

public void Init(IClassHelper classHelper, IPropertySet initExtensionProperties)
{
    // Store the class helper reference.
    this.classHelper=classHelper;

    // Store the extension properties.
    extensionProperties=initExtensionProperties;

    // Create extension properties if none exist.
    if (extensionProperties == null)
    {
        extensionProperties=new PropertySetClass();
        extensionProperties.SetProperty(LOGFILE_PROPERTY, DEFAULT_LOGFILE);
    }
}

public String LogFile
{
    get
    {
        return extensionProperties.GetProperty(LOGFILE_PROPERTY)as String;
    }

    set
    {
        // Get the base class and cast to the IClassSchemaEdit2 interface.
        IClass baseClass=classHelper.Class;
        IClassSchemaEdit2 classSchemaEdit=(IClassSchemaEdit2)baseClass;

        // Attempt to acquire an exclusive schema lock.
        ISchemaLock schemaLock=(ISchemaLock)baseClass;
        try
        {
            schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);

            // Set the extension property and save it.
            extensionProperties.SetProperty(LOGFILE_PROPERTY, value);
            classSchemaEdit.AlterClassExtensionProperties(extensionProperties);
        }
        catch (COMException comExc)
        {
            throw new Exception(String.Format(
                "Error updating extension properties: {0}", comExc.Message), comExc);
        }
        finally
        {
            schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
        }
    }
}

Private extensionProperties As IPropertySet=Nothing

Private classHelper As IClassHelper=Nothing
    
    Private Const LOGFILE_PROPERTY As String="LogFile"
    Private Const DEFAULT_LOGFILE As String="C:\Temp\LogFile.txt"
    
    Public Sub Init(ByVal classHelper As IClassHelper, ByVal extensionProperties As IPropertySet) Implements IClassExtension.Init
        ' Store the class helper reference.
        Me.classHelper=classHelper
        
        ' Store the extension properties.
        extensionProperties=extensionProperties
        
        ' Create extension properties if none exist.
        If extensionProperties Is Nothing Then
            extensionProperties=New PropertySetClass()
            extensionProperties.SetProperty(LOGFILE_PROPERTY, DEFAULT_LOGFILE)
        End If
    End Sub
    
    Public Property LogFile() As String
        Get
        Return CType(extensionProperties.GetProperty(LOGFILE_PROPERTY), String)
        End Get
        Set(ByVal Value As String)
        ' Get the base class and cast to the IClassSchemaEdit2 interface.
        Dim baseClass As IClass=classHelper.Class
        Dim classSchemaEdit2 As IClassSchemaEdit2=CType(baseClass, IClassSchemaEdit2)
        
        ' Attempt to acquire an exclusive schema lock.
        Dim schemaLock As ISchemaLock=CType(baseClass, ISchemaLock)
        Try
        schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock)
        
        ' Set the extension property and save it.
        extensionProperties.SetProperty(LOGFILE_PROPERTY, Value)
        classSchemaEdit2.AlterClassExtensionProperties(extensionProperties)
        Catch comExc As COMException
        Throw New Exception(String.Format("Error updating extension properties: {0}", comExc.Message), comExc)
        Finally
        schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock)
        End Try
        End Set
    End Property

IObjectClassExtension and IFeatureClassExtension

IObjectClassEvents

private static readonly String timestampFieldName="CREATED";

// Set position during IClassExtension.Init method using IClass.FindField.
private int timestampFieldPosition= - 1;

public void OnCreate(IObject obj)
{
    // Set the time stamp field's value to the current date and time.
    obj.set_Value(timestampFieldPosition, DateTime.Now);
}

public void OnDelete(IObject obj)
{
    // Do nothing.
}

public void OnChange(IObject obj)
{
    // Do nothing.
}

Private Const TIMESTAMP_FIELD_NAME As String="CREATED"

' Set position during IClassExtension.Init method using IClass.FindField.
Private timestampFieldPosition As Integer=-1

Public Sub OnCreate(ByVal obj As IObject) Implements IObjectClassEvents.OnCreate
    If timestampFieldPosition >= 0 Then
        obj.Value(timestampFieldPosition)=DateTime.Now
    End If
End Sub

Public Sub OnDelete(ByVal obj As IObject) Implements IObjectClassEvents.OnDelete
    ' Do nothing.
End Sub

Public Sub OnChange(ByVal obj As IObject) Implements IObjectClassEvents.OnChange
    ' Do nothing.
End Sub

IObjectClassValidation

• Fields with string values that require the use of string functions for validation
• Fields with a range of numeric values that must be validated using another field, also with a range of numeric values (making it unsuitable for subtyping)
• Fields with values that are constrained by a combination of multiple fields
• Fields with values that must be validated by checking external sources, such as a data dictionary table or the local file system

• ValidateRow
• ValidateField

// The class extension's class helper.
private IClassHelper classHelper=null;

// The name of the class's Email field.
private const String EMAIL_FIELD="Email";

// The index of the Email field.
private int emailFieldIndex= - 1;

// A simple regular expression for e-mail validation.
private const String REGEX_STR=@"[\w-]+@([\w-]+\.)+[\w-]+";

// A Regex instance created when the class extension is initialized.
private Regex regex=null;

public void Init(IClassHelper classHelper, IPropertySet extensionProperties)
{
    // Keep a reference to the helper.
    this.classHelper=classHelper;

    // Find the dataset's Email field.
    IClass baseClass=classHelper.Class;
    emailFieldIndex=baseClass.FindField(EMAIL_FIELD);

    // Create the Regex instance.
    regex=new Regex(REGEX_STR);
}

public String ValidateField(IRow row, String fieldName)
{
    String validationDescription=String.Empty;

    // Check that the Email field is being validated.
    if (fieldName.Equals(EMAIL_FIELD))
    {
        // Get the e-mail address.
        String email=Convert.ToString(row.get_Value(emailFieldIndex));

        // Check the regular expression for a match.
        if (!regex.IsMatch(email))
        {
            validationDescription=String.Format(
                "{0} is not a valid email address.", email);
        }
    }

    return validationDescription;
}

public String ValidateRow(IRow row)
{
    // Validate the Email field.
    return ValidateField(row, EMAIL_FIELD);
}

' The class extension's class helper.

Private classHelper As IClassHelper=Nothing
    
    ' The name of the class's Email field.
    Private Const EMAIL_FIELD As String="Email"
    
    ' The index of the Email field.
    Private emailFieldIndex As Integer=-1
    
    ' A simple regular expression for e-mail validation.
    Private Const REGEX_STR As String="[\w-]+@([\w-]+\.)+[\w-]+"
    
    ' A Regex instance created when the class extension is initialized.
    Private regex As Regex=Nothing
    
    Public Sub Init(ByVal classHelper As IClassHelper, ByVal extensionProperties As IPropertySet) _
                    Implements IClassExtension.Init
        
        ' Keep a reference to the helper.
        Me.classHelper=classHelper
        
        ' Find the dataset's Email field.
        Dim baseClass As IClass=classHelper.Class
        emailFieldIndex=baseClass.FindField(EMAIL_FIELD)
        
        ' Create the Regex instance.
        regex=New Regex(REGEX_STR)
    End Sub
    
    Public Function ValidateField(ByVal row As IRow, ByVal fieldName As String) As String _
                                  Implements IObjectClassValidation.ValidateField
        
        Dim validationDescription As String=String.Empty
        
        ' Check that the Email field is being validated.
        If fieldName.Equals(EMAIL_FIELD) Then
            ' Get the e-mail address.
            Dim email As String=Convert.ToString(row.Value(emailFieldIndex))
            
            ' Check the regular expression for a match.
            If Not regex.IsMatch(email) Then
                validationDescription=String.Format("{0} is not a valid email address.", email)
            End If
        End If
        
        Return validationDescription
    End Function
    
    Public Function ValidateRow(ByVal row As IRow) As String _
                                Implements IObjectClassValidation.ValidateRow
        
        ' Validate the Email field.
        Return ValidateField(row, EMAIL_FIELD)
    End Function

IObjectClassInfo and IObjectClassInfo2

• CanBypassStoreMethod - Indicates if IRow.Store must be called when objects are created in the class
• CanBypassEditSession - Indicates if the class requires data modification to take place in an edit session

public Boolean CanBypassStoreMethod()
{
    return false;
}

Public Function CanBypassStoreMethod() As Boolean Implements IObjectClassInfo.CanBypassStoreMethod
    Return False
End Function

public Boolean CanBypassEditSession()
{
    return false;
}

Public Function CanBypassEditSession() As Boolean Implements IObjectClassInfo2.CanBypassEditSession
    Return False
End Function

IRelatedObjectClassEvents and IRelatedObjectClassEvents2

• When the source class already has a class extension applied to it.
• When creating a variation of composite relationship behavior. For example, creating a relationship class that will move and rotate related features, but will not cascade deletion.

public void RelatedObjectSetMoved(IRelationshipClass relationshipClass, ISet
    objectsThatNeedToChange, ISet objectsThatChanged, ILine moveVector)
{
    // Get the first object to change and cast to the IFeatureEdit interface.
    objectsThatNeedToChange.Reset();
    IFeatureEdit featureEdit=objectsThatNeedToChange.Next()as IFeatureEdit;

    // If it is the correct type of object, move the related objects.
    if (featureEdit != null)
    {
        featureEdit.MoveSet(objectsThatNeedToChange, moveVector);
    }
}

public void RelatedObjectSetRotated(IRelationshipClass relationshipClass, ISet
    objectsThatNeedToChange, ISet objectsThatChanged, IPoint origin, Double angle)
{
    // Get the first object to change and cast to the IFeatureEdit interface.
    objectsThatNeedToChange.Reset();
    IFeatureEdit featureEdit=objectsThatNeedToChange.Next()as IFeatureEdit;

    // If it is the correct type of object, move the related objects.
    if (featureEdit != null)
    {
        featureEdit.RotateSet(objectsThatNeedToChange, origin, angle);
    }
}

Public Sub RelatedObjectSetMoved(ByVal relationshipClass As IRelationshipClass, _
                                 ByVal objectsThatNeedToChange As ISet, ByVal objectsThatChanged As ISet, _
                                 ByVal moveVector As ILine) Implements IRelatedObjectClassEvents2.RelatedObjectSetMoved
    
    ' Get the first object to change and cast to the IFeatureEdit interface.
    objectsThatNeedToChange.Reset()
    Dim featureEdit As IFeatureEdit=TryCast(objectsThatNeedToChange.Next(), IFeatureEdit)
    
    ' If it is the correct type of object, move the related objects.
    If Not featureEdit Is Nothing Then
        featureEdit.MoveSet(objectsThatNeedToChange, moveVector)
    End If
End Sub

Public Sub RelatedObjectSetRotated(ByVal relationshipClass As IRelationshipClass, _
                                   ByVal objectsThatNeedToChange As ISet, ByVal objectsThatChanged As ISet, _
                                   ByVal origin As IPoint, ByVal angle As Double) Implements IRelatedObjectClassEvents2.RelatedObjectSetRotated
    
    ' Get the first object to change and cast to the IFeatureEdit interface.
    objectsThatNeedToChange.Reset()
    Dim featureEdit As IFeatureEdit=TryCast(objectsThatNeedToChange.Next(), IFeatureEdit)
    
    ' If it is the correct type of object, move the related objects.
    If Not featureEdit Is Nothing Then
        featureEdit.RotateSet(objectsThatNeedToChange, origin, angle)
    End If
End Sub

IConfirmSendRelatedObjectEvents

// The name of the ownership relationship class. TODO: This should be set by implementing an
// extension specific method, along with a property page, and stored in the extension properties.
private String ownershipRelClassName=null;

public Boolean ConfirmSendRelatedObjectChanged(IRelationshipClass relClass, IObject
    objectThatChanged)
{
    // Make sure the object changed is from the correct related class.
    IDataset dataset=(IDataset)relClass;
    if (!dataset.Name.Equals(ownershipRelClassName))
    {
        return false;
    }

    // Cast to the IFeatureChanges interface and check for shape change.
    IFeatureChanges featureChanges=objectThatChanged as IFeatureChanges;
    if (featureChanges != null)
    {
        return featureChanges.ShapeChanged;
    }

    // Object is not a feature.
    return false;
}

' The name of the ownership relationship class. TODO: This should be set by implementing an
' extension specific method, along with a property page, and stored in the extension properties.
Private ownershipRelClassName As String=Nothing

Public Function ConfirmSendRelatedObjectChanged(ByVal relClass As IRelationshipClass, ByVal objectThatChanged As IObject) As Boolean Implements IConfirmSendRelatedObjectEvents.ConfirmSendRelatedObjectChanged
    ' Make sure the object changed is from the correct related class.
    Dim dataset As IDataset=CType(relClass, IDataset)
    If Not dataset.Name.Equals(ownershipRelClassName) Then
        Return False
    End If
    
    ' Cast to the IFeatureChanges interface and check for shape change.
    Dim featureChanges As IFeatureChanges=TryCast(objectThatChanged, IFeatureChanges)
    If Not featureChanges Is Nothing Then
        Return featureChanges.ShapeChanged
    End If
    
    ' Object is not a feature.
    Return False
End Function

IObjectInspector

The Attributes dialog box in ArcMap is used to view and edit an object's attributes during an edit session. It contains a tree view, which shows the currently selected objects and a list view, which contains the names and values for each field of the object selected in the tree view. The list view is the default object inspector or feature inspector (the terms are interchangeable). See the following screen shot that shows the Attributes dialog box with the default object inspector:

IFeatureClassEdit

public Boolean CanEditWithProjection
{
    get
    {
        return false;
    }
}

Public ReadOnly Property CanEditWithProjection() As Boolean Implements IFeatureClassEdit.CanEditWithProjection
Get
Return False
End Get
End Property

// Load from extension properties in IClassExtension.Init.
private String parcelOwnerRelClassName=null;

public Boolean HasCustomSplitPolicyForRelationship()
{
    return true;
}

public esriRelationshipSplitPolicy get_CustomSplitPolicyForRelationship(IRow row,
    IRelationshipClass relClass)
{
    IDataset rcDataset=(IDataset)relClass;
    if (rcDataset.Name.Equals(parcelOwnerRelClassName))
    {
        // If the relationship class (RC) is the parcel owner RC, use the custom policy.
        return esriRelationshipSplitPolicy.esriRSPPreserveOnAll;
    }
    else
    {
        // It is another RC. Use the default policy.
        if (relClass.IsComposite)
        {
            return esriRelationshipSplitPolicy.esriRSPDeleteParts;
        }
        else
        {
            return esriRelationshipSplitPolicy.esriRSPPreserveOnLargest;
        }
    }
}

Public Function HasCustomSplitPolicyForRelationship() As Boolean Implements IFeatureClassEdit.HasCustomSplitPolicyForRelationship
    Return True
End Function

Public ReadOnly Property CustomSplitPolicyForRelationship(ByVal row As IRow, ByVal relClass As IRelationshipClass) As esriRelationshipSplitPolicy Implements IFeatureClassEdit.CustomSplitPolicyForRelationship
Get
Dim rcDataset As IDataset=CType(relClass, IDataset)
If rcDataset.Name.Equals(ownershipRelClassName) Then
    ' If the relationship class (RC) is the parcel owner RC, use the custom policy.
    Return esriRelationshipSplitPolicy.esriRSPPreserveOnAll
Else
    ' It is another RC. Use the default policy.
    If relClass.IsComposite Then
        Return esriRelationshipSplitPolicy.esriRSPDeleteParts
    Else
        Return esriRelationshipSplitPolicy.esriRSPPreserveOnLargest
    End If
End If
End Get
End Property

IFeatureClassDraw

public Boolean DoesCustomDrawing()
{
    return true;
}

Public Function DoesCustomDrawing() As Boolean Implements IFeatureClassDraw.DoesCustomDrawing
    Return True
End Function

• HasCustomRenderer returns true if the custom drawing behavior is implemented with a custom renderer and returns false if the behavior is defined in a custom feature.
• ExclusiveCustomRenderer returns true if the custom renderer is the only renderer that layers can use when the feature class displays (false allows others to be used).

public Boolean ExclusiveCustomRenderer
{
    get
    {
        return false;
    }
}

public Boolean HasCustomRenderer()
{
    return true;
}

Public ReadOnly Property ExclusiveCustomRenderer() As Boolean Implements IFeatureClassDraw.ExclusiveCustomRenderer
Get
Return True
End Get
End Property

Public Function HasCustomRenderer() As Boolean Implements IFeatureClassDraw.HasCustomRenderer
    Return True
End Function

public object CustomRenderer
{
    get
    {
        Type type=Type.GetTypeFromProgID("PointDispersal.Renderer");
        return Activator.CreateInstance(type);
    }
}

public UID CustomRendererPropPageCLSID
{
    get
    {
        UID uid=new UIDClass();
        uid.Value="{CB3B689F-27A5-11D7-8B5C-00104BB6FCCB}";
        return uid;
    }
}

Public ReadOnly Property CustomRenderer() As Object Implements IFeatureClassDraw.CustomRenderer
Get
Dim Type As Type=Type.GetTypeFromProgID("PointDispersal.Renderer")
Return Activator.CreateInstance(Type)
End Get
End Property

Public ReadOnly Property CustomRendererPropPageCLSID() As UID Implements IFeatureClassDraw.CustomRendererPropPageCLSID
Get
Dim uid As UID=New UIDClass()
uid.Value="{CB3B689F-27A5-11D7-8B5C-00104BB6FCCB}"
Return uid
End Get
End Property

public IFields RequiredFieldsForDraw
{
    get
    {
        // Get the class's OID field.
        IClass baseClass=classHelper.Class;
        String oidFieldName=baseClass.OIDFieldName;
        int oidFieldIndex=baseClass.FindField(oidFieldName);
        IFields baseClassFields=baseClass.Fields;
        IField oidField=baseClassFields.get_Field(oidFieldIndex);

        // Create a new fields collection.
        IFields fields=new FieldsClass();
        IFieldsEdit fieldsEdit=(IFieldsEdit)fields;
        fieldsEdit.AddField(oidField);

        return fields;
    }
}

Public ReadOnly Property RequiredFieldsForDraw() As IFields Implements IFeatureClassDraw.RequiredFieldsForDraw
Get
' Get the class's OID field.
Dim baseClass As IClass=classHelper.Class
Dim oidFieldName As String=baseClass.OIDFieldName
Dim oidFieldIndex As Integer=baseClass.FindField(oidFieldName)
Dim baseClassFields As IFields=baseClass.Fields
Dim oidField As IField=baseClassFields.Field(oidFieldIndex)

' Create a new fields collection.
Dim fields As IFields=New FieldsClass()
Dim fieldsEdit As IFieldsEdit=CType(fields, IFieldsEdit)
fieldsEdit.AddField(oidField)

Return fields
End Get
End Property

Creating custom class descriptions

• Name - Returns what users see in the Type section of the ArcCatalog New Feature Class dialog box when creating a new feature class
• AliasName - Provides an alternate name for the object class description
• ModelName - Provides an additional way of guaranteeing a class is unique

public String Name
{
    get
    {
        return "Timestamped Class";
    }
}

public String AliasName
{
    get
    {
        return String.Empty;
    }
}

public String ModelName
{
    get
    {
        return String.Empty;
    }
}

public Boolean ModelNameUnique
{
    get
    {
        return false;
    }
}

Public ReadOnly Property Name() As String Implements IObjectClassDescription.Name
Get
Return "Timestamped Class"
End Get
End Property

Public ReadOnly Property AliasName() As String Implements IObjectClassDescription.AliasName
Get
Return ""
End Get
End Property

Public ReadOnly Property ModelName() As String Implements ESRI.ArcGIS.Geodatabase.IObjectClassDescription.ModelName
Get
Return ""
End Get
End Property

Public ReadOnly Property ModelNameUnique() As Boolean Implements ESRI.ArcGIS.Geodatabase.IObjectClassDescription.ModelNameUnique
Get
Return False
End Get
End Property

public UID InstanceCLSID
{
    get
    {
        // Return the UID of feature.
        UID uid=new UIDClass();
        uid.Value="{52353152-891A-11D0-BEC6-00805F7C4268}";
        return uid;
    }
}

public UID ClassExtensionCLSID
{
    get
    {
        // Return the UID of TimestampedClassExtension.
        UID uid=new UIDClass();
        uid.Value="{31b0b791-3606-4c58-b4d9-940c157dca4c}";
        return uid;
    }
}

Public ReadOnly Property InstanceCLSID() As UID Implements IObjectClassDescription.InstanceCLSID
Get
Dim uid As UID=New UIDClass()
uid.Value="{52353152-891A-11D0-BEC6-00805F7C4268}"
Return uid
End Get
End Property

Public ReadOnly Property ClassExtensionCLSID() As UID Implements IObjectClassDescription.ClassExtensionCLSID
Get
Dim uid As UID=New UIDClass()
uid.Value="{31b0b791-3606-4c58-b4d9-940c157dca4c}"
Return uid
End Get
End Property

public IFields RequiredFields
{
    get
    {
        // Get the feature class required fields.
        IFeatureClassDescription fcDescription=new FeatureClassDescriptionClass();
        IObjectClassDescription ocDescription=(IObjectClassDescription)
            fcDescription;
        IFields requiredFields=ocDescription.RequiredFields;
        IFieldsEdit requiredFieldsEdit=(IFieldsEdit)requiredFields;

        // Add a created date field.
        IField createdField=new FieldClass();
        IFieldEdit createdFieldEdit=(IFieldEdit)createdField;
        createdFieldEdit.Name_2="Created";
        createdFieldEdit.Required_2=false;
        createdFieldEdit.IsNullable_2=true;
        createdFieldEdit.Type_2=esriFieldType.esriFieldTypeDate;
        requiredFieldsEdit.AddField(createdField);

        // Add a modified date field.
        IField modifiedField=new FieldClass();
        IFieldEdit modifiedFieldEdit=(IFieldEdit)modifiedField;
        modifiedFieldEdit.Name_2="Modified";
        modifiedFieldEdit.Required_2=false;
        modifiedFieldEdit.IsNullable_2=true;
        modifiedFieldEdit.Type_2=esriFieldType.esriFieldTypeDate;
        requiredFieldsEdit.AddField(modifiedField);

        return requiredFields;
    }
}

Public ReadOnly Property RequiredFields() As IFields Implements IObjectClassDescription.RequiredFields
Get
' Get the feature class required fields.
Dim fcDescription As IFeatureClassDescription=New FeatureClassDescriptionClass()
Dim ocDescription As IObjectClassDescription=CType(fcDescription, IObjectClassDescription)
Dim fields As IFields=ocDescription.RequiredFields
Dim fieldsEdit As IFieldsEdit=CType(fields, IFieldsEdit)

' Add a created date field.
Dim createdField As IField=New FieldClass()
Dim createdFieldEdit As IFieldEdit=CType(createdField, IFieldEdit)
createdFieldEdit.Name_2="Created"
createdFieldEdit.Required_2=False
createdFieldEdit.IsNullable_2=True
createdFieldEdit.Type_2=esriFieldType.esriFieldTypeDate
fieldsEdit.AddField(createdField)

' Add a modified date field.
Dim modifiedField As IField=New FieldClass()
Dim modifiedFieldEdit As IFieldEdit=CType(modifiedField, IFieldEdit)
modifiedFieldEdit.Name_2="Modified"
modifiedFieldEdit.Required_2=False
modifiedFieldEdit.IsNullable_2=True
modifiedFieldEdit.Type_2=esriFieldType.esriFieldTypeDate
fieldsEdit.AddField(modifiedField)

Return fields
End Get
End Property

• FeatureType - Returns the feature type to be created (that is, simple, simple junction, or simple edge)
• ShapeFieldName - Returns the default Shape field name (by default, SHAPE for feature classes)

public esriFeatureType FeatureType
{
    get
    {
        return esriFeatureType.esriFTSimple;
    }
}

public String ShapeFieldName
{
    get
    {
        IFeatureClassDescription fcDescription=new FeatureClassDescriptionClass();
        return fcDescription.ShapeFieldName;
    }
}

Public ReadOnly Property FeatureType() As esriFeatureType Implements IFeatureClassDescription.FeatureType
Get
Return esriFeatureType.esriFTSimple
End Get
End Property

Public ReadOnly Property ShapeFieldName() As String Implements IFeatureClassDescription.ShapeFieldName
Get
Dim fcDescription As IFeatureClassDescription=New FeatureClassDescription()
Return fcDescription.ShapeFieldName
End Get
End Property

// Create an instance of the TimestampedClassDescription.
Type tsDescriptionType=Type.GetTypeFromProgID(
    "TimestampedClassDescription.TimestampedClassDescription");
object tsDescriptionObject=Activator.CreateInstance(tsDescriptionType);

// Cast the description object to ArcGIS class description interfaces.
IFeatureClassDescription fcDescription=(IFeatureClassDescription)
    tsDescriptionObject;
IObjectClassDescription ocDescription=(IObjectClassDescription)tsDescriptionObject;

// Create a new feature class using the class description.
IFeatureClass featureClass=featureWorkspace.CreateFeatureClass("MyTimestampClass",
    ocDescription.RequiredFields, ocDescription.InstanceCLSID,
    ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple,
    fcDescription.ShapeFieldName, "");

' Create an instance of the TimestampedClassDescription.
Dim tsDescriptionType As Type=Type.GetTypeFromProgID("TimestampedClassDescription.TimestampedClassDescription")
Dim tsDescriptionObject As Object=Activator.CreateInstance(tsDescriptionType)

' Cast the description object to ArcGIS class description interfaces.
Dim fcDescription As IFeatureClassDescription=CType(tsDescriptionObject, IFeatureClassDescription)
Dim ocDescription As IObjectClassDescription=CType(tsDescriptionObject, IObjectClassDescription)

' Create a new feature class using the class description.
Dim featureClass As IFeatureClass=featureWorkspace.CreateFeatureClass("MyTimestampClass", _
                                    ocDescription.RequiredFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, _
                                    esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, "")

See Also:

• ESRI.ArcGIS.ADF.Local
• ESRI.ArcGIS.System (ESRI.ArcGIS.esriSystem)
• ESRI.ArcGIS.Geodatabase
• ESRI.ArcGIS.Geometry