8 cosas que probablemente no sabías de C#


ESTAS SON ALGUNAS COSAS INUSUALES DE C# QUE POCOS DESARROLLADORES DE C# PARECEN CONOCER.

1. Los Indexers admiten parámetros Todos sabemos la declaración regular x=something[“a”] y para implementarlo escribes:

public string this[string key] { get { return internalDictionary[key]; } }

Pero sabías que se pueden usar parámetos para permitir esto x=something[“a”,”b”,”c”,”d”]?

Simplemente debes declarar el indexer así:

public IEnumerable<string> this[params string[] keys] { get { return keys.Select(key => internalDictionary[key]).AsEnumerable(); } }

Lo fantástico aquí es que puedes tener ambos indexers en la misma clase lado a lado. Si alguien envía un arreglo o múltiples argumentos obtendrá un retorno IEnumerable pero si lo llama con un argumento simple obtendrá un valor simple.

2. Los Strings definidos múltiples veces en el código son agrupados en una instancia Muchos desarrolladores creen que:

if (x == ” ” || x == “y”)

creará un par de strings cada momento. Pues no!.

C#, como muchos lenguajes, tiene un “string interning” (strings que se adicionan en el string pool compartido del runtime) y cada string que tu aplicación compila lo ubica en una lista en la memoria que se referencia en runtime.

Puedes usar String.Intern para ver si está actualmente en esta lista, pero ten en cuenta que haciendo String.Intern(“what”)==”what” siempre devolverá verdadero ya que justo definiste otro string en tu fuente.

String.IsInterned(“wh”+”at”)== “what” también retornará verdadero gracias a las optimizaciones del compilador.

String.IsInterned(new string(new char[] {‘w’,’h’,’a’,’t’}) == new string(new char[] {‘w’,’h’,’a’,’t’}) soló retornará verdadero si tienes “what” en otra parte del programa o en runtime algo más lo adicionó a la “intern pool”.

Si tiene clases que construyen o recuperan regularmente strings usados en runtime, considere usar String.Intern

para agregarlos al pool. Ten en cuenta que una vez ellos permanecerán allí hasta que se cierre la aplicación, así que use String.Intern muy cuidadosamente. La sintaxis es simplemente String.Intern(someClass.ToString())

Otra advertencia es que haciendo (object)”Hi” == (object)”Hi” va a retornar verdadero en su aplicación gracias al interning. Inténtalo en la ventana intermediate del debug y será falso ya que el debugger no estará manejando los strings “interning”.

3. Exponer los tipos con una capacidad menor no previene su uso como su tipo real. Un gran ejemplo de esto es cuando las listas internas son expuestas como propiedades IEnumerable.

Ejemplo:

private readonly List<string> internalStrings = new List<string>(); public IEnumerable<string> AllStrings { get { return internalStrings; }

Aquí pensaríamos que nadie puede modificar los strings internos. Desgraciadamente es muy fácil

((List<string>)x.AllStrings).Add(“Hello”);

Inclusive “AsEnumerable” no ayudará ya que es un método LINQ que no hace nada😦 Puedes usar

“AsReadOnly” que encapsula la lista que lanza cuando tratas de configurar cualquier cosa, sin embargo es una buena opción para hacer cosas similares con tus clases cuando necesitas exponer un subconjunto de estructuras internas si es inevitable.

4. Variables en métodos pueden ser globalizadas solo con llaves/corchetes En Pascal se tenía que declarar todas las variables que la función usaría desde el comienzo de la función.

Afortunadamente hoy las declaraciones pueden vivir al lado de su asignación y eso ayuda a prevenir su uso accidental antes de lo planeado.

Lo que no hace es pararlo de usarla después de lo planeado. Dado que for/if/while/using etc. todos permiten un ámbito anidado debería sorprender que puedes declarar variables dentro de llaves sin un keyword para obtener el mismo resultado:

private void MultipleScopes() { { var a = 1; Console.WriteLine(a); } { var b = 2; Console.WriteLine(a); } }

Es mejor solución dividir sus métodos en más pequeños usando el método de refactoring para extracción.

5. Los enums pueden tener métodos de extensión Los métodos de extensión permiten una forma de escribir métodos para clases de forma que otras personas del equipo pueden descubrir y usar. Dado que las enumeraciones son clases como cualquier otra no debería sorprender que se puedan extender:

enum Duration { Day, Week, Month };

static class DurationExtensions { public static DateTime From(this Duration duration, DateTime dateTime) { switch duration { case Day: return dateTime.AddDays(1); case Week: return dateTime.AddDays(7); case Month: return dateTime.AddMonths(1); default: throw new ArgumentOutOfRangeException(“duration”) } } }

Creo que las enumeraciones son terribles pero al menos nos permite centralizar algo del manejo switch/if y abstraerlas un poco mientras hacemos algo mejor. Recuerde verificar los valores que estén en rangos.

6. El orden de declaración de variables estáticas en el código fuente importa. Algunas personas insisten que las variables están ordenadas alfabéticamente y hay herramientas que las reordenan automáticamente…. sin embargo hay un escenario donde el reordenamiento puede tumbar tu aplicación.

static class Program { private static int a = 5; private static int b = a;

static void Main(string[] args) { Console.WriteLine(b); } }

Esto imprimirá el número 5. Si reordenas la declaración a y b la salida será 0.

7. Las variables de instancia privada de una clase pueden ser accesadas por otras intancias De pronto puedes pensar que el siguiente código no funcionará:

class KeepSecret { private int someSecret; public bool Equals(KeepSecret other) { return other.someSecret == someSecret; } }

Es fácil pensar que el significado de privado hace que solamente la instancia de la clase puede accesarla pero la realidad es que significa que solo la clase puede accesarla… incluyendo otras instancias de la clase. De verdad es muy útil para algunos métodos de comparación.

8. La especificación del lenguaje C# está en tu computador

Siempre y cuando tengas Visual Studio instalado puedes encontrarla en la carpeta VS en archivos de programa (x86 si es máquina 64 bits) dentro de la carpeta VC#\Specifications. VS 2010 viene con el documento C# 5.0 en formato Word.

Y está lleno de muchas más cosas interesantes como:

* i = 1 es atomic (hilo-seguro) para un int pero no para long * Se puede usar & y | booleanos nulos con compatibilidad SQL * [Conditional(“DEBUG”)] es más util que #if DEBUG

Y para todos los que dicen “Yo ya sabía todo esto” Yo digo “Donde estás cuando estoy contratando!”, en serio, es muy dificil encontrar desarrolladores C# con un sólido entendimiento del lenguaje.

Traducido de http://damieng.com/blog/2012/10/29/8-things-you-probably-didnt-know-about-csharp

 

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s