Isso veio à minha mente depois que aprendi o seguinte com esta pergunta :

where T : struct

Nós, desenvolvedores de C #, todos sabemos o básico de C #. Refiro-me a declarações, condicionais, loops, operadores, etc.

Alguns de nós até dominam coisas como Genéricos , tipos anônimos , lambdas , LINQ , ...

Mas quais são os recursos ou truques mais ocultos do C # que mesmo os fãs, viciados e especialistas em C # mal conhecem?

Aqui estão os recursos revelados até agora:

Palavras-chave

• yieldpor Michael Stum
• varpor Michael Stum
• using()declaração de kokos
• readonlypor kokos
• aspor Mike Stone
• as/ isPor Ed Swangren
• as/ is(melhorado) por Rocketpants
• defaultpor deathofrats
• global::por pzycoman
• using()Blocos por AlexCuse
• volatilepor Jakub Šturc
• extern aliaspor Jakub Šturc

Atributos

• DefaultValueAttributepor Michael Stum
• ObsoleteAttributepor DannySmurf
• DebuggerDisplayAttributepor Stu
• DebuggerBrowsablee DebuggerStepThroughpor bdukes
• ThreadStaticAttributepor marxidad
• FlagsAttributepor Martin Clarke
• ConditionalAttributepor AndrewBurns

Sintaxe

• ??(coalesce nulls) operator por kokos
• Bandeiras de número por Nick Berardi
• where T:newpor Lars Mæhlum
• Genéricos implícitos de Keith
• Lambdas de um parâmetro por Keith
• Auto propriedades por Keith
• Alias ​​de namespace de Keith
• Literais de string verbais com @ by Patrick
• enumvalores por lfoust
• @variablenames por marxidad
• eventoperadores por marxidad
• Formatar colchetes por Portman
• Modificadores de acessibilidade de acessador de propriedade por xanadont
• Operador condicional (ternário) ( ?:) por JasonS
• checkede uncheckedoperadores por Binoj Antony
• implicit and explicitoperadores de Flory

Características da linguagem

• Tipos anuláveis ​​por Brad Barker
• Tipos anônimos por Keith
• __makeref __reftype __refvaluepor Judah Himango
• Inicializadores de objeto por lomaxx
• Formate strings de David em Dakota
• Métodos de extensão por marxidad
• partialmétodos de Jon Erickson
• Diretivas de pré-processador de John Asbeck
• DEBUGdiretiva pré-processador de Robert Durgin
• Sobrecarga de operador por SefBkn
• Digite dedução por chakrit
• Operadores booleanos levados ao próximo nível por Rob Gough
• Passe a variável do tipo valor como interface sem boxe por Roman Boiko
• Determinar programaticamente o tipo de variável declarada por Roman Boiko
• Construtores estáticos de Chris
• Mapeamento ORM mais fácil nos olhos / condensado usando LINQ da roosteronacid
• __arglistpor Zac Bowling

Recursos do Visual Studio

• Selecionar bloco de texto no editor por Himadri
• Snippets por DannySmurf

Estrutura

• TransactionScopepor KiwiBastard
• DependantTransactionpor KiwiBastard
• Nullable<T>por IainMH
• Mutexpor Diago
• System.IO.Pathpor ageektrapped
• WeakReferencede Juan Manuel

Métodos e propriedades

• String.IsNullOrEmpty()método por KiwiBastard
• List.ForEach()método por KiwiBastard
• BeginInvoke(), EndInvoke()métodos por Will Dean
• Nullable<T>.HasValuee Nullable<T>.Valuepropriedades por Rismo
• GetValueOrDefaultmétodo de John Sheehan

dicas e truques

• Bom método para manipuladores de eventos por Andreas HR Nilsson
• Comparações em maiúsculas de John
• Acesse tipos anônimos sem reflexão por dp
• Uma maneira rápida de instanciar preguiçosamente as propriedades de coleção de Will
• Funções inline anônimas do tipo JavaScript por roosteronacid

De outros

• netmodules por kokos
• LINQBridge por Duncan Smart
• Extensões paralelas por Joel Coehoorn

Isso não é C # por si só, mas não vi ninguém que realmente use System.IO.Path.Combine()na medida em que deveria. De fato, toda a classe Path é realmente útil, mas ninguém a usa!

Estou disposto a apostar que todo aplicativo de produção tem o seguinte código, mesmo que não deva:

string path = dir + "\\" + fileName;

lambdas e inferência de tipo são subestimadas. Os lambdas podem ter várias instruções e dobram como um objeto delegado compatível automaticamente (apenas verifique se a assinatura corresponde) como em:

Console.CancelKeyPress +=
    (sender, e) => {
        Console.WriteLine("CTRL+C detected!\n");
        e.Cancel = true;
    };

Observe que eu não tenho new CancellationEventHandlernem preciso especificar tipos de sendere e, eles são inferíveis a partir do evento. É por isso que isso é menos complicado para escrever o todo, o delegate (blah blah)que também exige que você especifique tipos de parâmetros.

Os lambdas não precisam retornar nada e a inferência de tipo é extremamente poderosa em um contexto como este.

E, BTW, você sempre pode retornar Lambdas que fazem Lambdas no sentido de programação funcional. Por exemplo, aqui está uma lambda que cria uma lambda que lida com um evento Button.Click:

Func<int, int, EventHandler> makeHandler =
    (dx, dy) => (sender, e) => {
        var btn = (Button) sender;
        btn.Top += dy;
        btn.Left += dx;
    };

btnUp.Click += makeHandler(0, -1);
btnDown.Click += makeHandler(0, 1);
btnLeft.Click += makeHandler(-1, 0);
btnRight.Click += makeHandler(1, 0);

Observe o encadeamento: (dx, dy) => (sender, e) =>

Agora é por isso que estou feliz por ter participado da aula de programação funcional :-)

Além dos ponteiros em C, acho que é outra coisa fundamental que você deve aprender :-)

De Rick Strahl :

Você pode encadear o ?? operador para que você possa fazer várias comparações nulas.

string result = value1 ?? value2 ?? value3 ?? String.Empty;

Genéricos com alias:

using ASimpleName = Dictionary<string, Dictionary<string, List<string>>>;

Ele permite que você use ASimpleName, em vez de Dictionary<string, Dictionary<string, List<string>>>.

Use-o quando você usaria a mesma coisa grande e complexa genérica em muitos lugares.

Do CLR via C # :

Ao normalizar seqüências de caracteres, é altamente recomendável usar ToUpperInvariant em vez de ToLowerInvariant porque a Microsoft otimizou o código para realizar comparações em maiúsculas .

Lembro-me de uma vez em que meu colega de trabalho sempre mudava as cordas para maiúsculas antes de comparar. Eu sempre me perguntei por que ele faz isso porque sinto que é mais "natural" converter primeiro em minúsculas. Depois de ler o livro agora eu sei o porquê.

Meu truque favorito é usar o operador de coalescência nula e parênteses para instanciar automaticamente coleções para mim.

private IList<Foo> _foo;

public IList<Foo> ListOfFoo 
    { get { return _foo ?? (_foo = new List<Foo>()); } }

Evite verificar manipuladores de eventos nulos

Adicionar um representante vazio aos eventos na declaração, suprimindo a necessidade de sempre verificar se o evento é nulo antes de chamá-lo de impressionante. Exemplo:

public delegate void MyClickHandler(object sender, string myValue);
public event MyClickHandler Click = delegate {}; // add empty delegate!

Deixe você fazer isso

public void DoSomething()
{
    Click(this, "foo");
}

Em vez disso

public void DoSomething()
{
    // Unnecessary!
    MyClickHandler click = Click;
    if (click != null) // Unnecessary! 
    {
        click(this, "foo");
    }
}

Por favor, veja também esta discussão relacionada e esta postagem de Eric Lippert no blog sobre este tópico (e possíveis desvantagens).

Tudo o resto, além de

1) genéricos implícitos (por que apenas nos métodos e não nas classes?)

void GenericMethod<T>( T input ) { ... }

//Infer type, so
GenericMethod<int>(23); //You don't need the <>.
GenericMethod(23);      //Is enough.

2) lambdas simples com um parâmetro:

x => x.ToString() //simplify so many calls

3) tipos e inicializadores anônimos:

//Duck-typed: works with any .Add method.
var colours = new Dictionary<string, string> {
    { "red", "#ff0000" },
    { "green", "#00ff00" },
    { "blue", "#0000ff" }
};

int[] arrayOfInt = { 1, 2, 3, 4, 5 };

Outro:

4) As propriedades automáticas podem ter escopos diferentes:

public int MyId { get; private set; }

Obrigado @pzycoman por me lembrar:

5) Aliases de namespace (não que você precise dessa distinção específica):

using web = System.Web.UI.WebControls;
using win = System.Windows.Forms;

web::Control aWebControl = new web::Control();
win::Control aFormControl = new win::Control();

Eu não conhecia a palavra-chave "as" por um bom tempo.

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

O segundo retornará null se obj não for um MyClass, em vez de lançar uma exceção de conversão de classe.

Duas coisas de que gosto são as propriedades Automáticas, para que você possa reduzir ainda mais seu código:

private string _name;
public string Name
{
    get
    {
        return _name;
    }
    set
    {
        _name = value;
    }
}

torna-se

public string Name { get; set;}

Também inicializadores de objetos:

Employee emp = new Employee();
emp.Name = "John Smith";
emp.StartDate = DateTime.Now();

torna-se

Employee emp = new Employee {Name="John Smith", StartDate=DateTime.Now()}

A palavra-chave 'padrão' em tipos genéricos:

T t = default(T);

resulta em 'null' se T for um tipo de referência e 0 se for um int, false se for um booleano, etc.

Atributos em geral, mas acima de tudo DebuggerDisplay . Economiza anos.

O @ diz ao compilador para ignorar qualquer caractere de escape em uma string.

Só queria esclarecer este ... ele não diz para ignorar os caracteres de escape, na verdade, diz ao compilador para interpretar a string como um literal.

Se você tem

string s = @"cat
             dog
             fish"

ele realmente será impresso como (observe que ele inclui o espaço em branco usado para o recuo):

cat
             dog
             fish

Acho que um dos recursos mais subestimados e menos conhecidos do C # (.NET 3.5) são as Árvores de Expressão , especialmente quando combinadas com os Genéricos e Lambdas. Essa é uma abordagem para criação de API que bibliotecas mais recentes, como NInject e Moq, estão usando.

Por exemplo, digamos que eu quero registrar um método com uma API e que a API precise obter o nome do método

Dada esta classe:

public class MyClass
{
     public void SomeMethod() { /* Do Something */ }
}

Antes, era muito comum ver os desenvolvedores fazerem isso com strings e tipos (ou qualquer outra coisa amplamente baseada em strings):

RegisterMethod(typeof(MyClass), "SomeMethod");

Bem, isso é péssimo por causa da falta de digitação forte. E se eu renomear "SomeMethod"? Agora, na versão 3.5, no entanto, posso fazer isso de uma maneira fortemente tipada:

RegisterMethod<MyClass>(cl => cl.SomeMethod());

Na qual a classe RegisterMethod usa Expression<Action<T>>assim:

void RegisterMethod<T>(Expression<Action<T>> action) where T : class
{
    var expression = (action.Body as MethodCallExpression);

    if (expression != null)
    {
        // TODO: Register method
        Console.WriteLine(expression.Method.Name);
    }
}

Esse é um dos grandes motivos pelos quais estou apaixonado por Lambdas e Expression Trees no momento.

" rendimento " viria à minha mente. Alguns dos atributos como [DefaultValue ()] também estão entre os meus favoritos.

A palavra-chave " var " é um pouco mais conhecida, mas você também pode usá-la em aplicativos .NET 2.0 (desde que você use o compilador .NET 3.5 e defina-o para gerar o código 2.0) não parece ser muito conhecido. bem.

Edit: kokos, obrigado por apontar o ?? operador, isso é realmente muito útil. Como é um pouco difícil pesquisar no Google (como ?? é apenas ignorado), aqui está a página de documentação do MSDN para esse operador: ?? Operador (Referência de C #)

Costumo descobrir que a maioria dos desenvolvedores de C # não conhece os tipos 'anuláveis'. Basicamente, primitivas que podem ter um valor nulo.

double? num1 = null; 
double num2 = num1 ?? -100;

Defina um duplo anulável, num1 , como nulo, depois defina um duplo regular, num2 , para num1 ou -100 se num1 for nulo.

http://msdn.microsoft.com/en-us/library/1t3y8s4s(VS.80).aspx

mais uma coisa sobre o tipo Nullable:

DateTime? tmp = new DateTime();
tmp = null;
return tmp.ToString();

é retornar String.Empty. Verifique este link para mais detalhes

Aqui estão alguns recursos interessantes de C # ocultos, na forma de palavras-chave em C # não documentadas:

__makeref

__reftype

__refvalue

__arglist

Essas são palavras-chave em C # não documentadas (até o Visual Studio as reconhece!) Que foram adicionadas a um boxe / unboxing mais eficiente antes dos genéricos. Eles trabalham em coordenação com a estrutura System.TypedReference.

Há também __arglist, que é usado para listas de parâmetros de comprimento variável.

Uma coisa que as pessoas não sabem muito é o System.WeakReference - uma classe muito útil que monitora um objeto, mas ainda permite que o coletor de lixo o colete.

O recurso "oculto" mais útil seria a palavra-chave return return. Não está realmente escondido, mas muitas pessoas não sabem disso. O LINQ é construído sobre isso; Ele permite consultas executadas com atraso, gerando uma máquina de estado sob o capô. Raymond Chen postou recentemente sobre os detalhes internos e arenosos .

Uniões (o tipo de memória compartilhada C ++) em C # puro e seguro

Sem recorrer ao modo não seguro e aos ponteiros, você pode fazer com que os membros da classe compartilhem espaço de memória em uma classe / estrutura. Dada a seguinte classe:

[StructLayout(LayoutKind.Explicit)]
public class A
{
    [FieldOffset(0)]
    public byte One;

    [FieldOffset(1)]
    public byte Two;

    [FieldOffset(2)]
    public byte Three;

    [FieldOffset(3)]
    public byte Four;

    [FieldOffset(0)]
    public int Int32;
}

Você pode modificar os valores dos campos de bytes manipulando o campo Int32 e vice-versa. Por exemplo, este programa:

    static void Main(string[] args)
    {
        A a = new A { Int32 = int.MaxValue };

        Console.WriteLine(a.Int32);
        Console.WriteLine("{0:X} {1:X} {2:X} {3:X}", a.One, a.Two, a.Three, a.Four);

        a.Four = 0;
        a.Three = 0;
        Console.WriteLine(a.Int32);
    }

Emite isso:

2147483647
FF FF FF 7F
65535

basta adicionar using System.Runtime.InteropServices;

Usando @ para nomes de variáveis ​​que são palavras-chave.

var @object = new object();
var @string = "";
var @if = IpsoFacto(); 

Se você quiser sair do seu programa sem chamar nenhum bloco ou finalizador, use o FailFast :

Environment.FailFast()

Retornando tipos anônimos de um método e acessando membros sem reflexão.

// Useful? probably not.
private void foo()
{
    var user = AnonCast(GetUserTuple(), new { Name = default(string), Badges = default(int) });
    Console.WriteLine("Name: {0} Badges: {1}", user.Name, user.Badges);
}

object GetUserTuple()
{
    return new { Name = "dp", Badges = 5 };
}    

// Using the magic of Type Inference...
static T AnonCast<T>(object obj, T t)
{
   return (T) obj;
}

Aqui está um útil para expressões regulares e caminhos de arquivo:

"c:\\program files\\oldway"
@"c:\program file\newway"

O @ diz ao compilador para ignorar qualquer caractere de escape em uma string.

Mixins. Basicamente, se você deseja adicionar um recurso a várias classes, mas não pode usar uma classe base para todas elas, peça a cada classe que implemente uma interface (sem membros). Em seguida, escreva um método de extensão para a interface , ou seja,

public static DeepCopy(this IPrototype p) { ... }

Claro, alguma clareza é sacrificada. Mas funciona!

Não sei por que alguém iria querer usar o <bool> Nullable. :-)

Verdadeiro, falso, FileNotFound ?

Este não é "escondido" tanto quanto é nomeado incorretamente.

Muita atenção é dada aos algoritmos "mapa", "redução" e "filtro". O que a maioria das pessoas não percebe é que o .NET 3.5 adicionou todos esses três algoritmos, mas deu a eles nomes muito SQL-ish, com base no fato de que eles fazem parte do LINQ.

"map" => Selecionar
Transforma dados de um formulário para outro

"reduzir" => Agregar
Agrega valores em um único resultado

"filter" => Onde
Filtra dados com base em um critério

A capacidade de usar o LINQ para realizar trabalhos em linha em coleções que costumavam fazer iterações e condicionais pode ser incrivelmente valiosa. Vale a pena aprender como todos os métodos de extensão LINQ podem ajudar a tornar seu código muito mais compacto e sustentável.

Environment.NewLine

para novas linhas independentes do sistema.

Se você estiver tentando usar colchetes dentro de uma expressão String.Format ...

int foo = 3;
string bar = "blind mice";
String.Format("{{I am in brackets!}} {0} {1}", foo, bar);
//Outputs "{I am in brackets!} 3 blind mice"

1. ?? - operador coalescente
2. using ( declaração / diretiva ) - excelente palavra-chave que pode ser usada para mais do que chamar Dispose
3. somente leitura - deve ser usado mais
4. netmodules - pena que não há suporte no Visual Studio

@ Ed, eu sou um pouco reticente em postar isso, pois é pouco mais do que nitpicking. No entanto, gostaria de salientar que no seu exemplo de código:

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

Se você vai usar 'is', por que segui-lo com um elenco seguro usando 'as'? Se você constatou que obj é, de fato, MyClass, um elenco padrão:

c = (MyClass)obj

... nunca vai falhar.

Da mesma forma, você poderia apenas dizer:

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

Não sei o suficiente sobre as entranhas do .NET para ter certeza, mas meus instintos me dizem que isso reduziria no máximo dois tipos de operações de conversão para um máximo de um. É pouco provável que quebre o banco de processamento de qualquer maneira; pessoalmente, acho que a última forma parece mais limpa também.

Talvez não seja uma técnica avançada, mas eu vejo o tempo todo que me deixa louco:

if (x == 1)
{
   x = 2;
}
else
{
   x = 3;
}

pode ser condensado para:

x = (x==1) ? 2 : 3;