Curso de C#: Lição 11: Indexers

Esta lição ensina indexadores C #. Os nossos objectivos são os seguintes: Compreender o que são Indexadores. Implementar um indexador. Sobrecarga de indexadores.Compreender a forma de implementar Multi-Parâmetro indexadores.

Por | @oficinadanet Programação
Esta lição ensina indexadores C #. Os nossos objectivos são os seguintes:

* Compreender o que são Indexadores.
* Implementar um Indexador.
* Sobrecarga de indexadores.
* Compreender a forma de implementar Multi-Parâmetro indexadores.

Indexadores são realmente fáceis. Eles permitem que sua turma a ser utilizado apenas como um array. No interior de uma classe, você gerenciar um conjunto de valores da maneira que desejar. Estes objetos podem ser um conjunto finito de classe membros, uma outra matriz, ou seja, cerca complexa estrutura de dados. Independentemente da implementação interna da classe, seus dados podem ser obtidos através do uso constante de indexadores. Aqui está um exemplo:

Listing 11-1. Um Examplo de um Indexador:  IntIndexer.cs
using System;

///
///     A simple indexer example.
///

class IntIndexer
{
    private string[] myData;

    public IntIndexer(int size)
    {
        myData = new string[size];

        for (int i=0; i < size; i++)
        {
            myData[ i ] = "empty";
        }
    }

    public string this[int pos]
    {
        get
       {
            return myData[pos];
        }
        set
       {
            myData[pos] = value;
        }
    }

    static void Main(string[] args)
    {
        int size = 10;

        IntIndexer myInd = new IntIndexer(size);

        myInd[9] = "Some Value";
        myInd[3] = "Another Value";
        myInd[5] = "Any Value";

        Console.WriteLine("nIndexer Outputn");

        for (int i=0; i < size; i++)
        {
            Console.WriteLine("myInd[{0}]: {1}", i, myInd[ i ]);
        }
    }
}


Listando 11-1 mostra a forma de implementar um Alimentador. O IntIndexer classe tem uma string array chamado myData. Este é um arranjo privado que usuários externos não podem ver.  Este array é inicializado no construtor, que aceita um parâmetro int tamanho, instantiates a myData array, e depois enche cada elemento com a palavra "vazio".

A próxima turma membro é o Alimentador, que é identificado por esta palavra-chave e os colchetes, este [int pos]. Ela aceita uma única posição parâmetro, pos. Como você já pode ter adivinhado, a implementação de um Alimentador é o mesmo que uma propriedade. Tem obter e definir acessores que são exatamente como aqueles usados em uma propriedade.Esse indexador retorna uma string, tal como indicado pelo valor de retorno na corda Alimentador declaração.
O método main () instantiates simplesmente um novo objeto IntIndexer, acrescenta alguns valores, e imprime os resultados. Veja a saída:

Indexer Output
myInd[0]: empty
myInd[1]: empty
myInd[2]: empty
myInd[3]: Another Value
myInd[4]: empty
myInd[5]: Any Value
myInd[6]: empty
myInd[7]: empty
myInd[8]: empty
myInd[9]: Some Value


Usando um número inteiro é um meio de acesso arrays comuns em muitas línguas, mas o C # Alimentador vai além deste. Indexadores podem ser declaradas com vários parâmetros e cada parâmetro pode ser um tipo diferente. Parâmetros adicionais são separadas por vírgulas, o mesmo que um método parâmetro lista. Válido parâmetro tipos de indexadores incluem inteiros, enums, e cordas. Adicionalmente, indexadores podem ser sobrecarregados. Na listagem 11-2, nós modificar o programa anterior para aceitar sobrecarregada indexadores que aceitar diferentes tipos.

Listagem 11-2. Overloaded Indexers: OvrIndexer.cs
using System;

///
///     Implements overloaded indexers.
///

class OvrIndexer
{
    private string[] myData;
    private int         arrSize;

    public OvrIndexer(int size)
    {
        arrSize = size;
        myData = new string[size];

        for (int i=0; i < size; i++)
        {
            myData[ i ] = "empty";
        }
    }

    public string this[int pos]
    {
        get
       {
            return myData[pos];
        }
        set
       {
            myData[pos] = value;
        }
    }

    public string this[string data]
    {
        get
       {
            int count = 0;

            for (int i=0; i < arrSize; i++)
            {
                if (myData[ i ] == data)
                {
                    count++;
                }
            }
            return count.ToString();
        }
        set
       {
            for (int i=0; i < arrSize; i++)
            {
                if (myData[ i ] == data)
                {
                    myData[ i ] = value;
                }
            }
        }
    }

    static void Main(string[] args)
    {
        int size = 10;
        OvrIndexer myInd = new OvrIndexer(size);

        myInd[9] = "Some Value";
        myInd[3] = "Another Value";
        myInd[5] = "Any Value";

        myInd["empty"] = "no value";

        Console.WriteLine("nIndexer Outputn");

        for (int i=0; i < size; i++)
        {
            Console.WriteLine("myInd[{0}]: {1}", i, myInd[ i ]);
        }

        Console.WriteLine("nNumber of "no value" entries: {0}", myInd["no value"]);
    }
}


Listagem 11-2 mostra como a sobrecarga indexadores. O primeiro Alimentador, com o parâmetro int, pos, é o mesmo que na listagem 11-1, mas há uma nova Alimentador que leva uma string parâmetro. O accessor de obter o novo indexador retorna uma representação string do número de itens que atendam o valor do parâmetro de dados. O conjunto accessor mudanças cada entrada no array que corresponde ao tipo de dados parâmetro para o valor que é atribuído ao Alimentador.

O comportamento do sobrecarregada Alimentador que leva uma string parâmetro é demonstrada através do método main () Listagem de 11-2.Ele invoca o conjunto accessor, que atribui o valor de "sem valor" para cada um dos membros do myInd classe que tem o valor de "vazio". Ela usa o seguinte comando: myInd [ "vazio"] = "sem valor";. Após cada entrada do myInd classe é impresso, uma última entrada é impresso para o console, indicando o número de entradas com os "sem valor" string. Isso acontece, invocando o accessor obter com o seguinte código: myInd [ "sem valor"]. Here's the output:
Veja a saída:

Indexer Output

myInd[0]: no value
myInd[1]: no value
myInd[2]: no value
myInd[3]: Another Value
myInd[4]: no value
myInd[5]: Any Value
myInd[6]: no value
myInd[7]: no value
myInd[8]: no value
myInd[9]: Some Value

Number of "no value" entries: 7


A razão pela qual ambos os indexadores na listagem 11-2 podem coexistir na mesma classe é porque eles têm diferentes assinaturas. Um Indexador de assinatura é especificada pelo número e tipo de parâmetros em um parâmetro indexadores lista. A turma será inteligente o bastante para descobrir qual Alimentador de invocar, com base no número e tipo de argumentos no Alimentador chamada. Um indexador com vários parâmetros seriam implementadas, como por exemplo:

public object  this[int param1, ...,  int paramN]
{
get
   {
// process and return some class data
}
set
   {
// process and assign some class data
}
}

    

RESUMO


Você já sabe o que são para os indexadores e como eles são utilizados. Você pode criar uma classe membros Indexadores de acesso semelhantes aos arrays. Sobrecarregado e multi-parâmetro indexadores também foram cobertos.

Tradução automática de: http://www.csharp-station.com/Tutorials/Lesson11.aspx

Mais sobre: curso c sharp c#
Share Tweet
Recomendado
Comentários
Carregar comentários
Destaquesver tudo