Diario de un Dotnetero

Microsoft anuncia Visual Studio 2010 y .NET Framework 4.0

2008-10-01T12:06:00.001-06:00

Ayer Microsoft se adelantó al PDC y anunció que Visual Studio 2010 (también conocido por Visual Studio 10 o “Rosario”) y el .NET Framework 4.0 estarían disponibles a finales del 2009 o principios del 2010—seguramente para coincidir con el lanzamiento de Windows 7, tal como lo hicieron con .NET 3.0 y Windows Vista.

Lo curioso, sin embargo es que no dió muchos detalles al respecto. Según esta página en MSDN, los “pilares” de esa versión son [interpretación mía]:

Democratizar el ciclo de desarrollo. Que en términos prácticos parece que se trata de incorporar aún más modelación en Visual Studio, incluyendo—finalmente—diagramación en UML. Checa este video en Channel 9 al respecto. Parece que también van a mejorar algunas de las herramientas de pruebas y documentación, sobre todo para poder reproducir pulgas elusivas.
Facilitar las tecnologías emergentes. No sé exactamente a qué se refieran, ¿quizá soporte nativo a Silverlight 2 y cosas así? ¿Facilitar cosas de cloud computing? ¿Desarrollo para mulitprocesadores/multicore?
Inspirar deleite en los desarrolladores. Esto me suena a puro marketingspeak
Seguir la ola de plataformas de próxima generación. Esto pudiera referirse a tecnologías asociadas con Windows 7 o Server 2008 R2, o a cosas relacionadas con Live Mesh—parte de la iniciativa de cloud computing de Microsoft—que estoy seguro también tendrán algo de integración.
Aplicaciones departamentales avanzadas. Supongo que se enfocarán a facilitar el desarrollo no solo de “aplicacionzotas” sino también “aplicacioncitas”—que luego crecen como monstruos y luego las quieren usar en todos lados. ¿Significa que integrarán algunos pricipios de Access?

Hay una serie de videos ya en Channel 9 acerca de VS 2010. El blog de Arturo también tiene algo más de información en español al respecto.

Enjoy

Videos en español de Visual Studio 2008 y más por Channel 9

2008-10-01T11:27:00.001-06:00

Para los que no lo conocen, Channel 9 es un sitio de Microsoft para desarrolladores donde puedes encontrar un montonal de videos—y más importante creo—opinar sobre muchas de las tecnologías que maneja la compañía.

La mayoría de los videos están en inglés, pero hoy descubrí que si juegas con los tags puedes obtener un listado de los videos que está en español. Este enlace te da dicho listado:

http://channel9.msdn.com/tags/Spanish/

Ahí encontrarás videos sobre Visual Studio 2008, Expression Web, incluso uno que otro sobre Silverlight y Expression Blend.

Por ejemplo, parece que acaban de sacar una serie de cinco partes sobre Expression Web—uno de los productos de la familia Expression diseñados para hacer desde sitios HTML hasta sitios con páginas ASP.NET.

Enjoy

Cómo transformar XML sin usar XSLT

2008-09-04T00:01:00.000-06:00

El otro día, una compañía externa hizo un una auditoría de seguridad a un sistema grande que manejamos. Parte de la auditoría consistió en correr la herramienta FxCop contra las DLLs para buscar—entre otras cosas—posibles vulnerabilidades de inyección de SQL. FxCop produce dichos reportes en XML y eso fue lo que nos entregaron.

Estos reportes eran enormes y en un formato no muy amigable, así que necesitábamos de alguna forma extraer los datos de ahí para enfocar los esfuerzos de los desarrolladores (qué corregir y en dónde), y también para tabular los datos (número de issues por namespace, DLL, etc.) de manera que se les pudieran presentar a los gerentoides.

Este es un ejemplo de uno de esos archivos—no te preocupes, todas estas vulnerabilidades ya fueron parchadas, este es un extracto de esos reportes .

(Da clic a la imagen para ver un tamaño más grande)

Ahora, se me ocurrió que estos archivos se podían transformar a algo más “plano”—como otro archivo de XML o un CSV—de manera que pudiera ser importado a Excel fácilmente. Algo así como lo siguiente:

<?xml version="1.0" encoding="utf-8" standalone="yes"?>

<Vulnerabilities>

  <Vulnerability>

    <Module></Module>

    <Namespace></Namespace>

    <Type></Type>

    <Method></Method>

    <Issue></Issue>

  </Vulnerability>

  <Vulnerability>

    <Module></Module>

    <Namespace></Namespace>

    <Type></Type>

    <Method></Method>

    <Issue></Issue>

  </Vulnerability>

</Vulnerabilities>

La sola idea de hacer una hoja de estilos XSL para transformar eso me daba escalofríos, así que fue una buena oportunidad para practicar mi LINQ-Fu. Para ello me ayudé de LINQPad—una excelente herramienta para probar snippets de LINQ.

Armando el query

Mi primer query fue este:

XElement xml = XElement.Load(@"C:\Users\Carlos\Desktop\sampleFxCopReport.xml");

var query =

    from e in xml.Descendants("Issue")

    where e.Ancestors("Message").Attributes("TypeName").First().Value == "ReviewSqlQueriesForSecurityVulnerabilities"

    select new

        Module = e.Ancestors("Module").Attributes("Name").First().Value,

        Namespace = e.Ancestors("Namespace").Attributes("Name").First().Value,

        Type = e.Ancestors("Type").Attributes("Name").First().Value,

        Method = e.Ancestors("Member").Attributes("Name").First().Value,

        Issue = e.Value

};

Como puedes ver, cargar el archivo es trivial. Puedes hacerlo a través del método Load() de la clase XElement o XDocument.

Luego, declaré una variable de tipo var porque no estaba seguro exactamente del tipo de los objetos que regresaría mi query—utilicé un tipo anónimo, el cual explicaré en un minuto.

Si no estás muy familiarizado con queries de LINQ, solo recuerda que en su nivel más básico, tienes un from/where/select.

Primero le dices a qué objetos quieres hacerle query (from),
luego especificas un filtro que deje solo los que te interesen (where) y
finalmente le indicas una expresión de cómo quieres proyectar tus datos en la salida (select).

En este caso, se me hizo más fácil elegir primero todos los elementos <Issue> dentro del documento XML, ya que a partir de ellos puedo obtener el resto de la información viendo los nodos ancestros. Logré hacer esto con una sola línea en el from gracias al método Descendants() de la clase XElement. En otras palabras estoy diciendo “selecciona los elementos <Issue> en el documento, y por cada uno de ellos dame una variable e de donde extraer más información”. Puedes pensarlo como algo parecido a un foreach.

Luego, indiqué en el filtro where que únicamente deseo los <Issue> donde el mensaje (<Message>) sea de tipo vulnerabilidad de SQL (TypeName=”ReviewSqlQueriesForSecurityVulnerabilities”). Como los elementos <Message> son ancestros de <Issue>, utilicé Ancestors() para acceder a ese elemento y luego Attributes() para obtener el valor de atributo TypeName y poder hacer la comparación.

Finalmente, en la proyección el select new crea un tipo (una clase pues) sin nombre con 5 propiedades, que son inicializadas con los valores de las expresiones. Esto crea una collección de tipo IEnumerable<T> donde T es el tipo anónimo—¿ves por qué fue necesaria la variable var?

El resultado del query es este (da clic para ver la imagen más grande):

Pero, ¿qué tal si quisiera ordenar mis resultados primero por Module, luego por Namespace, Type y Method sucesivamente? Sencillo. Puedo agregar una cadena de OrderBy’s a mi query original o puedo agarrar el resultado del query y ordenarlo así:

var ordered =

    query.OrderBy(x => x.Method).OrderBy(x => x.Type)

    .OrderBy(x => x.Namespace).OrderBy(x => x.Module);

Esta manera de hacerlo involucra las famosas expresiones lamda, pero no me quiero desviar en explicarlas. Por ahora sólo tómalas como ejemplo y nota que puedes encadenar las cláusulas.

Esto es un buen comienzo, pero ahora quiero esos datos en algo que se le parezca a un documento XML.

Entonces agregué esto después de mi query:

XDocument xdoc = new XDocument();

xdoc.AddFirst(new XElement("Vulnerabilities"));

foreach (var element in query)

    xdoc.Root.Add(

        new XElement("Vulnerability", new XElement("Module", element.Module)

                                    , new XElement("Namespace", element.Namespace)

                                    , new XElement("Type", element.Type)

                                    , new XElement("Method", element.Method)

                                    , new XElement("Issue", element.Issue)

));

Primero creo un nuevo documento XML utilizando la clase XDocument, y le agrego un elemento raíz <Vulnerabilities>. Luego por cada elemento de mi lista ordenada, agrego un elemento <Vulnerability> que contendrá cinco elementos, uno por cada propiedad que me interesó, y que tendrán el valo. Nota que los constructores “raros” de XElement facilitan enormemente la tarea, y que los métodos AddFirst() y AddNew() se encargará de cerrar los elementos adecuadamente—a diferencia de la forma en que se utiliza un XmlWriter, por ejemplo.

El resultado:

Esto ya es prácticamente lo que quiero. Sin embargo, mi código hasta ahorita son como 30 líneas—principalmente por el formato, en realidad solo he utilizado como 7 instrucciones—y me gustaría condensar el código más. Además descubrí que el ordenamiento en realidad no lo necesito—puedo hacerlo en Excel—y que al documento XML le falta la declaración <?xml> al pricipio.

Sintetizando el código

Así que decidí cambiar la proyección (el select pues) de mi query original. El total del código quedó así:

XElement xml = XElement.Load(@"C:\Users\Carlos\Desktop\sampleFxCopReport.xml");

IEnumerable<XElement> query =

    from e in xml.Descendants("Issue")

    where e.Ancestors("Message").Attributes("TypeName").First().Value == "ReviewSqlQueriesForSecurityVulnerabilities"

    select new XElement("Vulnerability",

        new XElement("Module", e.Ancestors("Module").Attributes("Name").First().Value),

        new XElement("Namespace", e.Ancestors("Namespace").Attributes("Name").First().Value),

        new XElement("Type", e.Ancestors("Type").Attributes("Name").First().Value),

        new XElement("Method", e.Ancestors("Member").Attributes("Name").First().Value),

        new XElement("Issue", e.Value)

);

XDocument xDoc = new XDocument(

    new XDeclaration("1.0", "UTF-8", "yes"),

    new XElement("Vulnerabilities", query)

);

Nota que con solo 2 instrucciones—la instrucción de carga no cuenta—logré hacer la transformación (¡!) . Veamos los cambios significativos al query.

Primero, el resultado es almacenado en una variable que ya no es tipo var, sino IEnumerable<T> donde T es XElement. Esto es porque en la proyección (el select) ya no estoy utilizando un tipo anónimo para construir un objeto, sino los constructores de la clase XElement para obtener objetos de este tipo.

Finalmente, a la hora de crear el nuevo documento XML, utilizo también un constructor alterno de XDocument, para primero pasarle la declaración XML, y agregarle un elemento <Vulnerabilities> que tendrá como contenido el resultado de mi query—la lista de nodos <Vulnerability> con sus respectivos elementos hijo. ¿Así o más mágico?

[Pronunciarse en tono de vendedor de chuchulucos por T.V.:] ¡Pero aún hay más!

¿Quieres saber lo que se necesita para guardar el nuevo documento de XML a un archivo?

xDoc.Save(@"C:\Users\Carlos\Desktop\transformedReport.xml");

Así que con un total de 4 instrucciones logré cargar un archivo complejo de XML, transformarlo y escribir los resultados a otro más amigable.

[Pronunciarse en tono de vendedor de chuchulucos por T.V.:] ¡Pero aún hay más!

Sintetizándo el código aún más

¿En verdad quieres ponerte quisiquilloso con el query? Puedes lograr la totalidad de la lógica con solo 3 instrucciones—una para cargar el archivo original, otra para transformarlo y una más para guardar el archivo resultante—si utilizas expresiones lambda. Este ejemplo no lo explico porque igual y te acabo confundiendo más, pero creo que ilustra el poderío de LINQ y las nuevas clases para manipular XML.

XElement xml = XElement.Load(@"C:\Users\Carlos\Desktop\sampleFxCopReport.xml");

XDocument xDoc = new XDocument(

  new XDeclaration("1.0", "UTF-8", "yes"),

    new XElement("Vulnerabilities",

      xml.Descendants("Issue")

      .Where(i => i.Ancestors("Message").Attributes("TypeName").First().Value == "ReviewSqlQueriesForSecurityVulnerabilities")

      .Select(e => new XElement("Vulnerability",

              new XElement("Module", e.Ancestors("Module").Attributes("Name").First().Value),

              new XElement("Namespace", e.Ancestors("Namespace").Attributes("Name").First().Value),

              new XElement("Type", e.Ancestors("Type").Attributes("Name").First().Value),

              new XElement("Method", e.Ancestors("Member").Attributes("Name").First().Value),

              new XElement("Issue", e.Value)

);

xDoc.Save(@"c:\users\Carlos\Desktop\transformedReport.xml");

¿Qué tal, eh?

Conclusión

Este artículo mostró un ejemplo de cómo transformar un documento XML utilizando LINQ to XML. También mostró de manera práctica qué son los tipos anónimos (“clases sin nombres”), cómo cargar y escribir archivos XML con las clases XElement y XDocument incluidas en el .NET Framework 3.5, e ilustró brevemente el uso de expresiones lambda. La mayoría de los conceptos—excepto quizá las expresiones lambda—aplican también si estás utilizando Visual Basic como tu lenguaje de desarrollo para .NET.

Enjoy.

[Actualización 04-sept-2008, 3:00 p.m.] Para aquellos que son bien técnicos, los tipos anónimos sí tienen un nombre, solo que este no es elegido por el desarrollador, sino por el compilador, como lo mostró Fernik en su excelente artrículo. En términos prácticos no importa porque normalmente no se ofrece saber cuál es ese nombre. La palabra clave var permite que interactuemos con ellos como si fueran tipos comúnes y corrientes.

Google Chrome beta tampoco me impresiona

2008-09-03T13:30:00.003-06:00

Todo mundo y su abuelita para ahora se ha de haber enterado que Google lanzó su propio browser—Wired tiene un artículo interesante de por qué se tardaron tanto para lanzarlo, cuando para muchas personas era una evolución lógica.

Bajo riesgo repetir artículos anteriores, tengo que admitir que cuando comencé a ver la lista de características “inovadoras” me sorprendió lo no inovadoras que en realidad son:

Omnibox. Básicamente una versión del Awesomebar (Firefox 3) o del Smart Address Bar de IE8 beta2, pero con búsqueda integrada. Moderadamente interesante. Se parece también al search box que trae Flock—y el cual espero fusionen con el Awesomebar para Flock 2 final.
Pestañas independientes. Rara vez se me ha ofrecido que una pestaña haga que truene el navegador. De las pocas veces que me ha sucedido es cuando corro IETab dentro de Firefox, e incluso en esas instancias FF hace buen trabajo en recuperar mi sesión. Pero, la idea es interesante. Tanto que al parecer se le ocurrió lo mismo al equipo de Internet Explorer 8.
Acceso directo a aplicaciones. Un concepto que se me hizo bastante útil, desde que el equipo de Mozilla comenzó con el proyecto Prism hace casi un año (¿?)—y del cual, naturalmente hay una extensión para Firefox.
Pestañas dinámicas. Yo suelo mantener una sola ventana de navegador abierta—si no ¿pa’ qué quiero las pestañas, verdad?—pero si les gusta esta característica, también pueden encontrarla en Safari.
Modo incógnito. O como dijo un amigo mío, modo “p0rn” jejeje—y no que yo lo use, ¿verdad? Hmm… ¿dónde he visto eso? ¡Ah! Qué tal en Safari (conocido como Private Browsing) y en IE 8 beta 2 (conocido como InPrivate).
Marcadores instantáneos. Ver Flock, y FF 3. No digo más.

De lo único que en verdad puedo ver inovador es el motor de JavaScript que le pusieron, V8, que al parecer patea traseros en desempeño. Y aunque algunos autores han argumentado que JavaScript es “solo una parte mínima del Web”, yo les digo: ¿Alguna vez has intentado correr Gmail, Slashdot o Facebook en IE7 o previos contra cualquier otro navegador moderno? JavaScript sí importa, y mucho.

Tratando de no tirar mucho rollo—demasiado tarde, lo sé—sí hubo cosas que me gustaron:

Desempeño. Jala hecho la mater cuando no está detrás de un proxy—lean un poco más abajo.
Google Gears integrado. No tienes que instalar esto por separado para utilizar, por ejemplo, Google Reader en modo offline. No sorprendente, dado que otro producto de Google, pero es útil que lo traiga integrado.
Interfaz minimalista. De las primeras cosas que le hago a Firefox es quitarle todos los botones y cosas extra y si vieran mi pantalla verían que mi arreglo quedó prácticamente idéntico al que usaron en Chrome. Safari también viene de cajón así.
Herramientas de desarrollo Web incluidas. Al igual que Safari, puedes seleccionar un elemento y dar “Inspect Element” para obtener información de CSS, etc.
Búsqueda en la página amigable. Casi igual que la de Safari—¿comienzan a ver un patrón?

Si quisiera resumir “lo bueno” diría que en muchos sentidos, Chrome es como Safari, pero sin el rendereo borroso de fonts en Windows y con Gears integrado.

Lo que de plano no me gusto, y de hecho impide que lo use de tiempo completo:

No le gustan los proxies, sobretodo los que te piden username y password. Ni siquiera puedes instalarlo si estás detrás de un proxy de este tipo. Y el desempeño se va por el caño, con muchas páginas que no se llegan a cargarse completas—no pude correr Gmail, lo cual es el colmo. Esto quizá es de esperarse de un beta—Safari tuvo problemas similares que resolvieron en la versión final—pero por ahora es un dealbreaker para mi.
Fallas de compatibilidad con sitios sociales. Algunas cosas en Facebook y MySpace no funcionan aún con Chrome. Unas simplemente hacen una experiencia menos agradable y otras de plano hacen que no puedas utilizar funcionalidad de estos sitios. MySpace puede irse a chiflar alpistle—es el sitio del demonio en lo que a mi concierne—pero Facebook está bastante bien armado hasta donde sé. Pero si el navegador no jala bien en estos sitios, ¿cuántos chavalos de 12 a 17 años que se la pasan viviendo ahí lo usarían?
No trae soporte para RSS. Solo muestra el XML del feed. ¿Cómo se supone que voy a leer mis noticias?

¿Matará Chrome a IE? Lo dudo. Habrá que ver lo que sucede. En mi opinión esto tomaría tiempo, aunque es interesante que algunos ya le achacan el 3% del mercado después de su lanzamiento. Google es una compañía a la par con los recursos y reputación de Microsoft, lo cual introduce una dinámica interesante, sobretodo para los que desarrollamos aplicaciones Web. Antes probablemente te preocupabas por que tus sitios jalaran en IE o Firefox, si mucho—al pobre de Opera nunca lo han pelado y mucho menos a Konqueror et.al. Ahora que tienes Safari y Chrome en el mercado, creo que finalmente comenzaremos una era donde los estándares en el desarrollo del Web cobren la importancia que debieron tener desde el principio. *Cruzando los dedos para que suceda*

Enjoy.

Visual Studio 2008 Service Pack 1 ya está disponible

2008-08-12T05:43:00.001-06:00

Al menos para suscriptores de MSDN.

Official MSDN Subscriptions Blog : Visual Studio 2008 Service Pack 1 files are also now available

Oh, y también ya soltaron la versión RTM de SQL Server 2008.

¿Qué es lo que agrega?

Visual Studio 2008 SP1 delivers:

Improved WPF designers

SQL Server 2008 support

ADO.NET Entity Designer

Visual Basic and Visual C++ components and tools (including an MFC-based Office 2007 style ‘Ribbon’)

Visual Studio Team System Team Foundation Server (TFS) addresses customer feedback on version control usability and performance, email integration with work item tracking and full support for hosting on SQL Server 2008

Richer JavaScript support, enhanced AJAX and data tools, and Web site deployment improvements

The .NET Framework 3.5 SP1 delivers:

Performance increases between 20-45% for WPF-based applications – without having to change any code

WCF improvements that give developers more control over the way they access data and services

Streamlined installation experience for client applications

Improvements in the area of data platform, such as the ADO.NET Entity Framework, ADO.NET Data Services and support for SQL Server 2008’s new features

[Tomado de esta página, énfasis mía]

Enjoy

Reseña del Lanzamiento de Visual Studio 2008

2008-06-10T19:45:00.001-06:00

Alex Briseño puso una muy buena reseña del evento que tuvimos el pasado martes 27 de mayo, repleto de fotografías, pa’ que vayan a leerla.

La verdad yo me divertí un chorro, a pesar de que quedé exhausto porque me tocó dar 3 pláticas—lo cual implica hablar casi tres horas—me dió mucho gusto ver tanta gente. También se sintió bien padre que que ahora sí tuvimos bastantes cosas que regalar como todos esos paquetes de desarrollador con Visual Studio 2008, SQL Server 2008 y Windows Server 2008, así como los discos de Windows Vista y las suscripciones de TechNet.

Pero lo más chido creo que fue definitivamente el final, cuando nos pusimos a jugar—o a hacer el intento de jugar—boliche y a echarnos unas chelas con toda la raza hardcore que se quedó hasta esa hora.

El momento priceless se lo llevó Sergio, después de ganarle a Alex: “No pos si es la primera vez que juego”... ajá... sí cómo no... jejeje

Cómo acceder a controles dentro de un GridView

2008-06-03T13:07:00.001-06:00

Esta entrada salió como resultado de una pregunta que hicieron en el Foro de la Comunidad .NET. La pregunta, esencialmente, es: ¿Cómo accedo a un control que tengo en una columna templeteada dentro de un GridView de ASP.NET?

Me pareció buena la pregunta, así que hice un pequeño ejemplo para ilustrarlo. Una columna templeteada (TemplateField) es distinta a una normal (BoundField) en que tienes más control sobre los controles que aparecen en la columna. En otras palabras, tú especificas qué quieres que se muestre cuando el renglón está en modo "normal" (ItemTemplate) o cuando está en modo "edición" (EditItemTemplate). Puedes tener múltiples controles dentro de la columna, en lugar de solo uno que represente el dato.

La siguiente página contiene un GridView con tres columnas que vienen de un SqlDataSource. Los datos provienen de la clásica base de datos Northwind. En este caso estoy recuperando datos de la tabla de productos:

<%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default.aspx.vb"

  Inherits="_Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head id="Head1" runat="server">

  <title>Accediendo a Elementos en un GridView</title>

  <style type="text/css">

    #miGrid

      width: 450px;

      float: left;

  </style>

</head>

<body>

  <form id="form1" runat="server">

  <asp:Button runat="server" ID="leerElementosButton" Text="Leer elementos" />

  <div id="miGrid">

    <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="False"

      DataKeyNames="ProductID" DataSourceID="SqlDataSource1"

      EmptyDataText="No hay registros que mostrar.">

      <Columns>

        <asp:BoundField DataField="ProductID" HeaderText="ID Producto"

          InsertVisible="False" ReadOnly="True" />

        <asp:BoundField DataField="ProductName" HeaderText="Nombre Producto" />

        <asp:TemplateField HeaderText="Descontinuado">

          <EditItemTemplate>

            <asp:CheckBox ID="CheckBox1" runat="server"

              Checked='<%# Bind("Discontinued") %>' />

          </EditItemTemplate>

          <ItemTemplate>

            <asp:CheckBox ID="CheckBox1" runat="server"

              Checked='<%# Bind("Discontinued") %>' Enabled="false" />

          </ItemTemplate>

        </asp:TemplateField>

      </Columns>

    </asp:GridView>

    <asp:SqlDataSource ID="SqlDataSource1" runat="server"

      ConnectionString="<%$ ConnectionStrings:NorthwindConnectionString %>"

      ProviderName="<%$ ConnectionStrings:NorthwindConnectionString.ProviderName %>"

      SelectCommand="SELECT [ProductID], [ProductName], [Discontinued] FROM [Products]">

    </asp:SqlDataSource>

  </div>

  <div id="resultados">

    <asp:Label runat="server" ID="resultadosLabel" />

  </div>

  </form>

</body>

</html>

Para acceder, por ejemplo, al CheckBox que está dentro de la columna templeteada, primero necesitas una referencia al renglón, ya que el ID del control se repetirá n veces (una por cada renglón del Grid).

Esto se puede hacer de varias formas, por ejemplo, si tienes un manejador para un evento clic en alguno de los controles dentro del renglón pues en ese caso el sender viene siendo el renglón en sí, entonces únicamente te falta encontrar el CheckBox de ese renglón para leer sus propiedades. Otra forma de hacerlo, como en el siguiente ejemplo, es leer todos los renglones y por cada uno encontrar el CheckBox que le corresponde al renglón:

Partial Class _Default

  Inherits System.Web.UI.Page

  Protected Sub leerElementosButton_Click(ByVal sender As Object, _

    ByVal e As System.EventArgs) Handles leerElementosButton.Click

    Dim grid As GridView = Me.GridView1

    Dim checkBox As CheckBox

    Dim resultado As New StringBuilder

    For Each renglon As GridViewRow In grid.Rows

      checkBox = CType(renglon.FindControl("CheckBox1"), CheckBox)

      If checkBox.Checked Then  'Hacer algo con esta información

        resultado.Append(String.Format( _

          "El renglón {0} está descontinuado <br />", renglon.DataItemIndex))

      End If

    Next

    resultadosLabel.Text = resultado.ToString()

  End Sub

End Class

En resúmen, la idea clave aquí es que el GridView tiene una colección de renglones (de tipo GridViewRow) y cada uno de estos renglones tiene su correspondiente colección de controles que están dentro de ese renglón. El GridViewRow también te da acceso al DataItem que contiene los datos asociados al renglón, en caso de que lo requirieras.

El resultado de correr el código anterior (dando clic al botón) es el siguiente:

Espero les ayude.

Enjoy

Creo que he estado trabajando mucho...

2008-05-15T12:28:00.001-06:00

Me salió esto hoy. Creo que Visual Studio está tratando de decirme algo...

Domina los atajos de teclado para Visual Studio

2008-04-20T15:42:00.002-06:00

Una de las maneras más fáciles de incrementar tu productividad cuando utilizas casi cualquier programa es aprenderte los atajos de teclado—los mentaos keyboard shortcuts, pues. De hecho tengo amigos que odian levantar las manos del teclado cuando están programando. Si alguna vez has usado algún editor de texto como vi, quizá hayas apreciado que una vez que dominas la complejidad de los comandos, en realidad se siente como si estuvieras "platicando" con el editor. Y aunque yo no llegaría al extremo de recomendar que manejes Visual Studio con los comandos de vi, sí recomiendo enormemente que te aprendas algunos de los más comúnes que ya vienen de cajón con el IDE.

El problema es que Visual Studio tiene 8 millones 557,934 comandos. Bueno, quizá algunos menos, pero aún así son un titipuchal. Y lo que es peor, los atajos de teclado cambian de acuerdo a la configuración general de Visual Studio. Esta es la configuración que te pregunta la primer vez que arrancas el IDE o si das Tools>Import and Export Settings...>Reset all settings.

Aquí es donde ayudan algunos documentos de referencia rápida. Si primordialmente desarrollas en Visual Basic, y utilizas esa configuración (Visual Basic Development Settings), aquí hay un PDF de Microsoft que los resume.

Si usas la configuración de Visual C# Development Settings, para desarrollar primordialmente en C#, están este para Visual Studio 2005 y este otro para Visual Studio 2008.

Sin embargo, yo utilizo la configuración para desarrollo general (General Development Settings) porque desarrollo tanto aplicaciones Web como Windows, a veces en C# y a veces en Visual Basic, aparte que ya me había aprendido algunos atajos desde versiones anteriores de Visual Studio. Como no encontré ninguna referencia rápida para esta configuración, creé mi propio documento. Puedes descargarlo del sitio de la Comunidad.

Mi recomendación personal es, no intentes aprenderlos todos de un zopetón. Dice un proverbio: "¿Cómo te comes un elefante? Un bocado a la vez". Así que mejor escoge un grupo de comandos y practica cada uno por separado, repitiéndolo al menos 20 veces. Lo que yo hice fue agarrar una archivo con código y practicar un comando a la vez en diferentes partes del archivo mientras lo "vocalizaba mentalmente" hasta que quedaba grabado en mi memoria muscular. Luego practicaba el siguiente comando hasta terminar el grupo. Al día siguiente me enfocaba en un grupo distinto, y así sucesivamente.

Cómo crear tus propios atajos

Por supuesto, también puedes definir tus propios atajos. Estos atajos pueden ejecutar un comando del IDE o alguna macro que hayas creado para alguna tarea específica. Por ejemplo, hay dos atajos que a mi me ha sido útil definir: uno para comparar el archivo actual contra la versión en el controlador de código y otro para obtener el historial del archivo actual en el controlador de código.

Para definirlos, primero ve a Tools>Options... y luego Environment>Keyboard. Al hacerlo verás la siguiente ventana:

En la parte donde dice Show commands containing, teclea parte del comando, p. ej. "compare". Esto traerá una lista de posibles comandos. En este caso, el que busco es File.Compare. Luego, selecciona el comando adecuado de la lista y pon el cursor en la parte donde dice Press shortcut keys. Presiona la combinación que desees utilizar. Si la combinación ya está siendo utilizada por algún otro comando, esta información será mostrada en la parte de abajo donde dice Shortcut currently used by. En mi caso escogí la combinación Ctrl+Alt+F,C para finalmente darle clic en el botón Assign.

Repite los mismos pasos para el comando File.ViewHistory y utiliza el atajo Ctrl+Alt+F,H—o cualquier otra combinación que más te guste.

En fin, creo que esto da la idea. Enjoy