0Pricing
C# Academy · Aula

Tipos personalizados compatíveis com intervalos

Adicione suporte a Index e Range aos seus tipos.

Tipos personalizados compatíveis com intervalos é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Duas formas de oferecer suporte a Index e Range

Seus próprios tipos podem aceitar a sintaxe de Index e Range. Há duas opções: fornecer indexadores explícitos ou fornecer uma propriedade Length/Count e um método Slice.

Indexador explícito de Index

Adicione um indexador que receba System.Index, e o operador ^ funcionará diretamente no seu tipo.

using System;

class Deck {
    private int[] cards = { 1, 2, 3, 4, 5 };
    public int this[Index i] => cards[i];
}

var d = new Deck();
Console.WriteLine(d[^1]); // 5

Indexador explícito de Range

Para oferecer suporte ao fatiamento com .., adicione um indexador que receba System.Range e retorne o tipo de fatia desejado.

using System;

class Deck {
    private int[] cards = { 1, 2, 3, 4, 5 };
    public int[] this[Range r] => cards[r];
}

var d = new Deck();
Console.WriteLine(string.Join(",", d[1..3])); // 2,3

Padrão Length + Slice

O compilador também pode gerar automaticamente o suporte a intervalos se o seu tipo tiver uma propriedade Count ou Length e um método Slice(int start, int length).

Implementando o padrão

Aqui, um armazenamento intermediário personalizado expõe Length e Slice. O compilador reescreve buf[1..3] como buf.Slice(1, 2) para você.

using System;

class Buffer {
    private int[] data = { 10, 20, 30, 40 };
    public int Length => data.Length;
    public int this[int i] => data[i];
    public int[] Slice(int start, int length) {
        var result = new int[length];
        Array.Copy(data, start, result, 0, length);
        return result;
    }
}

var buf = new Buffer();
Console.WriteLine(string.Join(",", buf[1..3])); // 20,30

Por que Length é importante

A propriedade Length (ou Count) permite ao compilador resolver índices a partir do fim, como ^1, no seu tipo. Sem ela, ^ não pode ser traduzido.

using System;

class Buffer {
    private int[] data = { 10, 20, 30, 40 };
    public int Length => data.Length;
    public int this[Index i] => data[i.GetOffset(Length)];
}

var buf = new Buffer();
Console.WriteLine(buf[^1]); // 40

Resolvendo Index manualmente

Dentro de um indexador de Index, chame i.GetOffset(Length) para converter um índice possivelmente contado a partir do fim em um deslocamento comum.

using System;

class Ring {
    private string[] items = { "a", "b", "c" };
    public int Length => items.Length;
    public string this[Index i] {
        get {
            int offset = i.GetOffset(Length);
            return items[offset];
        }
    }
}

var r = new Ring();
Console.WriteLine(r[^2]); // b

Resolvendo Range manualmente

Para um indexador de Range, r.GetOffsetAndLength(Length) fornece tanto o início quanto a quantidade a copiar.

using System;

class Ring {
    private int[] items = { 1, 2, 3, 4, 5 };
    public int Length => items.Length;
    public int[] this[Range r] {
        get {
            var (start, len) = r.GetOffsetAndLength(Length);
            var slice = new int[len];
            Array.Copy(items, start, slice, 0, len);
            return slice;
        }
    }
}

var r = new Ring();
Console.WriteLine(string.Join(",", r[^3..^1])); // 3,4

Count versus Length

O padrão aceita qualquer um dos nomes: matrizes e segmentos usam Length; List<T> usa Count. Qualquer uma dessas propriedades satisfaz o compilador.

using System;
using System.Collections.Generic;

var list = new List<int> { 1, 2, 3, 4 };
// List<T> has Count, so Index works:
Console.WriteLine(list[^1]); // 4

Projetando tipos de retorno de Slice

Decida se seu Slice retorna uma cópia, como as matrizes, ou uma visão, como os segmentos. As visões são mais econômicas, mas compartilham estado mutável; portanto, documente essa escolha.

Um tipo personalizado completo

Esta Sequence oferece suporte a ^ e .. por meio de indexadores explícitos e de uma propriedade Length.

using System;

class Sequence {
    private int[] data;
    public Sequence(int[] d) => data = d;
    public int Length => data.Length;
    public int this[Index i] => data[i];
    public int[] this[Range r] => data[r];
}

var s = new Sequence(new[] { 5, 10, 15, 20 });
Console.WriteLine(s[^1]);                       // 20
Console.WriteLine(string.Join(",", s[1..^1]));  // 10,15

Verificação rápida

Confirme o que habilita a sintaxe de intervalos em um tipo personalizado.

Recapitulação

Você aprendeu duas formas de adicionar suporte a Index/Range aos seus tipos.

  • Indexadores explícitos que recebem Index e Range.
  • O padrão implícito: uma propriedade Count/Length mais Slice(int, int).
  • GetOffset(Length) e GetOffsetAndLength(Length) resolvem posições a partir do fim.

Perguntas Frequentes

A aula “Tipos personalizados compatíveis com intervalos” é grátis?

Sim — o texto completo de “Tipos personalizados compatíveis com intervalos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Tipos personalizados compatíveis com intervalos”?

Adicione suporte a Index e Range aos seus tipos. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Tipos personalizados compatíveis com intervalos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. O tipo Index e o operador ^
  2. O tipo Range e o operador ..
  3. Intervalos com matrizes e strings
  4. Tipos personalizados compatíveis com intervalos
← Voltar para C# Academy