Esto vino a mi mente después de aprender lo siguiente de esta pregunta :

where T : struct

Nosotros, los desarrolladores de C #, todos conocemos los conceptos básicos de C #. Me refiero a declaraciones, condicionales, bucles, operadores, etc.

Algunos de nosotros incluso dominamos cosas como genéricos , tipos anónimos , lambdas , LINQ , ...

¿Pero cuáles son las características o trucos más ocultos de C # que incluso los fanáticos, adictos y expertos de C # apenas conocen?

Aquí están las características reveladas hasta ahora:

Palabras clave

• yieldpor Michael Stum
• varpor Michael Stum
• using()declaración de kokos
• readonlypor kokos
• aspor Mike Stone
• as/ ispor Ed Swangren
• as/ is(mejorado) por Rocketpants
• defaultpor deathofrats
• global::por pzycoman
• using()bloques por AlexCuse
• volatilepor Jakub Šturc
• extern aliaspor Jakub Šturc

Atributos

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

Sintaxis

• ??(fusionar nulos) operador de kokos
• Banderines de números de Nick Berardi
• where T:newpor Lars Mæhlum
• Genéricos implícitos por Keith
• Lambdas de un parámetro de Keith
• Auto propiedades de Keith
• Alias ​​de espacio de nombres de Keith
• Literales de cadena literales con @ by Patrick
• enumvalores por lfoust
• @variablenames por marxidad
• eventoperadores por marxidad
• Formatear corchetes por Portman
• Modificadores de accesibilidad de acceso de propiedad por xanadont
• Operador condicional (ternario) ( ?:) por JasonS
• checkedy uncheckedoperadores de Binoj Antony
• implicit and explicitoperadores de Flory

Características del lenguaje

• Tipos anulables por Brad Barker
• Tipos anónimos por Keith
• __makeref __reftype __refvaluepor Judá Himango
• Inicializadores de objetos por lomaxx
• Cadenas de formato de David en Dakota
• Métodos de extensión por marxidad
• partialmétodos de Jon Erickson
• Directivas de preprocesador de John Asbeck
• DEBUGdirectiva de preprocesador de Robert Durgin
• Operador sobrecargado por SefBkn
• Inferencia de tipo por chakrit
• Operadores booleanos llevados al siguiente nivel por Rob Gough
• Pase la variable de tipo de valor como interfaz sin boxeo por Roman Boiko
• Determine programáticamente el tipo de variable declarada por Roman Boiko
• Constructores estáticos de Chris
• Mapeo de ORM más fácil en los ojos / condensado usando LINQ por roosteronacid
• __arglistpor Zac Bowling

Características de Visual Studio

• Seleccionar bloque de texto en el editor por Himadri
• Fragmentos de DannySmurf

Marco de referencia

• TransactionScopepor KiwiBastard
• DependantTransactionpor KiwiBastard
• Nullable<T>por IainMH
• Mutexpor Diago
• System.IO.Pathpor ageektrapped
• WeakReferencepor juan manuel

Métodos y propiedades

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

consejos y trucos

• Buen método para controladores de eventos por Andreas HR Nilsson
• Comparaciones en mayúsculas por John
• Acceda a tipos anónimos sin reflexión por dp
• Una forma rápida de instanciar perezosamente las propiedades de colección de Will
• Funciones en línea anónimas similares a JavaScript de roosteronacid

Otro

• netmodules por kokos
• LINQBridge por Duncan Smart
• Extensiones paralelas de Joel Coehoorn

Esto no es C # per se, pero no he visto a nadie que realmente use System.IO.Path.Combine()en la medida en que debería. De hecho, toda la clase Path es realmente útil, ¡pero nadie la usa!

Estoy dispuesto a apostar que cada aplicación de producción tiene el siguiente código, aunque no debería:

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

Las lambdas y la inferencia de tipos están infravaloradas. Las lambdas pueden tener múltiples declaraciones y duplican automáticamente como un objeto delegado compatible (solo asegúrese de que la firma coincida) como en:

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

Tenga en cuenta que no tengo new CancellationEventHandlerni tengo que especificar tipos desender y e, son infecibles desde el evento. Es por eso que esto es menos engorroso para escribir todo, lo delegate (blah blah)que también requiere que especifique tipos de parámetros.

Las lambdas no necesitan devolver nada y la inferencia de tipos es extremadamente poderosa en un contexto como este.

Y, por cierto, siempre puede devolver Lambdas que hacen Lambdas en el sentido de programación funcional. Por ejemplo, aquí hay una lambda que hace una lambda que maneja un 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);

Tenga en cuenta el encadenamiento: (dx, dy) => (sender, e) =>

Ahora es por eso que estoy feliz de haber tomado la clase de programación funcional :-)

Aparte de los punteros en C, creo que es la otra cosa fundamental que debes aprender :-)

De Rick Strahl :

Puedes encadenar el ?? operador para que pueda hacer un montón de comparaciones nulas.

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

Genéricos con alias:

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

Te permite usar ASimpleName, en lugar deDictionary<string, Dictionary<string, List<string>>> .

Úselo cuando usaría la misma cosa grande, larga, genérica y compleja en muchos lugares.

Desde CLR a través de C # :

Al normalizar cadenas, se recomienda que use ToUpperInvariant en lugar de ToLowerInvariant porque Microsoft ha optimizado el código para realizar comparaciones en mayúsculas .

Recuerdo una vez que mi compañero de trabajo siempre cambiaba las cadenas a mayúsculas antes de comparar. Siempre me he preguntado por qué lo hace porque siento que es más "natural" convertir a minúsculas primero. Después de leer el libro ahora sé por qué.

Mi truco favorito es utilizar el operador de fusión nula y los paréntesis para crear instancias automáticas de colecciones para mí.

private IList<Foo> _foo;

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

Evite buscar controladores de eventos nulos

Agregar un delegado vacío a los eventos en la declaración, eliminando la necesidad de verificar siempre que el evento sea nulo antes de llamarlo, es increíble. Ejemplo:

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

Dejarte hacer esto

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

En lugar de esto

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

Consulte también esta discusión relacionada y esta publicación de blog de Eric Lippert sobre este tema (y posibles desventajas).

Todo lo demás, más

1) genéricos implícitos (¿por qué solo en métodos y no en clases?)

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

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

2) lambdas simples con un parámetro:

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

3) tipos anónimos e inicializadores:

//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 };

Otro:

4) Las propiedades automáticas pueden tener diferentes ámbitos:

public int MyId { get; private set; }

Gracias @pzycoman por recordarme:

5) Alias ​​de espacio de nombres (no es probable que necesite esta distinción particular):

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

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

No conocía la palabra clave "como" durante bastante tiempo.

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

El segundo devolverá nulo si obj no es MyClass, en lugar de lanzar una excepción de conversión de clase.

Dos cosas que me gustan son las propiedades automáticas para que pueda colapsar aún más su código:

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

se convierte

public string Name { get; set;}

También objetos inicializadores:

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

se convierte

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

La palabra clave 'predeterminada' en tipos genéricos:

T t = default(T);

da como resultado un 'nulo' si T es un tipo de referencia y 0 si es un int, falso si es un booleano, etc.

Atributos en general, pero sobre todo DebuggerDisplay . Te ahorra años.

El @ le dice al compilador que ignore cualquier carácter de escape en una cadena.

Solo quería aclarar esto ... no le dice que ignore los caracteres de escape, en realidad le dice al compilador que interprete la cadena como un literal.

Si usted tiene

string s = @"cat
             dog
             fish"

en realidad se imprimirá como (tenga en cuenta que incluso incluye el espacio en blanco utilizado para la sangría):

cat
             dog
             fish

Creo que una de las características menos apreciadas y menos conocidas de C # (.NET 3.5) son los árboles de expresión , especialmente cuando se combinan con genéricos y lambdas. Este es un enfoque para la creación de API que las bibliotecas más nuevas como NInject y Moq están utilizando.

Por ejemplo, supongamos que quiero registrar un método con una API y que la API necesita obtener el nombre del método

Dada esta clase:

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

Antes, era muy común ver a los desarrolladores hacer esto con cadenas y tipos (o algo más basado en cadenas):

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

Bueno, eso apesta por la falta de tipeo fuerte. ¿Qué sucede si cambio el nombre de "SomeMethod"? Ahora, en 3.5, sin embargo, puedo hacer esto de una manera muy tipada:

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

En el que la clase RegisterMethod usa Expression<Action<T>>así:

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);
    }
}

Esta es una gran razón por la que estoy enamorado de Lambdas y Expression Trees en este momento.

" ceder " vendría a mi mente. Algunos de los atributos como [DefaultValue ()] también se encuentran entre mis favoritos.

La palabra clave " var " es un poco más conocida, pero parece que no se puede conocer muy bien en las aplicaciones .NET 2.0 (siempre que use el compilador .NET 3.5 y lo configure en el código de salida 2.0). bien.

Editar: kokos, gracias por señalar el ?? operador, eso es realmente muy útil. Dado que es un poco difícil de google (ya que ?? simplemente se ignora), aquí está la página de documentación de MSDN para ese operador: ?? Operador (Referencia de C #)

Tiendo a encontrar que la mayoría de los desarrolladores de C # no saben acerca de los tipos 'anulables'. Básicamente, primitivas que pueden tener un valor nulo.

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

Establezca un doble anulable, num1 , en nulo, luego establezca un doble regular, num2 , en num1 o -100 si num1 era nulo.

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

Una cosa más sobre el tipo Nullable:

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

es return String.Empty. Mira este enlace para más detalles

Estas son algunas características interesantes ocultas de C #, en forma de palabras clave de C # no documentadas:

__makeref

__reftype

__refvalue

__arglist

Estas son palabras clave de C # no documentadas (¡incluso Visual Studio las reconoce!) Que se agregaron para un boxeo / unboxing más eficiente antes de los genéricos. Trabajan en coordinación con la estructura System.TypedReference.

También hay __arglist, que se usa para listas de parámetros de longitud variable.

Una cosa de la que la gente no sabe mucho es System.WeakReference , una clase muy útil que realiza un seguimiento de un objeto pero que aún permite que el recolector de basura lo recoja.

La característica "oculta" más útil sería la palabra clave de retorno de rendimiento. No está realmente oculto, pero mucha gente no lo sabe. LINQ está construido sobre esto; permite consultas ejecutadas con retraso al generar una máquina de estado bajo el capó. Raymond Chen recientemente publicó sobre los detalles internos y arenosos .

Uniones (el tipo de memoria compartida de C ++) en C # puro y seguro

Sin recurrir al modo inseguro y los punteros, puede hacer que los miembros de la clase compartan espacio de memoria en una clase / estructura. Dada la siguiente clase:

[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;
}

Puede modificar los valores de los campos de bytes manipulando el campo Int32 y viceversa. Por ejemplo, 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);
    }

Salidas esto:

2147483647
FF FF FF 7F
65535

simplemente agregue usando System.Runtime.InteropServices;

Usando @ para nombres de variables que son palabras clave.

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

Si desea salir de su programa sin llamar a ningún bloque o finalizador, use FailFast :

Environment.FailFast()

Devolver tipos anónimos de un método y acceder a miembros sin reflexión.

// 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;
}

Aquí hay una útil para expresiones regulares y rutas de archivos:

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

El @ le dice al compilador que ignore cualquier carácter de escape en una cadena.

Mixins Básicamente, si desea agregar una función a varias clases, pero no puede usar una clase base para todas ellas, haga que cada clase implemente una interfaz (sin miembros). Luego, escriba un método de extensión para la interfaz , es decir

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

Por supuesto, se sacrifica algo de claridad. ¡Pero funciona!

Sin embargo, no estoy seguro de por qué alguien querría usar Nullable <bool>. :-)

¿Verdadero, falso, FileNotFound ?

Este no está "oculto" tanto como está mal nombrado.

Se presta mucha atención a los algoritmos "mapa", "reducir" y "filtro". De lo que la mayoría de la gente no se da cuenta es que .NET 3.5 agregó estos tres algoritmos, pero les dio nombres muy SQL, basados ​​en el hecho de que son parte de LINQ.

"map" => Seleccionar
Transforma datos de un formulario a otro

"reduce" =>
Agregar valores agregados en un solo resultado

"filter" => Donde
filtra datos basados ​​en un criterio

La capacidad de usar LINQ para realizar trabajos en línea en colecciones que solían tomar iteraciones y condicionales puede ser increíblemente valiosa. Vale la pena aprender cómo todos los métodos de extensión de LINQ pueden ayudar a que su código sea mucho más compacto y fácil de mantener.

Environment.NewLine

para líneas nuevas independientes del sistema.

Si está tratando de usar corchetes dentro de una expresión 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. utilizando ( instrucción / directiva ): excelente palabra clave que se puede usar para algo más que simplemente llamar a Eliminar
3. solo lectura - debe usarse más
4. netmodules: lástima que no haya soporte en Visual Studio

@Ed, soy un poco reticente a publicar esto, ya que es poco más que una trampa. Sin embargo, señalaría que en su ejemplo de código:

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

Si vas a usar 'es', ¿por qué seguir con un molde seguro usando 'como'? Si ha comprobado que obj es de hecho MyClass, un elenco de pantano estándar:

c = (MyClass)obj

... nunca va a fallar.

Del mismo modo, podrías decir:

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

No sé lo suficiente sobre las entrañas de .NET para estar seguro, pero mis instintos me dicen que esto reduciría un máximo de dos operaciones de lanzamiento de tipos a un máximo de uno. Es poco probable que rompa el banco de procesamiento de cualquier manera; personalmente, creo que la última forma también se ve más limpia.

Tal vez no sea una técnica avanzada, pero una que veo todo el tiempo que me vuelve loco:

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

se puede condensar a:

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