Blog Geo.NET Geoprocessamento, SIG e Sensoriamento Remoto

Class Extensions é um assunto relativamente antigo. Quem já desenvolveu para ArcObjects às conhecem razoavelmente bem e são implementadas em larga escala como forma de customização avançada dos famosos geodatabases (qualquer um deles, seja Personal, File ou ArcSDE).

Bem, as class extensions são implementadas através de algumas interfaces especiais e devem ser registradas em uma categoria apropriada (o assunto das categorias de objetos ESRI merece um post sozinho!), GeoObjectClassExtensions para funcionarem e além disso devem ser aplicadas à uma Feature Class ou Table para rodarem apropriadamente. E outra coisa: elas só funcionam com quem possui o código cliente (da Class Extension) instalado na máquina. Para quem não possui o cliente elas se comportam de maneira comum.

Com Class Extensions é possível customizar o inspetor de objetos (aquele carinha utilizado para editar os objetos), customizar a renderização de objetos (isso é poderoso!) e customizar a validação realizada pelo ArcGIS antes da feature receber uma chamada no método Store() (ou seja, antes de ir para o banco);

Existem diversas coisas legais que podemos fazer com estas class extensions e não existe muita dificuldade de implementação (claro, quanto mais requisitos ou quanto mais complexos, mais complicado é de implementar e manter uma CE.).

As CEs podem existes para os seguintes tipos:

• Features
• Rows
• Quaisquer tipos derivados de IRow

O que isto quer dizer? Bem, tanto tabelas, quanto feature classes e qualquer objeto derivado disto podem ter CEs.

Os requerimentos/limitações para Class Extensions são:

• Feature classes e tabelas só podem ter uma class extension;
• A CE precisa ser registrada na categoria apropriada (GeoObjectClassExtensions)
• A funcionalidade não está presente no repositório de dados e sim no cliente. Sempre será necessário realizar o deploy de todo o código das CEs em todos os clientes;

Não são requerimentos/limitações muito pesadas, portanto é uma alternativa viável para customizações mais complexas do procedimento de edição/criação/deleção de objetos.

Obrigatoriamente, o desenvolvedor precisa implementar as seguintes interfaces: IObjectClassExtension (e IFeatureClassExtension, caso seja uma extensão para feature classes). Neste ponto, nossa CE não tem nenhuma funcionalidade. Ela apenas existe.

Para adicionar funcionalidade, podemos implementar outras interfaces, listadas à seguir:

• IObjectClassEvents
• IObjectClassValidation
• IObjectClassInfo
• IRelatedObjectClassEvents
• IConfirmSendRelatedObjectEvents
• IFeatureClassEdit
• IFeatureClassDraw
• IFeatureClassCreation
• IObjectInspector

Estas interfaces são opcionais, cada uma oferencendo um pouquinho de funcionalidade customizada. Hoje falaremos sobre IObjectClassEvents, que é uma das interfaces mais comum de se implementar. Ao longo de uma pequena série tentarei demonstrar a funcionalidade de algumas destas interfaces.

IObjectClassEvents

Esta interface é responsável por nos fornecer métodos para lidar com os eventos de criação, atualização e deleção de um registro. Pense em uma trigger de um banco de dados. Sempre que o evento disparar, determinado método será disparado em sequência.

Os métodos que devem ser implementados para total aderência ao contrato (a interface ) são:

• OnCreate(IObject obj);
• OnChange(IObject obj);
• OnDelete(IObject obj);

Um exemplo de implementação de uma CE com a interface IObjectClassEvents. Note que esta implementação não é completa, ou seja, faltam métodos para o registro da CE, inicialização correta, etc;

Imagine que temos uma tabela log de operação. Nela salvamos os registros relativos às operações realizadas por todos operadores durante o dia. Sua estrutura é a seguinte (em SQL, mas devemos considerar que a tabela está presente em um ambiente ArcGIS - Geodatabases de qualquer tipo);

CREATE TABLE LOG_OPERACAO(
OBJECTID serial NOT NULL,
NOME_TABELA VARCHAR(100) NOT NULL,
NOME_USUARIO VARCHAR(100) NOT NULL,
TIPO_OPERACAO VARCHAR(20) NOT NULL,
OID_ORIGINAL integer NOT NULL,
DATA_HORA_OPERACAO timestamp NOT NULL default now()
CONSTRAINT LOG_OPERACAO_PK PRIMARY KEY (OBJECTID)
);

    public class LogUsuario:IObjectClassExtension,IObjectClassEvents
    {
        public void OnCreate(IObject obj)
        {
            // vamos adicionar um registro à uma tabela de log de operações
            // precisamos de nosso workspace para abrir a tabela
            IFeatureWorkspace workspace = ((IDataset)obj.Class).Workspace;
            ITable logTable = workspace.OpenTable("LOG_OPERACAO");

            // só vamos tentar adicionar se a tabela existir no geodatabase!
            if (logTable != null)
            {
                // ok, a tabela existe. caso não existisse, ela seria nula
                // portanto, vamos criar um novo registro
                IRow novoRegistroLog = logTable.CreateRow();

                novoRegistroLog.set_Value(1,((IDataset)obj.Class).Name); // nome da tabela que estamos modificando
                novoRegistroLog.set_Value(1,Environment.UserName); // nome do usuario
                novoRegistroLog.set_Value(2,"INSERCAO"); // tipo da operacao
                novoRegistroLog.set_Value(3,obj.OID); // id no geodatabase
                novoRegistroLog.set_Value(4,DateTime.Now); // data e hora
                novoRegistroLog.Store();
           }
     }

        public void OnChange(IObject obj)
        {
            // vamos adicionar um registro à uma tabela de log de operações
            // precisamos de nosso workspace para abrir a tabela
            IFeatureWorkspace workspace = ((IDataset)obj.Class).Workspace;
            ITable logTable = workspace.OpenTable("LOG_OPERACAO");

            // só vamos tentar adicionar se a tabela existir no geodatabase!
            if (logTable != null)
            {
                // ok, a tabela existe. caso não existisse, ela seria nula
                // portanto, vamos criar um novo registro
                IRow novoRegistroLog = logTable.CreateRow();

                novoRegistroLog.set_Value(1,((IDataset)obj.Class).Name); // nome da tabela que estamos modificando
                novoRegistroLog.set_Value(1,Environment.UserName); // nome do usuario
                novoRegistroLog.set_Value(2,"ATUALIZACAO"); // tipo da operacao
                novoRegistroLog.set_Value(3,obj.OID); // id no geodatabase
                novoRegistroLog.set_Value(4,DateTime.Now); // data e hora
                novoRegistroLog.Store();
           }
     }

        public void OnDelete(IObject obj)
        {
            // vamos adicionar um registro à uma tabela de log de operações
            // precisamos de nosso workspace para abrir a tabela
            IFeatureWorkspace workspace = ((IDataset)obj.Class).Workspace;
            ITable logTable = workspace.OpenTable("LOG_OPERACAO");

            // só vamos tentar adicionar se a tabela existir no geodatabase!
            if (logTable != null)
            {
                // ok, a tabela existe. caso não existisse, ela seria nula
                // portanto, vamos criar um novo registro
                IRow novoRegistroLog = logTable.CreateRow();

                novoRegistroLog.set_Value(1,((IDataset)obj.Class).Name); // nome da tabela que estamos modificando
                novoRegistroLog.set_Value(1,Environment.UserName); // nome do usuario
                novoRegistroLog.set_Value(2,"INSERCAO"); // tipo da operacao
                novoRegistroLog.set_Value(3,obj.OID); // id no geodatabase
                novoRegistroLog.set_Value(4,DateTime.Now); // data e hora
                novoRegistroLog.Store();
           }
     }
}

Bem, este é um exemplo de implementação da interface IObjectClassEvents. Poderiamos ter deixado o código muito mais limpo (escrevendo uma função à parte para a criação de um registro na tabela de log, por exemplo) e implementado outras funcionalidades. O que importa é que você já sabe como implementar algumas funcionalidades extras dentro do ArcGIS. Lembrando que para esta CE funcionar precisamos aplicar a mesma à uma feature class. Para aplicar uma class extension programaticamente, preciso utilizar algo similar à isto:

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 (!extensionUID.Equals(""))
        {
            // 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);
    }
}

Este snippet de código tirado da documentação da EDN (ESRI Developer Network), instalado junto com o SDK faz as seguintes operações:

1. Tenta assumir um lock exclusivo sobre a ObjectClass (veja a interface IObjectClass);
2. Converte a object class para um class schema edit (veja IClassSchemaEdit2), para poder acessar os membros (métodos e propriedades) de edição;
3. Acha a extensão através do código GUID (é o carinho que se vê como um atributo de classe, localizado acima da declaração comum de classe, no seu projeto do Visual Studio;
4. Altera a class extension;
5. Libera o lock exclusivo (feito na chamada finally para termos garantia que o lock não ficará por lá, atoa);

O que acharam pessoal? Não é exatamente um bixo de sete cabeças, mas precisamos aprofundar nos ArcObjects para ter sucesso na implementação de class extensions úteis. O exemplo fornecido é bobo, pode ter utilidade, mas existem milhares de possibilidades com esses diabinhos. Vários produtos de nível corporativo (soluções de energia, da Miner&Miner por exemplo), apostam pesado na customização de feature classes como saída para problemas complexos.

Tentem brincar um pouquinho com as class extensions. É bem divertido e rende um trabalho interessante.

Vou ficar por aqui!

Um abraço,

George R. C. Silva