Como usar C# set e get

-
Como usar C# set e get
A linguagem C# tem duas funções - uma função de atribuição (get) e uma função de valor (set), que pode ser vista claramente no código da linguagem intermediária que ela gera. C# não defende definir o nível de proteção do domínio como público e permitir que os usuários operem arbitrariamente fora da classe - isso é muito unOO ou, para ser mais específico, muito inseguro! Para todos os campos que precisam estar visíveis fora da classe, o C# recomenda o uso de atributos para expressá-los. Os atributos não representam locais de armazenamento, que é a diferença fundamental entre atributos e domínios. A seguir está um design de atributo típico:

usando o sistema;
classeMinhaClasse
{
inteiro inteiro;
público int inteiro
{
obter {retornar número inteiro;}
definir {inteiro=valor;}
}
}

teste de classe
{
público estático vazio Principal()
{
MinhaClasse MeuObjeto=new MinhaClasse();
Console.Write(MeuObjeto.Integer);
MeuObjeto.Integer++;
Console.Write(MeuObjeto.Integer);
}
}

Como esperado, o programa gera 0 1. Podemos ver que os atributos fornecem aos programadores uma interface de acesso amigável aos membros do domínio por meio do agrupamento de métodos. O valor aqui é a palavra-chave do C#, que é o parâmetro implícito de set quando realizamos operações de atributos, ou seja, o rvalue quando realizamos operações de gravação de atributos.

Os atributos fornecem três operações de interface: somente leitura (get), somente gravação (set) e leitura-gravação (get e set). Estas três operações no domínio devem ser declaradas sob o mesmo nome de atributo e não podem ser separadas. Veja a seguinte implementação:

classeMinhaClasse
{
nome da string privada;

nome da string pública
{
obter { nome de retorno }
}
nome da string pública
{
definir {nome = valor};
}
}

O método acima de separar a implementação do atributo Name está errado! Devemos colocá-los juntos como no exemplo anterior. Vale ressaltar que as três propriedades (somente leitura, somente gravação, leitura-gravação) são consideradas o mesmo nome de propriedade pelo C#, veja o exemplo a seguir:

classeMinhaClasse
{
protegido int num=0;
número interno público
{
definir
{
num=valor;
}
}
}
classe MinhaClassDerivado: MinhaClasse
{
novo público int Num
{
pegar
{
retornar num;
}
}
}

teste de classe
{
público estático vazio Principal()
{
MyClassDerived MyObject = new MyClassDerived();
//MeuObjeto.Num= 1; //Erro!
((MinhaClasse)MeuObjeto).Num = 1;
}
}

Podemos ver que o atributo Num-get{} em MyClassDerived bloqueia a definição do atributo Num-set{} em MyClass.

É claro que os atributos são muito mais do que apenas operações de interface de domínio. A essência dos atributos ainda são métodos. Veja o exemplo a seguir:

classeMinhaClasse
{
nome da string privada;
nome da string pública
{
obter { nome de retorno }
definir
{
if (valor==nulo)
nome="Microsoft";
outro
nome=valor;
}
}
}

Devido à natureza do método dos atributos, é claro que os atributos também possuem várias modificações de métodos. Os atributos também possuem 5 modificadores de acesso, mas os modificadores de acesso dos atributos geralmente são públicos, caso contrário perderemos o significado dos atributos como interfaces públicas de classes. Além da falta de atributos de recurso, como sobrecarga de método trazida por vários parâmetros do método, modificadores como virtual, selado, substituição e abstrato têm o mesmo comportamento para atributos e métodos, porque os atributos são essencialmente implementados como dois métodos. , Certos comportamentos requerem nossa atenção. Veja o exemplo a seguir:

classe abstrata A
{
interno;
público virtual int X
{
obter {retorno 0;
}
público virtual int Y
{
obter { retornar y }
definir {y = valor};
}
público abstrato int Z { obter;
}
classe B: A
{
intz;
substituição pública int X
{
obter {retornar base.X + 1};
}
substituição pública int Y
{
definir { base.Y = valor < 0: valor };
}
substituição pública int Z
{
obter { retornar z }
definir {z = valor};
}
}

Este exemplo destaca alguns comportamentos típicos de propriedades no contexto de herança. Aqui, a classe A deve ser declarada abstrata devido à existência do atributo abstrato Z. A subclasse B refere-se aos atributos da classe pai A por meio da palavra-chave base. A classe B pode substituir os atributos virtuais da classe A somente por meio do conjunto Y.

Propriedades estáticas, assim como métodos estáticos, só podem acessar variáveis ​​de domínio estáticas da classe. Também podemos declarar propriedades externas da mesma forma que fazemos com métodos externos.