10 Dicas para aumentar sua produtividade com C#
Autor: Anderson Silva Garcia | Publicado: 2011-11-02T02:59:00-07:00

Junta uma dica daqui, outra dali, e voilá, seguem 10 dicas para aumentar sua produtividade enquanto programa usando a linguagem C#. Obviamente não estou falando de atalhos, que também são muito úteis, mas apenas de práticas muitas vezes pouco conhecidas para aumento de produtividade, redução de código e por aí vai. Muitas só funcionam a partir do Framework 3.5, mas acredito que nesta altura do campeonato ninguém deveria estar programando em 2.0 ou frameworks inferiores…

1. Operador Ternário ‘?’
Use-o com moderação ou ele prejudicará a legibilidade de seu código. Basicamente o operador ternário substitui um bloco if tradicional em uma única linha de código. Novidade? NOT! Operadores ternários existem na linguagem C desde a década de 70. Na prática funciona assim, imagine o seguinte bloco de código:
int x = 10;
int y = 20;
int max;
if(x &gt; y)
max = x;
else
max = y; 
Você pode substituí-lo usando o operador ternário que funciona da seguinte forma (Questão) ? (Ação Positiva) : (Ação Negativa). Vamos ver o exemplo anterior usando operador ternário:
int x = 10;
int y = 20;
int max = (x &gt; y) ? x : y; 

2. Operador Null-coalesce ‘??’
Quantas vezes você tem de testar se objetos são nulos em seu código? O operador null-coalesce pode vir a ser útil a você então. Considere o seguinte código:
object cache = null;
object d = new object();
object e = (c != null) ? c : d; 
Obviamente poderíamos reescrever usando o operador ternário:
object cache = null;
object d = new object();
object e = (c != null) ? c : d; 
Porém, usando o operador null-coalesce, conseguimos encurtar ainda mais o código (se o objeto do lado esquerdo é null, então ele retornará o valor do lado direito):
object cache = null;
object d = new object();
object e = c ?? d; 

3. Inicializadores de Objetos
Cansado de perder várias linhas de código para ficar setando valores de propriedades? Ou então cansado de ficar escrevendo dezenas de sobrecargas de construtores? Os construtores auto-implementados que surgiram na versão 3.0 do C# resolvem seu problema e de quebra ainda melhoram a legibilidade de seu código. Primeiro vamos ver o jeito tradicional de inicializar um objeto:
Cliente c = new Cliente();
c.Nome = “João”;
c.Endereco = “Rua Lima 204″; 
E agora usando os inicializadores de objeto:
Cliente c = new Cliente { Nome=”João”, Endereco = “Rua Lima 204″ }; 

4. A diretiva ‘using’
Uma vez que você precisa alocar um objeto em memória um pouco mais pesado que o normal, como streams e arquivos de mídia, é importante que seja feito um controle mais rigoroso na hora de liberar a memória novamente, evitando problemas futuros. Ou seja, sempre temos de fazer três etapas: criamos o objeto, usamos ele e o descartamos. Isso pode ser ilustrado com o trecho de código abaixo:
// 1. Alocando o objeto
Font font1 = new Font(“Arial”, 10.0f);
try
{
// 2. Usando o recurso
}
finally
{
// 3.Descartando o objeto
if (font1 != null)
((IDisposable)font1).Dispose();
} 
A diretiva using permite comprimir o código anterior em:
// alocando o recurso
using (Font font1 = new Font(“Arial”, 10.0f))
{
// Usando o recurso
}  
// Descarte automático 
A diretiva using somente pode ser utilizada em objetos que implementem a interface IDisposable.

5. Apelidos para nomes de classes e namespaces muito grandes
Nomes em C# podem se tornar muito longos. Se você está desenvolvendo algo para Microsoft Office, pode estar querendo abrir um processo do Word para criar um documento, o que cria objetos com namespaces enormes. O código abaixo, usando a diretiva using para criar um apelido de namespace ilustra outro uso deste canivete suíço da programação C#:
using Word = Microsoft.Office.Interop.Word;
…
Word.Application = new Word.Application() { Visible = True; } 

6. Objetos Nullables
Algumas vezes é necessário que suas variáveis possam conter valores nulos, mesmo quando é um simples inteiro. Isto ocorre com mais frequência quanto trabalhos com mapeamento objeto-relacional, pois na maioria dos bancos de dados sempre teremos tabelas com colunas que podem conter valores nulos. Para tornar um variável comum em uma variável que aceita null, basta adicionar um ‘?’ ao final do tipo e pronto!
Nullable x = null;
int? x = null; 
Os nullable-types surgiram na versão 2.0 do framework e podem ser invocados das duas formas exibidas anteriormente.

7. Propriedades Automáticas
No C# 3.0 ganhamos as propriedades automáticas. Geralmente a maioria das propriedades das classes são apenas exposições de atributos privados ao restante do sistema. Dificilmente elas possuem alguma lógica ou verificação que realmente exija a criação de um atributo privado e de uma propriedade pública. Desta forma, para que ficar repetindo gets e sets sempre iguais, retornando o valor de um atributo privado? Desta forma, as propriedades automáticas vieram para agilizar a tarefa de criação de propriedades que nada mais fazem do que retornar ou receber valores. Vale salientar que em tempo de compilação vão ser gerados atributos privados para onde os valores dessas propriedades ficarão armazenados. Ous eja, não muda nada para o sistema, apenas para o programador.
public class Pessoa
{
private string _primeiroNome;
public string PrimeiroNome
{
get { return _primeiroNome; }
set { _primeiroNome= value; }
}
} 
O bloco de código anterior mostra o jeito antigo de fazer as coisas. O bloco seguinte mostra as propriedades automáticas:
public class Pessoa
{
public string PrimeiroNome { get; set; }
} 
Para quem acha que criar propriedades automáticas públicas é a mesma coisa que criar atributos públicos, está redondamente enganado. O método DataBind presente na maioria dos controles de exibição de dados somente efetua o Bind sobre propriedades públicas e nunca sobre atributos de classe. Desta forma, se pretende que sua classe possa ser exibida em controles deste tipo, é bom usar as propriedades corretamente.

8. Inferência de Tipos
Esta é outra dica que deve ser usada com cuidado. Eu particularmente uso apenas quando estou trabalhando com namespaces desconhecidos ou com LINQ e Lambda Expressions. Sendo o C# uma linguagem fortemente tipada, é natural que aja toda uma preocupação com escolher o melhor tipo para as variáveis e objetos que serão utilizadas. Da mesma forma, é importante conhecer os diversos tipos existentes quando se está manipulando métodos de terceiros. A inferência de tipos permite que você deixe de escrever o tradicional código:
string MyString = “Hello World”; 
Desta forma:
var MyString = “Hello World”; 
Peraí, igual no Javascript? NOT! Mesmo com a inferência de tipos C# ainda é uma linguagem fortemente tipada e uma vez que a inferência esteja concluída (i.e. a variável recebeu um valor) o tipo de seu conteúdo jamais poderá ser alterado. Novamente, isto é apenas a nível de programação. Quando o compilador entra em ação, ele atribui os tipos corretos conforme a necessidade, nos poupando do trabalho de decorar os mais variados tipos e retornos de chamadas de métodos. O objeto do tipo inferido pode perfeitamente ser utilizado como um objeto normal, como o código a seguir nos mostra:
var elencoSenior = Empregados.Where(s =&gt; s.Idade &gt; 35);
foreach(var membro in elencoSenior)
Console.WriteLine(“Nome: {0} Idade: {1}”,membro.Nome, membro.Idade); 
Mas então, qual o tipo de elencoSenior? ((System.Linq.Enumerable.Iterator&lt;f__AnonymousType0&gt;)(SeniorStaff))
Bizarro não? Já imaginou ter de trabalhar com este tipo maluco? Muito mais fácil com inferência de tipos.

9. Expressões Lambda
Expressões Lambda são expressões de consulta feitas sobre coleções de dados de forma extremamente otimizada e simples, criando um poderosa ferramenta de produtividade. Por exemplo, se tivéssemos uma lista de 30 funcionários e quiséssemos saber todos os funcionários que possuem mais de 35 anos? Tradicionalmente teríamos de fazer um laço para percorrer todos os elementos dalista comparando a idade de cada elemento e adicionandoos em uma outra fila à medida em que forem encontrados os funcionários mais velhos. Com Lambda, tal tarefa se restringe somente a:
var elencoSenior = Empregados.Where(s =&gt; s.Idade &gt; 35); 

10. string.IsNullOrEmpty()
Não necessariamente uma feature da linguagem, mas um método estático muito útil da classe string. Me impressiono como existem pessoas que não conhecem esta poderosa ferramenta para testar se strings estão nulas (null) ou vazias (“”). Segue exemplo de código;
if (String.IsNullOrEmpty(s) == true)
return “é nula ou vazia”;
else
return String.Format(“(\”{0}\”) é nula ou vazia.”, s); 

Fonte: http://www.luiztools.com/post/10-Dicas-para-aumentar-sua-produtividade-com-C.aspx