SharePoint 2010. Personalizando formularios con InfoPath

Una de las nuevas características de SharePoint 2010, es la capacidad de poder personalizar los formularios de las listas (New Form, Edit Form and View Form) con InfoPath 2010.

Con la versión actual (MOSS 2007) tenemos la posibilidad de personalizar los formularios de nuestros Workflows con InfoPath, podíamos tener una biblioteca de formularios en la que los usuarios rellenan los datos de una lista utilizando un documento InfoPath, pero no tenemos la posibilidad que nos ofrece SharePoint 2010 en la que un usuario, con conocimientos de InfoPath, puedo con no más de dos clicks de ratón personalizar el formulario de la una lista.

Os lo muestro con un ejemplo, que será más fácil ver las diferencias.

Vamos a crearnos una lista de Contacts en SharePoint 2010 para personalizar el formulario. Para quien no conozca de InfoPath, comentarles que es una aplicación para desarrollar formularios basados en XML, incluyendo validadores de campos, consultas a orígenes de datos externos, formateo de campos, etc.

SharePoint2010_InfoPathCustomForm1

En la pestaña de List, tenemos una opción con el icono de InfoPath llamada Customize Form. Cuando seleccionamos esta opción, se nos abrirá InfoPath 2010, con un formulario que se ha creado con los elementos de la lista de Contacts.

SharePoint2010_InfoPathCustomForm2

Validación de campos con reglas de InfoPath

Las listas de SharePoint 2010 permiten la validación de los campos utilizando formulas, estas validaciones son del tipo comparación (con valores u otros campos), sin embargo, no podemos realizar validaciones con expresiones regulares. InfoPath 2010, además de este tipo de validaciones, incluye algunas algunas más, como las de expresiones regulares. Por ejemplo, en el formulario de Contacts, vamos a poner una validador para que el usuario tenga que escribir un email correctamente.

SharePoint2010_InfoPathCustomForm3

InfoPath incluye algunas expresiones regulares comunes (email, código postal, url), pero también podemos escribir nuestras expresiones para realizar la validación.

SharePoint2010_InfoPathCustomForm4

Estas reglas pueden ser de Validación, Formateo o Acción. Para nuestro ejemplo, utilizaremos una regla de validación.

SharePoint2010_InfoPathCustomForm5

También vamos a crear una regla de Formateo para que el campo Company se ponga en amarillo cuando se escriba una empresa llamada Contoso.

SharePoint2010_InfoPathCustomForm6

Filtrar Lookups

También podemos realizar filtros de los campos Lookups de la lista. Por ejemplo, hemos modificado la lista de Contacts, para que el Job Title sea un campo Lookup. Vamos a ver como podemos filtrar ese campo para que sólo salgan los Job Title de Internal Use.

En las propiedades del Drop-Down List del campo Job Title, vemos que está conectado a un origen de datos externos, llamado Job Title y en el Entries se ha seleccionado todos los elementos de la lista de SharePoint.

SharePoint2010_InfoPathCustomForm7

Para filtrar, tenemos que cambiar el Entries para que no nos devuelva toda la lista de elementos, si no que nos devuelva los elementos que tengan un ‘FALSE’ en el campo Internal use. Si nuestro origen de datos a filtrar no incluye este campo, podemos añadir una nueva conexión a una lista de SharePoint e incluir este campo.

SharePoint2010_InfoPathCustomForm8

Ahora nuestro Entries contiene la consulta filtrada (/dfs:myFields/dfs:dataFields/d:SharePointListItem_RW[d:Internal_x0020_use = string(false())]).

Nos queda publicar el formulario a la lista de SharePoint y listo. Hemos personalizado el formulario de la lista, sin necesidad de programación.

SharePoint2010_InfoPathCustomForm9

Ahora hemos pasado de tener un formulario estándar como este…

SharePoint2010_InfoPathCustomForm

a este otro con las reglas de InfoPath, el Lookup filtrado y algún cambio en el diseño…

SharePoint2010_InfoPathCustomForm10

Uno de los valores que siempre he defendido de SharePoint, es que, dentro de las posibilidades, ofrezca variedad en el Self-Service. Que los usuarios de SharePoint puedan crear listas, añadir campos, les ofrece muchas posibilidades. Ahora con esta nueva versión, hemos ampliado el menú del Self-Service y los usuarios podrán crear más elementos, más profesionales y sin necesidad de programación.

 

Saludos a todos…

SharePoint 2010. Consultando listas con WCF Data Services

Hoy vamos a empezar una serie de artículos que hablarán sobre los métodos que SharePoint 2010 nos ofrece para acceder a los elementos (listas, documentos, etc.) que almacena desde un cliente externo al servidor.

En la versión 2007 de SharePoint existen unos servicios web que nos permitían realizar consultas sobre las listas. Trabajar con estos servicios web complicaban un poco el desarrollo, ya que no sólo teníamos que conocer el modelo que íbamos a consultar, sino saber construir un lenguaje llamado CAML que nos permitía realizar consultas sobre estos datos.Al final, terminábamos desarrollando un servicio web que utilizando el API de servidor de SharePoint devolvía los datos de las listas con un formato un poco más amigable.

La nueva versión 2010 nos trae alguna novedades. Tenemos nueva API Microsoft.SharePoint.Client y un nuevo servicio que implementa Open Data Protocol usando WCF Data Services. Hoy nos centraremos en este último.

WCF Data Services en SharePoint 2010 ofrece las funcionalidades de la programación de cliente con Data Services, a través del servicio con la url http://<site>/_vti_bin/listdata.svc.

Si accedemos al servicio con un explorador web, obtendremos el Data Service Atom feed con todas las listas del sitio.

SharePoint2010_wcf1

Sin queremos consultar la lista Tasks, con poner la url del servicio seguida del nombre de la lista tenemos (http://<site>/_vti_bin/listdata.svc/Tasks), o incluso podemos obtener el xml de un elemento (http://<site>/_vti_bin/listdata.svc/Tasks(1)). También se incluyen todas las opciones de filtrado (http://<site>/_vti_bin/listdata.svc/Tasks?$filter=Description eq ‘Tarea 1’), ordenación (http://<site>/_vti_bin/listdata.svc/Tasks$orderby=Description desc) y etc.

SharePoint2010_wcf2

Peor esta no es la idea, está bien poder hacer consultas con el navegador, pero con un par de líneas de código podemos realizar consultas de este tipo o incluso de actualización de los elementos.

Abramos Visual Studio 2010 (o incluso Visual Studio 2008 SP1) y en un proyecto de consola agregamos la referencia de servicio a la url del mismo (http://<site>/_vti_bin/listdata.svc).

SharePoint2010_wcf3

La ventaja de utilizar WCF Data Services para consultar datos en SharePoint es que tendremos un Strongly Type DataContext y Strongly Type List (en el Servicio Web clásico de Sharepoint todas las listas son del mismo tipo y no tenemos diferencia entre ellas). WCF Data Services crea un modelo relacional de objetos para cada lista del sitio que estemos consultando.

Para realizar una consulta sobre la lista Tasks, sólo tendremos que instancia el HomeDataContext y realizar la consulta con LINQ.

   1: Uri intranetUri = new Uri("http://intranet.contoso.com/_vti_bin/listdata.svc", UriKind.Absolute);

   2:  

   3: IntranetService.HomeDataContext context = new IntranetService.HomeDataContext(intranetUri);

   4:  

   5: context.Credentials = System.Net.CredentialCache.DefaultCredentials;

   6:  

   7: IQueryable<IntranetService.TasksItem> tasks = from t in context.Tasks

   8:                                         where t.Title.Contains("Tarea")

   9:                                         select t;

  10:  

  11: foreach (var item in tasks)

  12: {

  13:     Console.WriteLine("ID {0} - Title {1}", item.ID, item.Title);

  14: }

  15:  

  16: Console.ReadLine();

Igual de simple lo tenemos para realizar inserciones o actualizaciones en la lista.

   1: IntranetService.TasksItem task = new IntranetService.TasksItem();

   2: task.Title = "Tarea 2 desde consola";

   3: task.StartDate = DateTime.Now;

   4: task.Created = DateTime.MinValue;

   5: task.Modified = DateTime.MinValue;

   6:  

   7: context.AddToTasks(task);

   8:  

   9: context.SaveChanges();

 

Aunque sigamos teniendo los clásicos Servicios Web (/_vti_bin/Lists.asmx) para consultar listas, este nuevo servicio con WCF Data Services nos proporciona un modelo de objetos relacional y un contexto que se encarga de realizar las consultas sobre el servicio.

 

Saludos a todos…

POCO Template para Visual Studio Beta 2

El equipo de ADO.NET acaba de publicar una nueva actualización de las plantillas que generan las clases POCO de nuestras entidades.

Las podemos descargar desde el Extension Manager de Visual Studio 2010 o desde las páginas de Visual Studio Gallery (c# o vb).

Estas plantillas nos permiten generar el código de las clases POCO y del ObjectContextl utilizando las plantillas T4.´

Si queremos más información sobre esta plantilla, la podemos leer en el blog de ADO.NET Team.

 

Saludos a todos…

Más rápido con Visual Studio 2010. Shortcuts

Vamos a recordar y aprender algunos de los Shotcuts que existen en Visual Studio 2010 que nos permiten ser más productivos, ahorrándonos levantar la mano del teclado y coger el ratón (que vagos que somos!).

Comment and Uncomment código (Ctrl-k-c y Ctrl-k-u)

Para comentar o descomentar las líneas de código que tengamos seleccionadas, tenemos la combinación de teclas Ctrl-k-c, para comentar, y Ctrl-k.u, para descomentar.

RapidoVS2010-Shortcuts1

También lo podemos utilizar con ficheros xml, aspx, etc.

RapidoVS2010-Shortcuts2

Toggle Outlining (Ctrl+m+m)

Para alternar la esquematización de un bloque de código, pulsaremos Ctrl+m+m, bien para cerrar o bien para abrir el esquema de código. Si lo que queremos es cerrar todos los esquemas de nuestro código, pulsamos las teclas Ctrl+m+l.

RapidoVS2010-Shortcuts3

Code Snippets (Ctrl+k+s)

Si queremos seleccionar un snippets de la lista, pulsamos Ctrl+k+s.

RapidoVS2010-Shortcuts4

View Call Hierarchy (Ctrl+k+t)

Para ver la jerarquía de llamadas de un método, nos posicionamos sobre el y pulsamos Ctrl+k+t.

RapidoVS2010-Shortcuts5

Esta ventana nos permite encontrar los lugares donde se llama a un método determinado, que es similar a cómo funciona actualmente buscar todas las referencias. Sin embargo, a diferencia de buscar todas las referencias, la función de Call Hierarchy proporciona mejor comprensión y más detallada acerca de las llamadas.

Un método (o una propiedad o un constructor) se muestra como una raíz en el treeview. Podemos expandir el nodo para obtener una lista de “categorías de búsqueda”. Actualmente se admiten cuatro categorías de búsqueda:

  • Calls To – “entrante” llama a este miembro
  • Calls From – “saliente” llamadas mencionadas en el cuerpo de este miembro
  • Overrides – disponible sólo para miembros abstractos o virtuales
  • Implements – sitios donde se implementa un miembro de la interfaz

Las ventajas de Call Hierarchy frente a buscar todas las referencias es que permite explorar y profundizar en múltiples niveles en el gráfico de llamadas (del llamador encontrar llamador etc..) Por último, el panel de detalles muestra información sobre los sitios de llamada concretas, si un método se llama varias veces en el cuerpo del método que realizó llamada.

 

Saludos a todos…

Más rápido con Visual Studio 2010. Navegación y Búsquedas

Una nueva funcionalidad en Visual Studio 2010 es la ventana de Navegación (Navigate To – Ctrl+,). Esta ventana nos permite realizar búsquedas incrementales en las clases, ficheros, variables y miembros de nuestra solución, para luego,  al seleccionar, abrir el elemento y navegar hasta él.

RapidoVS2010-NavigateTo1

Navigate To realiza la localización de los elementos en nuestro código utilizando capacidades de búsqueda “fuzzy”. Por ejemplo, si buscamos Calendario laboral o laboral calendario es capaz de recuperar los elemento que coincidan con esa búsqueda, incluso cuando el elemento se llame CalendarioLaboral o incluso exista una clase Laboral en el namespace Calendario.

RapidoVS2010-NavigateTo2

También es capaz de realizar búsquedas con el formato Pascal Casing. Sólo tenemos que escribir las letras mayúsculas de nuestros tipos o miembros y automáticamente filtrará los resultados a las coincidencias de esta nomenclatura.

RapidoVS2010-NavigateTo3

Cuando seleccionamos un resultado de la búsqueda, nos mostrará el elemento marcándolo diferenciándolo del resto de nuestro código.

RapidoVS2010-NavigateTo4

Otra funcionalidad que nos aporta rapidez en el día a día, es la posibilidad de Navigate Backward (Navegar hacia atrás con Ctrl+-) o Navigate Forward (hacia adelante con Ctrl+Shift+-) en las posiciones en las que nos encontramos en nuestro código. Por ejemplo, si realizamos un Go To Definition (Ir a la definición de un tipo o clase con F12) y queremos volver a nuestro punto de partida, sólo tendremos que realizar la acción Navigate Backward. También podemos utilizar los botones de la barra de herramienta.

RapidoVS2010-NavigateTo5

También podemos realizar búsquedas de la palabra seleccionada o de la palabra en la que se encuentre el cursor sin necesidad de abrir el diálogo de búsqueda. Para ello sólo tenemos que posicionarnos en la palabra y pulsar Ctrl-F3, para búsquedas hacia adelante, y Ctrl+Shift+F3, para búsquedas en orden inverso o hacia detrás.

RapidoVS2010-NavigateTo6

Por ejemplo, si nos posicionamos en el primer String del código anterior, y realizamos una búsqueda hacia adelante con Ctrl+F3, se nos resaltará la primera coincidencia de la palabra String que encuentre en nuestro código.

RapidoVS2010-NavigateTo7

Espero que este pequeño resumen sobre navegación en Visual Studio nos permite ser más rápidos para localizar y navegar por nuestras soluciones.

 

Saludos a todos…

Self-Tracking en Entity Framework 4.0

Una de las nuevas características que se han desarrollado en Entity Framework 4.0, es la posibilidad de usar entidades Selft-Tracking. Las entidades Self-Tracking son clases que no tienen dependencia de Entity Framework, pero que incluyen mecanismos que gestionan los cambios es sus propiedades.

Estas entidades nos permiten enviarlas a un cliente (por medio de WCF, por ejemplo), realizar cambios sobre ellas y recibirlas conociendo que cambios se han realizado, sin necesidad de consultar el contexto. Con estos cambios y con algunas nuevas funcionalidades de Entity Framework 4 se obtiene un mejor rendimiento cuando persistimos las entidades en el contexto.

Cada clase de nuestro modelo implementa la interfaz IObjectWithChangeTracker, que tiene los métodos necesarios para gestionar los cambios (Unchanged, Modified, Added o Deleted), y no sólo gestiona los cambios, sino que también mantiene los valores originales.

Para generar las entidades Selft-Tracking nos tenemos que instalar la CTP2 de Entity Framework, que la podemos descargar aquí.

Una vez instalada la CTP2, tendremos una nueva opción en nuestro modelo (fichero edmx) que nos permite añadir un nuevo elemento de generación de código.

EF_SelfTracking1 

y en la ventana de nuevo elemento, tenemos la opción del generador de entidades Selft-Tracking de ADO.NET (ADO.NET Selft-Tracking Entity Generator)

EF_SelfTracking2

¿Qué hemos conseguido con esto? Bueno, si revisamos nuestro Solution Explorer, podemos observar que se han creado dos nuevos elementos, ClientesModel.Context.tt y ClientesModel.Types.tt.

EF_SelfTracking3

Estos dos nuevos ficheros son plantillas de texto T4 que se utilizan para generar código. Estas plantillas generan las clases necesarias para Selft-Tracking, tanto para el Contexto como para nuestras entidades del modelo. Más información sobre plantillas T4 en el siguiente post.

Ahora tenemos generados el código necesario para nuestro Selft-Tracking Context y para nuestras Entidades Self-Traking, pero ¿es recomendable dejar nuestras entidades en el mismo proyecto que nuestro contexto? Si lo que queremos es desarrollar una aplicación N-tier, la respuesta es no, lo ideal, para poder reutilizarlo en todas nuestras capas, sin dependencias de Entity Framework, sería separar la plantilla ClientesModel.Types.tt en otro proyecto para que pueda ser utilizado en cualquier capa de nuestra aplicación.

Veamos cómo debería de quedar.

EF_SelfTracking4

Al separar nuestras entidades (ClientesModel.Types.tt), tendremos que hacer ciertos cambios en estas plantillas para que la generación y las referencias sean las correctas.

  1. Añadimos en el proyecto Data la referencia al proyecto Model.
  2. Las entidades Self-Tracking se generan con la capacidad de que puedan ser serializadas, necesitaremos añadir la referencia a System.Runtime.Serialization al proyecto Model.
  3. Modificamos la plantilla ClientesModel.Types.tt para que genere nuestro modelo a partir del fichero edmx. Cambia la ruta de la variable string inputFile = @”ClientesModel.edmx” a @”..EfTracking.DataClientesModel.edmx”.
  4. Por último, modificamos la plantilla ClientesModel.Context.tt para que incluya los using necesarios para que utilice nuestras entidades que están en el namespace EfTracking.Model. Buscamos las dos secciones de using que se encuentran en la plantilla y añadimos la nuestra.

Con estos cambios, conseguimos distribuir nuestras entidades, incluyendo la plantilla de generación del código, en otro proyecto (dll) para su reutilización en cualquiera de las capas (cliente, servicio, datos, etc.). Al incluir la plantilla, mantenemos su funcionalidad que nos permitiría modificar nuestro Entity Framework (fichero edmx) y que se reflejen los cambios en las entidades Self-Tracking.

Si nos creamos un servicio que utilice las entidades y el contexto, con Self-Tracking podemos obtener nuestra entidad y realizar la actualización de la misma, utilizando el siguiente método:

   1: public Model.Contact UpdateContact(Model.Contact contact)

   2: {

   3:     using (var context = new Data.ClientesEntities())

   4:     {

   5:         context.Contacts.ApplyChanges(contact);

   6:         context.SaveChanges();

   7:      

   8:         return contact;

   9:     }

  10: }

 

El método ApplyChanges es una nueva funcionalidad que permite enlazar las entidades e interpretar los cambios realizados para persistirlos a nuestro contexto.

Tenemos que tener en cuenta que implementando la funcionalidad de Self-Tracking en nuestra aplicación, limitamos la interoperabilidad de nuestra aplicación ya que no podemos asegurar que la funcionalidad de Self-Tracking sea manejada por clientes no .NET.

Sin embargo, siempre hay que valorar si necesitamos esta nueva funcionalidad frente a poder interactuar con otros sistemas que no la pueden implementar.

 

Saludos a todos…

POCO en Entity Framework 4.0

La próxima versión de Entity Framework 4.0 permitirá la opción de trabajar con nuestras clases POCO. Ahora podremos desarrollar nuestras aplicaciones N-tiers reutilizando nuestros objetos en cualquiera de las capas, ya que estos serán objetos planos sin referencias algunas a Entity Framework.

Vamos a ver un pequeño ejemplo de cómo sería crear un modelo a partir de nuestras clases POCO, que podrían ser como estas:

EF_POCO1

Este modelo se ha generado con el diseñador de entidades (bien utilizando el método Model-First o el método Generar desde la base de datos). Las clases para estas entidades serían las siguientes:

   1: public class Customer

   2: {

   3:     public int Id { get; set; }

   4:     public String Name { get; set; }

   5:     public String Address { get; set; }

   6:     public IList<Contact> Contacts { get; set; }

   7: }

   1: public class Contact

   2: {

   3:     public int Id { get; set; }

   4:     public String Name { get; set; }

   5:     public String PhoneNumber { get; set; }

   6:     public Customer Customer { get; set; }

   7: }

Si vemos las propiedades de nuestro fichero edm (no de nuestro modelo), tenemos una nueva propiedad que nos permite especificar la herramienta que vamos a utilizar para generar nuestro código, por defecto utiliza EntityModelCodeGenerator.

EF_POCO2

Para poder utilizar nuestras propias clases POCO, tenemos que dejar vació el Custom Tool, para que no genere ningún código con el ObjectContext de Entity Framework.

Al especificar que no queremos que nos genere un ObjectContext, tendremos que crearlo nosotros, definiendo todas las colecciones que queremos utilizar en nuestras consultas.

Un ObjectContext podría ser el siguiente:

   1: public class ManagerEntities : ObjectContext

   2: {

   3:     private ObjectSet<nTierTest.Model.Contact> _contacts;

   4:     private ObjectSet<nTierTest.Model.Customer> _customers;

   5:  

   6:     public ManagerEntities()

   7:         : base("Name=ManagerEntities")

   8:     {

   9:         DefaultContainerName = "ManagerEntities";

  10:         ContextOptions.LazyLoadingEnabled = true;

  11:         _contacts = CreateObjectSet<nTierTest.Model.Contact>("ManagerEntities.Contact");

  12:         _customers = CreateObjectSet<nTierTest.Model.Customer>("ManagerEntities.Customer");

  13:     }

  14:  

  15:     public ObjectSet<nTierTest.Model.Contact> Contacts

  16:     {

  17:         get { return _contacts; }

  18:     }

  19:  

  20:     public ObjectSet<nTierTest.Model.Customer> Customers

  21:     {

  22:         get { return _customers; }

  23:     }

  24: }

Los nombres de las entidades las podemos ver en nuestro modelo, incluyendo el DefaultContainerName que lo tenemos en la propiedad Entity Container Name.

Con este contexto, podemos realizar consultas sobre nuestras entidades y nos devolveran colecciones de nuestras clases POCO.

   1: var context = new nTierTest.Data.ManagerEntities();

   2:  

   3: List<nTierTest.Model.Customer> customerList = (from c in context.Customers

   4:                                                select c).ToList();

   5:  

   6: var contacts = from c in context.Contacts

   7:                where c.Customer.Id == 1

   8:                select c;

Lo siguiente sería crear los métodos necesarios para añadir entidades al contexto, validadores para nuestras clases, etc.

   1: public void AddCustomer(nTierTest.Model.Customer customer)

   2: {

   3:     _customers.AddObject(customer);

   4: }

Aunque este es un ejemplo muy simple de como configurar POCO con Entity Framework, nos da una idea de las nuevas opciones que se nos abren para el desarrollo de nuestras aplicaciones.

 

Saludos a todos…

Más rápido con Visual Studio 2010. Zoom y Búsqueda incremental

Zoom

El equipo de desarrollo de Visual Studio 2010, intentando mejorar la experiencia del usuario (este término que tan de moda se ha puesto), nos permiten, en el nuevo IDE desarrollado con WPF, la posibilidad de hacer Zoom en los editores de código.

Para esta acción, tenemos varias posibilidades:

Seleccionar el nivel de Zoom en el indicador de la ventana activa.

RapidoVS2010-Zoom1

Utilizar el ratón (Ctrl+Mouse Wheel)

Para esto sólo tenemos que mantener pulsado la tecla Ctrl y girar la rueda del ratón para hacer Zoom-In o Zoom-Out, igual que si lo hiciéramos en Internet Explorer o en Word.

Utilizar los Keyboard Shorcut para hacer zoom.

Zoom-In Ctrl+Shift+punto
Zoom-Out Ctrl+Shift+coma

Búsqueda incremental

La búsqueda incremental se utiliza para localizar un texto de manera rápida en el documento que tenemos abierto. Es muy eficaz porque sólo tenemos que escribir lo que queremos buscar, sin necesidad de interactuar con el IDE.

Cuando pulsamos las teclas Ctrl+i, se activa esta búsqueda y podemos empezar a escribir el término que queremos localizar.

Según vamos escribiendo, podremos ver que el cursos se ha posicionado en la primera ocurrencia de la búsqueda y la ha remarcado para que la localicemos mejor.

RapidoVS2010-Incremental1

Podemos ver el termino que está buscando en la barra de progreso del IDE.

RapidoVS2010-Incremental2

Cada vez que pulsemos las teclas Ctrl+i, el cursor se posicionará en la siguiente ocurrencia, y así sucesivamente. Para posicionarnos en la ocurrencia anterior, sólo tendremos que pulsar Ctrl+Shift+I, si queremos borrar un caracter del texto buscado pulsamos la tecla Backspace y cuando queramos finalizar la búsqueda solo tendremos que pulsar ESC.

Y hasta aquí dos características, una de ellas nuevas, de Visual Studio 2010 que nos ayudarán en nuestro día a día.

 

Saludos a todos…

Más rápido con Visual Studio 2010. Intellisense para TDD

En Visual Studio 2010 tenemos dos modos de Intellisense, Suggestion y Standard Completion. El modo Completion se usa cuando nuestras clases, métodos o miembros están definidos, Suggestion es el llamado ”TDD Friendly” y ahora veremos por qué.

RapidoVS2010-Intellisense1

Cuando escribimos código con el modo Completion activado, intellisense nos muestra la lista de miembros existentes pertenecientes a la búsqueda de lo que estamos escribiendo. Si aceptamos la selección, pulsando alguna de las teclas predefinidas para ello (Tabulados, punto y coma o enter), se quedará escrito el elemento de la lista que esté seleccionado en ese momento.

RapidoVS2010-Intellisense2

 

 

Sin embargo, cuando escribimos con el modo Suggestion, activándolo con la combinacion Ctrl-Alt-Space, el comportamiento de intellisense es distinto. Aunque nos muestra la lista de miembros existentes que estamos buscando, a esta lista se ha añadido un cuadro de texto que va escribiendo lo que nosotros hemos escrito y no tenemos seleccionado ningún elemento de la lista. Esto nos permite elegir si queremos un elemento de la lista o si queremos el texto que hemos escrito y que nos lo previsualiza en el cuadro de texto.

RapidoVS2010-Intellisense3

Este pequeño cambio, nos ayudará cuando estemos con TDD o escribiendo métodos que no existen y los crearemos más adelante.

 

Saludos a todos…

Más rápido con Visual Studio 2010. Reemplazo multi-línea

Empezamos con una serie de artículos para escribir código mejor y más rápido con Visual Studio 2010.

Visual Studio 2010 nos permite seleccionar un bloque de texto presionando la tecla ALT.

RapidoVS2010_2D00_Reemplazo1[1]

Una que lo tenemos seleccionado, podemos escribir para reemplazar el texto seleccionado en todas las líneas a la vez.

RapidoVS2010_2D00_Reemplazo2[1]

Esto nos permite hacer cambios en nuestro código rápido y en varias líneas simultáneamente.

 

Saludos a todos…