Como borrar Requirimientos de TFS / delete requirements in TFS


Be sure you have installed Power Tools for VS 2010, Open Visual Studio Command Prompt, and run the following command:
witadmin destroywi /collection:http://192.168.0.1:8080/tfs/Collection /id:1305,1306,1307,1308,1309
change 192.168.0.1 for the proper ip address of your server and Collection for the name of your Collection, you can see this name when connecting to the TFS server, the id numbers can be found in the open requirements query in TFS.

ID
TFS requirements ID

Your user must have permissions to delete.

Merging Skype and Live Messenger / Uniendo Skype y Live Messenger


You can now download the new Skype 6.0.73.126, it allows you to merge your existing skype and live messenger accounts into one. First, enter your live messenger credentials when accessing skype, the program will let you choose to use your existing Skype Account or create a new one.  Ahora puedes bajar el nuevo Skype 6.0.73.126, ya puedes unir tus cuentas existentes de skype y live messenger en uno solo. Primero, ingrese con sus credenciales de live messenger en skype, el programa le permitirá escoger usar su cuenta existente de skype o crear una nueva.

This slideshow requires JavaScript.

Once you click on the proper button, you must write your skype account and password. Then Skype will merge your accounts. After this you will see your skype and live messenger accounts in the main screen of Skype. Messenger contacts have a note to identify them below name.   (Messenger > “messenger message”)

Una vez de clic en el botón escogido debe escribir su usuario y clave de skype. Ahora Skype unirá las cuentas. Después verá que se han unido sus cuentas y los contactos aparecen en la ventana principal de Skype.  Los contactos de messenger aparecen con una nota para identificarlos debajo de su nombre. (Messenger > “mensaje del messenger”)

Wear the Shirt / Ponte la camiseta


Wear the Shirt
Ponte la camiseta

Wear the shirt by the company means that when the company requires some additional efforts from us, we are willing to provide them. Even if it means theoretically degrade our position. But who better to demonstrate that our experience can be shared to help maintain the professionalism of the company. We can not be blind if we see catastrophic situations happening, those we can help solve or better prevent from happening.

If a situation will get us out of our comfort in order to solve it, should be seen as a new experience instead of running away and witness how it affects our environment in a bad way, of course it is more likely that if we really love our work always we are willing to help.

Having the shirt means that we will not let the company fall for something that we can fix.

The moment you decide to take your shirt off from the company is because you retired, either because they do not work anymore or because you went to wear the shirt of another company. But you must never take your shirt off while you’re still working in the company, that’s not honest.

It is best to work for a company that you like and that means you’ll always have the shirt, otherwise you will always find excuses to take off the shirt.

 

****************************************************

 

Ponerse la camiseta por la empresa significa que cuando la empresa requiera de nuestros esfuerzos adicionales, estemos dispuestos a brindarlos. Aunque eso implique degradar teóricamente nuestra posición. Pero que mejor que demostrar que nuestra experiencia se puede compartir para ayudar a mantener el profesionalismo de la compañía. No podemos hacernos los ciegos si frente a nosotros suceden situaciones catastróficas que podemos ayudar a resolver o mejor aún prevenir.

Si una situación nos va a sacar de nuestra comodidad para poder resolverla, hay que verla como una nueva experiencia en lugar de huir y ser testigo de como afecta de mala forma nuestro entorno, claro es más probable que si de verdad nos gusta nuestro trabajo siempre estemos dispuestos a ayudar.

Tener puesta la camiseta significa que no vamos a dejar que la compañía se caiga por algo que nosotros podemos arreglar.

En el momento que tu decidas quitarte la camiseta de la compañía es porque te jubilaste, ya sea porque ya no trabajarás más o porque te fuiste a usar la camiseta de otra compañía. Pero jamás debes quitarte la camiseta mientras sigas trabajando en la compañía, eso no es honesto.

Lo más recomendable es trabajar para una compañía que te guste y eso significa que siempre tendrás puesta la camiseta, de otra forma siempre buscarás excusas para quitarte la camiseta.

Documentar el código es esencial. C#


Siempre que realizamos un nuevo proyecto ya sea con Visual Studio Studio y C# o cualquier otra herramienta, debemos tener en cuenta que normalmente pensamos en crear estos proyectos para que sean usados un tiempo prudencial, a veces incluso años. Por esto necesariamente el código va a ser releído muchas veces por nosotros y probablemente por otras personas. Si hemos documentado bien el código la siguiente vez que lo leamos vamos a comprender fácilmente que queríamos hacer allí, de lo contrario nos toca hacer un trabajo fuerte de reentender para que escribimos dicho código. Es por esto que se hace fundamental hacer una buena documentación.

Usando Visual Studio y C# la forma sencilla de documentar cada función, clase o programa es pulsar 3 veces la tecla slash “/” encima del nombre de la entidad respectiva y aparece una documentación sencilla:

        /// <summary>

        ///

        /// </summary>

        public int MyProperty { get; set; }

Dentro de summary ponemos una descripción clara de lo que realiza la entidad y con eso podemos darle una idea de para que sirve.

Si queremos algo más especializado debemos utilizar una herramienta que ayude a documentar, por ejemplo el GhostDoc http://submain.com/products/ghostdoc.aspx ampliamente recomendado por la comunidad de desarrolladores de VS.

Se puede bajar de la dirección mencionada arriba y una vez instalado, procedemos a documentar la misma porción de código usando clic derecho sobre el nombre de la entidad, escogemos “Document this” nueva opción creada por Ghostdoc y este es el resultado:

        /// <summary>

        /// Gets or sets my property.

        /// </summary>

        /// <value>

        /// My property.

        /// </value>

        public int MyProperty { get; set; }

Esto nos proporciona una presentación más completa y con más sentido para documentar. Esta herramienta nos va a servir mucho para usar diariamente. La recomiendo para que los programas estén más entendibles y puedan ser mejor administrados.

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