programacion - programar c#



Características ocultas de C#? (20)

Desde CLR a través de C # :

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

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

Esto vino a mi mente después de que aprendí lo siguiente de esta pregunta :

where T : struct

Nosotros, los desarrolladores de C #, todos sabemos lo básico de C #. Me refiero a declaraciones, condicionales, bucles, operadores, etc.

Algunos de nosotros incluso dominamos cosas como Generics , tipos anónimos , lambdas , LINQ , ...

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

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


Palabras clave

Atributos

Sintaxis

Características del lenguaje

Características de Visual Studio

Marco de referencia

Métodos y propiedades

consejos y trucos

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

Otro


Answer #1

La @ 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

Answer #2
  1. ?? - operador coalescente
  2. Uso de ( statement / directive ): gran palabra clave que se puede usar para más que solo llamar a Dispose
  3. readonly - debería ser usado más
  4. Netmodules: muy mal, no hay soporte en Visual Studio

Answer #3

" yield " vendría a mi mente. Algunos de los atributos como DefaultValueAttribute también están entre mis favoritos.

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

Edit: kokos, gracias por señalar el ?? Operador, eso es realmente muy útil. Ya que es un poco difícil buscarlo en Google (ya que se ignora), aquí está la página de documentación de MSDN para ese operador: ??


Answer #4

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


Answer #5

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 están utilizando las bibliotecas más nuevas como NInject y Moq.

Por ejemplo, digamos 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 escritura fuerte. ¿Qué pasa si cambio el nombre de "SomeMethod"? Ahora, en 3.5, sin embargo, puedo hacer esto de una manera muy tipográfica:

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

En el que la clase RegisterMethod usa Expression<Action<T>> siguiente manera:

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 razón importante por la que estoy enamorado de Lambdas y Expression Trees en este momento.


Answer #6

Dos cosas que me gustan son las propiedades automáticas para que puedas contraer tu código aún más:

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

se convierte en

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 en

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

Answer #7

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

Answer #8

La palabra clave 'por defecto' 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.


Answer #9

Mi truco favorito es usar el operador de unión nula y los paréntesis para crear instancias automágicamente para mí.

private IList<Foo> _foo;

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

Answer #10

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

Environment.FailFast()

Answer #11

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

Se devuelve String.Empty. Revisa this enlace para más detalles.


Answer #12

Utilizando @ para nombres de variables que son palabras clave.

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

Answer #13

Evite verificar los manejadores de eventos nulos

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

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

Dejar que hagas 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 sus posibles desventajas).


Answer #14

Uniones (el tipo de memoria compartida de C ++) en C # pura y segura

Sin recurrir al modo inseguro ni a 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);
    }

Produce esto:

2147483647
FF FF FF 7F
65535

solo agregue usando System.Runtime.InteropServices;


Answer #15

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

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

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


Answer #16

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

Se presta mucha atención a los algoritmos "mapa", "reducir" y "filtro". 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 parecidos a SQL, basándose en el hecho de que son parte de LINQ.

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

"reduce" =>
Agregue los valores de los agregados en un solo resultado

"filter" => Donde
filtra los datos según 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.


Answer #17

Si está intentando usar llaves 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"

Answer #18

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

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

Si va a usar 'es', ¿por qué seguirlo con un modelo seguro usando 'como'? Si has comprobado que obj es MyClass, un elenco estándar:

c = (MyClass)obj

... nunca va a fallar.

Del mismo modo, usted podría 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 tipo a un máximo. Es poco probable que se rompa el banco de procesamiento de cualquier manera; Personalmente, creo que la última forma también se ve más limpia.


Answer #19

Mixins. Básicamente, si desea agregar una característica a varias clases, pero no puede usar una clase base para todas ellas, haga que cada clase implemente una interfaz (sin miembros). Luego, escribe 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!





hidden-features