Propriedades automáticas do C # 3.0 - útil ou não? [fechadas]

Nota: Isso foi publicado quando eu estava iniciando o C #. Com o conhecimento de 2014, posso realmente dizer que as propriedades automáticas estão entre as melhores coisas que já aconteceram na linguagem C #.

Estou acostumado a criar minhas propriedades em C # usando um campo privado e público:

private string title;
public string Title
{
    get { return title;  }
    set { title = value;  }
}

Agora, com o .NET 3.0, obtivemos propriedades automáticas:

public string Title { get; set; }

Eu sei que isso é mais uma questão filosófica / subjetiva, mas há alguma razão para usar essas propriedades automáticas, exceto ao salvar cinco linhas de código para cada campo? Minha queixa pessoal é que essas propriedades estão escondendo coisas de mim, e eu não sou um grande fã de magia negra.

De fato, o campo privado oculto nem aparece no depurador, o que é bom, pois as funções get / set não fazem nada. Mas quando eu quero realmente implementar alguma lógica getter / setter, tenho que usar o par privado / público de qualquer maneira.

Vejo o benefício de salvar muito código (um vs seis linhas) sem perder a capacidade de alterar a lógica do getter / setter posteriormente, mas, novamente, já posso fazer isso simplesmente declarando um campo público "Public string Title" sem a necessidade do {get; conjunto; }, economizando ainda mais código.

Então, o que estou perdendo aqui? Por que alguém realmente deseja usar propriedades automáticas?

Nós os usamos o tempo todo no Stack Overflow.

Você também pode estar interessado em uma discussão sobre Propriedades x Variáveis ​​Públicas . IMHO, é realmente para isso que é uma reação e, para esse propósito, é ótimo.

Sim, apenas salva o código. É muito mais fácil ler milhas quando você as carrega. Eles são mais rápidos de escrever e mais fáceis de manter. Salvar código é sempre uma boa meta.

Você pode definir diferentes escopos:

public string PropertyName { get; private set; }

Para que a propriedade só possa ser alterada dentro da classe. Isso não é realmente imutável, pois você ainda pode acessar o setter privado por meio de reflexão.

A partir do C # 6, você também pode criar readonlypropriedades verdadeiras - ou seja, propriedades imutáveis ​​que não podem ser alteradas fora do construtor:

public string PropertyName { get; }

public MyClass() { this.PropertyName = "whatever"; }

Em tempo de compilação que se tornará:

readonly string pName;
public string PropertyName { get { return this.pName; } }

public MyClass() { this.pName = "whatever"; }

Em classes imutáveis ​​com muitos membros, isso economiza muito código em excesso.

As três grandes desvantagens do uso de campos em vez de propriedades são:

1. Você não pode conectar-se a um campo enquanto pode a uma propriedade
2. Se você começar a usar um campo, não poderá alterá-los mais tarde (facilmente) para uma propriedade
3. Existem alguns atributos que você pode adicionar a uma propriedade que não pode adicionar a um campo

Eu, pessoalmente, adoro propriedades automáticas. O que há de errado em salvar as linhas de código? Se você deseja fazer coisas em getters ou setters, não há problema em convertê-los em propriedades normais posteriormente.

Como você disse, você pode usar campos e, se desejar adicionar lógica a eles posteriormente, os converterá em propriedades. Mas isso pode apresentar problemas com qualquer uso de reflexão (e possivelmente em outro lugar?).

Além disso, as propriedades permitem definir níveis de acesso diferentes para o getter e o setter, o que você não pode fazer com um campo.

Eu acho que é o mesmo que a palavra-chave var. Uma questão de preferência pessoal.

De Bjarne Stroustrup, criador de C ++:

Eu particularmente não gosto de aulas com muitas funções get e set. Isso geralmente indica que não deveria ter sido uma aula em primeiro lugar. É apenas uma estrutura de dados. E se realmente é uma estrutura de dados, torne-a uma estrutura de dados.

E sabe de uma coisa? Ele tem razão. Quantas vezes você está simplesmente agrupando campos privados em um get e set, sem fazer nada dentro do get / set, simplesmente porque é a coisa "orientada a objetos" a ser feita. Esta é a solução da Microsoft para o problema; eles são basicamente campos públicos aos quais você pode se associar.

Uma coisa que ninguém parece ter mencionado é como infelizmente as propriedades automáticas não são úteis para objetos imutáveis ​​(geralmente estruturas imutáveis). Porque para isso você realmente deve fazer:

private readonly string title;
public string Title
{
    get { return this.title; }
}

(onde o campo é inicializado no construtor por meio de um parâmetro passado e, em seguida, é somente leitura.)

Portanto, isso tem vantagens sobre uma propriedade simples get/ private setautomática.

Eu sempre crio propriedades em vez de campos públicos porque você pode usar propriedades em uma definição de interface, não pode usar campos públicos em uma definição de interface.

As propriedades automáticas são tanto uma magia negra quanto qualquer outra coisa em C #. Quando você pensa sobre isso em termos de compilação para IL, em vez de ser expandido para uma propriedade C # normal primeiro, é muito menos magia negra do que muitas outras construções de linguagem.

Eu uso propriedades automáticas o tempo todo. Antes do C # 3, eu não podia me incomodar com toda a digitação e apenas usava variáveis ​​públicas.

A única coisa que sinto falta é poder fazer isso:

public string Name = "DefaultName";

Você precisa mudar os padrões para seus construtores com propriedades. tedioso :-(

Eu acho que qualquer construção que seja intuitiva e reduza as linhas de código é uma grande vantagem.

Esses tipos de recursos são o que torna linguagens como Ruby tão poderosas (recursos dinâmicos e que também ajudam a reduzir o excesso de código).

Ruby sempre teve isso como:

attr_accessor :my_property
attr_reader :my_getter
attr_writer :my_setter

O único problema que tenho com eles é que eles não vão longe o suficiente. A mesma versão do compilador que adicionou propriedades automáticas, adicionou métodos parciais. Por que eles não juntaram os dois está além de mim. Um simples "parcial em <PropertyName> Changed" tornaria essas coisas realmente muito úteis.

É simples, é curto e se você deseja criar uma implementação real dentro do corpo da propriedade em algum lugar abaixo da linha, isso não interromperá a interface externa do seu tipo.

Tão simples como isso.

Uma coisa a observar aqui é que, no meu entender, isso é apenas um açúcar sintático no final do C # 3.0, o que significa que a IL gerada pelo compilador é a mesma. Concordo em evitar a magia negra, mas, mesmo assim, menos linhas para a mesma coisa geralmente são boas.

Na minha opinião, você sempre deve usar propriedades automáticas em vez de campos públicos. Dito isto, aqui está um compromisso:

Comece com um campo interno usando a convenção de nomenclatura que você usaria para uma propriedade. Quando você quer

• precisa acessar o campo de fora de sua montagem ou
• precisa anexar lógica a um getter / setter

Faça isso:

1. renomeie o campo
2. torná-lo privado
3. adicionar uma propriedade pública

O código do seu cliente não precisará ser alterado.

Algum dia, porém, seu sistema crescerá e você o decomporá em montagens separadas e várias soluções. Quando isso acontece, todos os campos expostos voltarão para assombrá-lo porque, como Jeff mencionou, alterar um campo público para uma propriedade pública é uma alteração de API de quebra .

Eu uso o CodeRush, é mais rápido que as propriedades automáticas.

Para fazer isso:

 private string title;
public string Title
{
    get { return title;  }
    set { title = value;  }
}

Requer oito pressionamentos de tecla no total.

Bem, com trechos de código, uma propriedade automática com o mesmo nome seria sete teclas no total;)

@Domenic: Eu não entendi .. você não pode fazer isso com propriedades automáticas ?:

public string Title { get; }

ou

public string Title { get; private set; }

É isso que você está se referindo?

Minha maior preocupação com as propriedades automáticas é que elas são projetadas para economizar tempo, mas muitas vezes acho que preciso expandi-las para as propriedades completas posteriormente.

O que falta ao VS2008 é um refator de propriedade automática de explosão.

O fato de termos um refator de campo encapsulado faz com que eu trabalhe mais rápido para usar apenas campos públicos.