Pregunta Características ocultas de C #? [cerrado]


Esto vino a mi mente después de que aprendí 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 las 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 de C #, los adictos, los expertos apenas conocen?

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


Palabras clave

Atributos

Sintaxis

  • ?? (coalesce nulls) operador por kokos
  • Número de indicadores por Nick Berardi
  • where T:new por Lars Mæhlum
  • Genéricos implícitos por Keith
  • Un solo parámetro lambdas por Keith
  • Propiedades automáticas por Keith
  • Namespace aliases por Keith
  • Literales literales literales con @ por Patricio
  • enum valores por lfo
  • @variablenames por marxidad
  • event operadores por marxidad
  • Formato de corchetes por Portman
  • Modificadores de accesibilidad de acceso de propiedad por xanadont
  • Operador condicional (ternario) (?:) por JasonS
  • checked y unchecked operadores por Binoj Antony
  • implicit and explicit operadores por Flory

Características del lenguaje

Características de Visual Studio

Marco de referencia

Métodos y propiedades

  • String.IsNullOrEmpty() método por KiwiBastard
  • List.ForEach() método por KiwiBastard
  • BeginInvoke(), EndInvoke() métodos por Will Dean
  • Nullable<T>.HasValue y Nullable<T>.Value propiedades por Rismo
  • GetValueOrDefault método por John Sheehan

consejos y trucos

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

Otro


1476


origen


Respuestas:


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ían De hecho, toda la clase Path es realmente útil, pero ¡nadie lo 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;

752



lambdas y tipo inferrence están subestimados Lambdas puede tener múltiples declaraciones y ellos doble como un objeto delegado compatible automáticamente (solo asegúrese de que coincida con la firma) como en:

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

Tenga en cuenta que no tengo una new CancellationEventHandler tampoco tengo que especificar tipos de sender y e, son deducibles del evento. Por eso es menos engorroso escribir todo delegate (blah blah) que también requiere que especifique tipos de parámetros.

Lambdas no necesita devolver nada y la inferencia de tipo es extremadamente poderosa en un contexto como este.

Y por cierto, siempre puedes regresar Lambdas que hacen Lambdas en el sentido de programación funcional. Por ejemplo, aquí hay una lambda que crea 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 :-)


585



De Rick Strahl:

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

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

528



Genéricos aliased:

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

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

Úselo cuando use la misma cosa genérica grande larga y compleja en muchos lugares.


455



De CLR a través de C #:

Al normalizar cadenas, es altamente   recomendado que uses   ToUpperInvariant en lugar de   ToLowerInvariant porque Microsoft tiene   optimizado el código para realizar   comparaciones en mayúsculas.

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


438



Mi truco favorito es usar el nulo coalesce operador y paréntesis para crear automáticamente instancias de colecciones para mí.

private IList<Foo> _foo;

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

409



Evite buscar controladores de eventos nulos

Agregar un delegado vacío a los eventos en la declaración, suprimir la necesidad de comprobar siempre el evento para null antes de llamar es impresionante. Ejemplo:

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

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

Por favor, también vea esto discusión relacionada y esto entrada en el blog por Eric Lippert sobre este tema (y posibles inconvenientes).


314



Todo lo demás, más

1) genéricos implícitos (¿por qué solo en los métodos y no en las 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 ​​del espacio de nombres (no es probable que necesites 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();

305



No sabía la palabra clave "como" desde hace bastante tiempo.

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

El segundo devolverá null si obj no es un MyClass, en lugar de arrojar una excepción de lanzamiento de clase.


286



Dos cosas que me gustan son las propiedades automáticas, por lo que puedes colapsar aún más tu código:

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

se convierte

public string Name { get; set;}

También los inicializadores de objetos:

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

se convierte

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

262



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étera.


255