Usando propriedades (guia de programação translation from VPE for Csharp)

Artigo
08/25/2010

Propriedades combinam aspectos de campos e métodos.Para o usuário de um objeto, uma propriedade parece ser um campo, acessando a propriedade requer a mesma sintaxe.Para o implementador de uma classe, uma propriedade é um ou dois blocos de código, que representa um obter acessador e/ou um conjunto acessador.O bloco de código para o get o acessador é executado quando a propriedade é leitura; bloqueie o código para o set o acessador é executado quando um novo valor é atribuído à propriedade. Uma propriedade sem um set o acessador é considerado somente leitura. Uma propriedade sem um get o acessador é considerado somente gravar. Uma propriedade que tenha ambos os acessadores é de leitura-gravar.

Diferentemente dos campos, propriedades não são classificadas sistema autônomo variáveis.Portanto, você não pode passar uma propriedade sistema autônomo um REF (translation from VPE for Csharp Reference) ou check-out (translation from VPE for Csharp Reference) parâmetro.

Propriedades têm muitos usos: Eles podem validar dados antes de permitir que uma alteração; modo transparente, eles podem expor dados em uma classe onde esses dados está realmente recuperados de outra fonte, sistema autônomo um banco de dados; eles podem executar uma ação quando sistema autônomo dados são alterados, sistema autônomo disparar um evento ou alterar o valor de outros campos.

Propriedades são declaradas no bloco de classe, especificando o nível de acesso do campo, seguido do tipo da propriedade, seguido do nome da propriedade e seguido por um bloco de código declara um get-acessador e/ou um set acessador. Por exemplo:

public class Date
{
    private int month = 7;  // Backing store

    public int Month
    {
        get
        {
            return month;
        }
        set
        {
            if ((value > 0) && (value < 13))
            {
                month = value;
            }
        }
    }
}

Neste exemplo, Month é declarada sistema autônomo uma propriedade assim que o set acessador pode certificar-se de que o Month valor é definido entre 1 e 12. The Month propriedade usa um particular campo para controlar o valor real. A localização real dos dados da propriedade é normalmente conhecida sistema autônomo "repositório de backup da propriedade." É comum para sistema autônomo propriedades usar particular campos sistema autônomo um repositório de backup.O campo é marcado como particular para garantir que ele só pode ser alterado chamando a propriedade.Para obter mais informações sobre restrições de acesso público e particular, consulte Modificadores de acesso (guia de programação C#).

Propriedades implementadas automaticamente fornecem sintaxe simplificada para declarações de propriedade simples.Para obter mais informações, consulte Propriedades implementado automática (guia de programação translation from VPE for Csharp).

Get acessador

O corpo do get o acessador é semelhante a que um método. Ele deve retornar um valor do tipo de propriedade.A execução do get o acessador é equivalente ao ler o valor do campo. Por exemplo, quando você estiver retornando variável particular do get acessador e otimizações estiverem ativadas, a telefonar para o get método do acessador é embutido pelo compilador, portanto não há nenhuma sobrecarga de telefonar de método. No entanto, um virtual get método do acessador não pode ser embutido porque o compilador não sabe em qual método, na verdade, pode ser chamado em time de execução do time de compilar. Este é um get acessador retorna o valor de um campo privado name:

class Person
{
    private string name;  // the name field
    public string Name    // the Name property
    {
        get
        {
            return name;
        }
    }
}

Quando você faz referência a propriedade, exceto quando o destino de uma atribuição, o get o acessador é chamado para ler o valor da propriedade. Por exemplo:

Person person = new Person();
//...

System.Console.Write(person.Name);  // the get accessor is invoked here

The get acessador deve terminar em um retornar or throw demonstrativo e controle não podem fluir fora do corpo do acessador.

For um estilo de programação incorreto para alterar o estado do objeto, usando o get acessador. Por exemplo, o acessador seguir produz o efeito colateral de alterar o estado do objeto sempre que o number campo é acessado.

private int number;
public int Number
{
    get
    {
        return number++;   // Don't do this
    }
}

The get acessador pode ser usado para retornar o valor do campo ou para computá-lo e retorná-lo. Por exemplo:

class Employee
{
    private string name;
    public string Name
    {
        get
        {
            return name != null ? name : "NA";
        }
    }
}

No segmento de código anterior, se você não atribuir um valor de Name propriedade, ela retornará o valor de ND.

O conjunto de acesso

The set um método cujo tipo de retorno é semelhante ao acessador void.Ele usa um parâmetro implícito chamado value, cujo tipo é o tipo da propriedade. No exemplo a seguir, um set o acessador é adicionado à Name propriedade:

class Person
{
    private string name;  // the name field
    public string Name    // the Name property
    {
        get
        {
            return name;
        }
        set
        {
            name = value;
        }
    }
}

Quando você atribuir um valor à propriedade, a set o acessador é chamado usando um argumento que fornece o novo valor. Por exemplo:

Person person = new Person();
person.Name = "Joe";  // the set accessor is invoked here                

System.Console.Write(person.Name);  // the get accessor is invoked here

É um erro para usar o nome do parâmetro implícito, value, uma declaração de variável local em um set acessador.

Comentários

Propriedades podem ser marcadas sistema autônomo public, private, protected, internal, ou protected internal. Esses modificadores de acesso definem como os usuários da classe podem acessar a propriedade.The get e set acessadores para a mesma propriedade podem ter modificadores de acesso diferentes. Por exemplo, a get pode ser public para permitir somente-leitura acesso de fora o tipo e o set pode ser private ou protected. Para obter mais informações, consulte Modificadores de acesso (guia de programação C#).

Uma propriedade pode ser declarada sistema autônomo um estático propriedade usando o static palavra-chave. Isso torna a propriedade disponível para chamadores a qualquer momento, mesmo se nenhum instância da classe existe.Para obter mais informações, consulte Classes estáticas e membros de classe estáticos (guia de programação C#).

Uma propriedade pode ser marcada sistema autônomo uma propriedade virtual usando o virtual palavra-chave.Isso permite que as classes derivadas substituir o comportamento da propriedade usando o Substituir palavra-chave.Para obter mais informações sobre essas opções, consulte Herança (Guia de programação C#).

Uma propriedade substituindo uma propriedade virtual também pode ser selado, especificando que para classes derivadas não é mais virtual.Por fim, uma propriedade pode ser declarada Resumo.Isso significa que não há nenhuma implementação na classe e as classes derivadas devem escrever sua própria implementação.Para obter mais informações sobre essas opções, consulte Abstrato e Sealed classes e membros de classe (guia de programação C#).

Observação:
É um erro usar uma (referência C#) virtual, abstract (referência C#) , ou Substituir (referência C#) modificador em um acessador de um estáticopropriedade .

Exemplo

Este exemplo demonstra as propriedades da ocorrência, estática e somente leitura.Ele aceita o nome do funcionário do teclado, incrementa NumberOfEmployees 1 e exibe o funcionário, nome e número.

public class Employee
{
    public static int NumberOfEmployees;
    private static int counter;
    private string name;

    // A read-write instance property:
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    // A read-only static property:
    public static int Counter
    {
        get { return counter; }
    }

    // A Constructor:
    public Employee()
    {
        // Calculate the employee's number:
        counter = ++counter + NumberOfEmployees;
    }
}

class TestEmployee
{
    static void Main()
    {
        Employee.NumberOfEmployees = 107;
        Employee e1 = new Employee();
        e1.Name = "Claude Vige";

        System.Console.WriteLine("Employee number: {0}", Employee.Counter);
        System.Console.WriteLine("Employee name: {0}", e1.Name);
    }
}
/* Output:
    Employee number: 108
    Employee name: Claude Vige
*/

Este exemplo demonstra como acesso uma propriedade em uma classe base que está oculta pela outra propriedade que tem o mesmo nome em uma classe derivada.

public class Employee
{
    private string name;
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

public class Manager : Employee
{
    private string name;

    // Notice the use of the new modifier:
    public new string Name
    {
        get { return name; }
        set { name = value + ", Manager"; }
    }
}

class TestHiding
{
    static void Main()
    {
        Manager m1 = new Manager();

        // Derived class property.
        m1.Name = "John";

        // Base class property.
        ((Employee)m1).Name = "Mary";

        System.Console.WriteLine("Name in the derived class is: {0}", m1.Name);
        System.Console.WriteLine("Name in the base class is: {0}", ((Employee)m1).Name);
    }
}
/* Output:
    Name in the derived class is: John, Manager
    Name in the base class is: Mary
*/

Pontos importantes no exemplo anterior são:

A propriedade Name na classe derivada oculta a propriedade Name na classe base. Nesse caso, a new modificador é usado na declaração da propriedade na classe derivada:
```
public new string Name
```
O efeito de (Employee) é usado para acessar a propriedade oculta na classe base:
```
((Employee)m1).Name = "Mary";
```
Para obter mais informações sobre como ocultar membros, consulte o novo modificador (translation from VPE for Csharp Reference).

Nesse exemplo, duas classes, Cube e Square, implementar uma classe abstrata, Shapee substituir seu resumo Area propriedade. Observe o uso do Substituir modificador em Propriedades.O programa aceita o lado sistema autônomo entrada e calcula sistema autônomo áreas para o quadrado e o cubo.Além disso, aceita a área sistema autônomo entrada e calcula o lado correspondente para o quadrado e o cubo.

abstract class Shape
{
    public abstract double Area
    {
        get;
        set;
    }
}

class Square : Shape
{
    public double side;

    public Square(double s)  //constructor
    {
        side = s;
    }

    public override double Area
    {
        get
        {
            return side * side;
        }
        set
        {
            side = System.Math.Sqrt(value);
        }
    }
}

class Cube : Shape
{
    public double side;

    public Cube(double s)
    {
        side = s;
    }

    public override double Area
    {
        get
        {
            return 6 * side * side;
        }
        set
        {
            side = System.Math.Sqrt(value / 6);
        }
    }
}

class TestShapes
{
    static void Main()
    {
        // Input the side:
        System.Console.Write("Enter the side: ");
        double side = double.Parse(System.Console.ReadLine());

        // Compute the areas:
        Square s = new Square(side);
        Cube c = new Cube(side);

        // Display the results:
        System.Console.WriteLine("Area of the square = {0:F2}", s.Area);
        System.Console.WriteLine("Area of the cube = {0:F2}", c.Area);
        System.Console.WriteLine();

        // Input the area:
        System.Console.Write("Enter the area: ");
        double area = double.Parse(System.Console.ReadLine());

        // Compute the sides:
        s.Area = area;
        c.Area = area;

        // Display the results:
        System.Console.WriteLine("Side of the square = {0:F2}", s.side);
        System.Console.WriteLine("Side of the cube = {0:F2}", c.side);
    }
}
/* Example Output:
    Enter the side: 4
    Area of the square = 16.00
    Area of the cube = 96.00

    Enter the area: 24
    Side of the square = 4.90
    Side of the cube = 2.00
*/

Consulte também

Partilhar via

Usando propriedades (guia de programação translation from VPE for Csharp)

Get acessador

O conjunto de acesso

Comentários

Exemplo

Consulte também

Tarefas

Conceitos

Referência

Recursos adicionais