Agile-Madrid. Septiembre 2010.

De forma sorpresiva me vi con el tiempo libre para ir a la reunión de principio de mes del grupo Agile de Madrid el pasado uno de septiembre. He de reconocer que el saber que, nada menos,  tres MVP de Microsoft iban a asistir a la reunión me despejaron la pereza que siempre me embarga en el último momento y en el sofá de mi casa.
 
La esquina del “lado oscuro”… :)

Los asistentes nos quedamos sorprendidos también al comprobar que nos habíamos juntando un montón (19 personas) y empezamos con las presentaciones justo antes de iniciar el primer tema que trataba sobre “El contrato Agile en la Administración pública”.
Como muy bien reflejó uno de los compañeros, existen dos tipos de contrato:  por Servicios y por Obras. Y el contrato Agile al que nos estábamos referenciando se podría considerar como un contrato por Obra pero con la particularidad de que su alcance y prioridad pueden cambiar.
Yo creo que es impepinable lo de hacer un documento de alcance/tiempo inicial para sentar las bases de la colaboración. Aunque muchos opinen que eso no es una práctica Agile.
También estuvimos de acuerdo en que es necesario un “suelo” de gastos para que las empresas pequeñas y medianas puedan asumir el riesgo de conformar un equipo y no quedarse en perdidas directas por ser paralizado el proyecto en una o dos de las primeras iteraciones.
El debate ha seguido en el foro De Agile-Spain, y está siendo muy interesante.

 
Escogiendo los temas de la próxima reunión.
A continuación entramos a debatir “Cómo vender TDD a los jefes”. Lo cual llevó a la primera conclusión: cuanto menos técnico más fácil de venderlo. Lo cual llevo a la siguiente conclusión, ¿porqué debes venderlo si es una práctica puramente técnica?
Como llevo ya bastante tiempo dubitativo con TDD, pregunté si había alguna mejora en el desarrollo de un proyecto por usar TDD y solamente JMB habló de una cierta métrica que indicaba que los desarrollos con esta técnica son más predecibles. Ante mi pregunta de cuantos utilizaban TDD actualmente, levantaron la mano solamente cinco de las diecinueve personas asistentes (tres de ellos mis “ídolos” de .NET). Por último, las respuestas a las preguntas de David sobre argumentos para convencer a los desarrolladores que utilicen TDD, me llevan a mi conclusión personal:

La Fe es el mejor argumento para pasarse al TDD

Es decir, el saber que gente del nivel de Alfredo o Luís Fraile utilizan TDD, es lo que me puede motivar a utilizar esta técnica. Porque, sin haberla utilizado, la argumentación que la promueva es, a mi entender, poco motivadora ante el enorme esfuerzo que implica el cambio de paradigma.
 

A continuación, y finalizada la reunión, nos fuimos a beber cervecitas al bareto de al lado, y a eso de las once de la noche cogí mi vehículo para volver a mi casa, henchido de conocimiento y con ganas de ir a la próxima.

BrainStorming, Post-Tip & Flight Simulator

Ciertamente una imagen vale más que mil palabras. Y que la Red se ha convertido en la mayor y espectacular fuente de conocimiento de todos los tiempos desde que el hombre salió de la prehistoria al descubrir la escritura es algo que nadie puede negar.

Ahora mismo mi ritmo de evolución profesional está por las nubes intentando terminar la certificación, motivo de la apertura de este blog, empapándome de la nueva tecnología de desarrollo que ha traído .NET 3,5 y en especial el Visual Studio 2008 y, sobre todo, intentando actualizarme en metodologías y herramientas de gestión de proyectos y ALM.

Por ello sigo diversos blogs escritos por las mas variopintas personas y que, centrándose en metodologías, repiten conceptos como el de utilizar una pizarra y un buen montón de post-tip para la toma de requerimientos.

Lo que pasa es que me costaba entender que realmente ESE es el concepto exactamente. No una hipérbole ni una aproximación, sino que es simplemente un grupo de gente alrededor de una mesa en una tormenta de ideas, escribiéndolas en pequeños cuadraditos de papel autoadhesivo y pegándolas en la pizarra.

Y hoy, volviendo a viejísimos tiempos, me encuentro en una página de Microsoft dedicada a su simulador de vuelo Flight Simulator la imagen perfecta que me ha despejado todo tipo de dudas y me ha dejado meridianamente claro el concepto.

El futuro del Flight Simulator esta en las tarjetas

Duet. Office con SAP

Hace casi dos años estuve en un proyecto en donde desarrollábamos una Intranet en .NET que utilizaba como repositorio de datos un sistema SAP/Oracle. Fue un proyecto muy bonito, en donde aprendí muchísimo sobre SAP, encontré buenos amigos con los que aún quedo a comer y que me dejo una agradable sensación de lo bien que funciona SAP con .NET cuando superas las dificultades inherentes de conectar ambos sistemas.

Desde entonces sigo pendiente de todo lo que salga sobre este binomio y por ello quiero referirme a un producto que he encontrado por la blogosfera que interrelaciona SAP con Office consiguiendo, según cuentan, unir lo mejor de ambas partes.

Duet for Microsoft Office and SAP

Si tengo tiempo, le tengo que echar un vistazo para desempolvar mis conocimientos de SAPITO.

Un mes

Bueno, un mes sin escribir. Un mes que han cambiado bastantes cosas en mi trabajo y en mi vida personal que me han echo alejarme de este blog.

Pero ahora vuelvo con más ganas y, espero, con más tiempo.

Siguiente tema: Uso del DataTable.DefaultView para hacer ordenaciones. Y el uso del TryParse para validaciones.

Hasta prontito...

Parámetros mútiples desde un GridView

Ciertamente la programación es una actividad en donde la inspiración va de la mano de la experiencia. Y hay días en donde “te baja la idea del cielo” y encuentras otra forma nueva, por lo menos para ti, de hacer las cosas.

Siempre me habían parecido espantosas las cadenas de parámetros que se envían desde un GridView para editar una fila (siempre que no uses programación visual). Por ejemplo, si tengo un grid como el de la imagen, y quiero mandar información a la ventana de al lado según la fila seleccionada tengo que hacer una “guarrería” como esta:

<asp:ImageButton ID="imgbImageButton" runat="server" CausesValidation="false" 
CommandArgument='<%# Eval("idVehiculo") & "@" & eval("Empleado").toString%>'

Para después con un string.split, cargar cada uno de los argumentos en un array y enviarlo al método adecuado.

Protected Sub gvDatosTabla_RowCommand(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewCommandEventArgs) Handles gvDatosTabla.RowCommand

Dim parametro() As String = Split(e.CommandArgument, "@")

lblDatosDni.Text = parametro(0)

lblDatosEmpleado.Text = parametro(1)

tbDatosImporte.Text = parametro(2)

End Sub

A causa de la lógica de negocio, me veo obligado a que esta ya larguísima cadena se me multiplique por tres y comienzo a comerme el tarro de cómo mejorar simplificar el código.

Y pienso… si tuviera un identificador único en la tabla no habría mayor problema.

A lo cual le he añadido, en la clase que recupera la tabla, un método que le añade una columna en donde almaceno un valor numérico incremental que se inicia en 1.

Private Function idToTable(ByVal tabla As DataTable) As DataTable
Dim id As Integer = 1
tabla.Columns.Add("IdTabla", Type.GetType("System.Int32"))
For Each filas As DataRow In tabla.Rows
filas("IdTabla") = id
id += 1
Next

Return tabla

End Function

Teniendo ya un identificador único, cargo la tabla en una propiedad que almacena en el gridView y ya tengo persistencia.

Public Property tabla() As DataTable
Get
Return ViewState("tabla")
End Get

Set(ByVal value As DataTable)
ViewState("tabla") = value
End Set
End Property

Y ya puedo cargarlo en el dataView para hacer el bind del GridView, teniendo cuidado de además de las columnas que se deben mostrar, incluir una columna oculta con el identificador único.

<asp:BoundField Visible="false" DataField="IdTabla" />

Ahora cuando selecciono una fila para editar ya no tengo que pasar los datos vía CommandArgument, simplemente envío el identificador único que he añadido. Y encuentro todos los valores de esa fila haciendo un select en la tabla.

Protected Sub gvDatosTabla_RowCommand(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewCommandEventArgs) Handles gvDatosTabla.RowCommand

Dim filas() As DataRow = tabla.Select("IdTabla=" & e.CommandArgument)

If filas.Length > 0 Then
Dim fila As DataRow = filas(0)
lblDatosDni.Text = fila("dni") lblDatosEmpleado.Text = fila("empleado")
lblDatosImporte.Text = fila("Importe")
Else
mensaje("No existe la fila seleccionada")
End If

End Sub

Otra enorme ventaja que tengo al usar este método es que puedo acceder a los datos de la fila seleccionada por medio del nombre del campo/columna, en vez del críptico y horroroso sistema de índices del Array.

¿Desarrollo o gestión de proyectos?

Ufff, esta certificación me va a sacar una úlcera y me veo presentándome al examen en Abril.

No por difícil sino porque entre Team system, SCRUM, pruebas unitarias, Wow (nivel 18), no saco tiempo para hacerme los tremendamente tediosos test de la certificación.

Y, recién desembarcado del evento de presentación del Visual Studio 2008 Team System, tengo la terrible duda de si debería haberme centrado en gestión de proyectos y haber dejado los estudios de desarrollo para un momento más dulce.

Pero luego recuerdo las charlas de LINQ, de WCF y toda la marabunta de nuevas capacidades del VST2008 y mi alma de desarrollador {HERO} emerge y me veo estudiando todo el día.

“Sarna con gusto no pica”.

Nuevo libro del Guille

De resaca del TREMENDO evento de presentación de la tecnología 2008 de Microsoft, me encuentro con el anuncio del nuevo libro del Guille que, a mi entender, merece de largo un enlace y publicidad.

Gracias Guille.

dateTime.toBinary

Maravilla de las maravillas haciendo test para la certificación (a este paso me presento en Marzo).

¿Cuántas veces me he encontrado que tenía un servidor en los estados unidos quería controlar el paso del tiempo pero con la hora de España?

Ahora me encuentro que en .NET 2 el tipo para almacenar fechas y horas sido mejorado ya que incluye una nueva propiedad llamada Kind en donde se define si la representación se basa en hora local, en la UTC o en ninguna de ellas. Y gracias a ello puedo hacer una transformación “mágica” que me permite almacenar una fecha/hora de cualquier sitio y que la pueda visualizar de forma automática en la zona horaria en donde lo visualicemos. Sea, donde sea.

Para ello utilizamos dateTime.toBinary que nos convierte el dato en formato binario de 64 bits.

Y lo recupero con dateTime.fromBinary, en donde se transforma del binario de 64 bits a la fecha y hora en el formato y franja horaria del destinatario…!!

Ale, un nuevo juguetito para experimentar cosas.

Confirmación de borrado en un Grid más avanzado.

Hace casi un mes escribí la siguiente entrada que trataba de un método limpio y sencillo de visualizar una ventana de confirmación en javascript desde cualquier control .net que aceptara el oncClientClick.

Hoy traigo la versión más avanzada para realizarlo en un GridView en donde tengamos en una columna un texto descriptivo y en otra un enlace para borrar la fila.
La teoría es añadir al enlace de borrado el parámetro OnClientClick invocando el Javascript que nos saca la alerta y que es:

function fnConfirmacionBorrado(value)
{
return window.confirm('El registro ' + value + ' va ha ser eliminado, ¿Desea continuar?');
}

Despues hacemos el método que borra al entrada físicamente de la fuente de datos y que aquí no voy a describir por ser cansinamente repetitivo. Al que llamaremos borra().

Por último en el momento en que .NET va a ir rellenando fila a fila el GridView, incluiremos el OnClientClick introduciendo el valor de la columna con la descripción como el mensaje ‘value’ que le enviaremos a la función javascript.

Protected Sub gvListado_RowDataBound(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewRowEventArgs) Handles gvListado.RowDataBound

‘ Recuperamos el enlace de eliminar.
Dim eliminar As LinkButton = CType(e.Row.FindControl("lnkEliminar"), LinkButton)

‘ Recuperamos la etiqueta con la descripción
Dim descripcion As Label = CType(e.Row.FindControl("lblDescripcion"), Label)

‘ comprobamos que no sea nothing para que no falle.
If Not IsNothing(eliminar) Then
eliminar.OnClientClick = "return fnConfirmacionBorrado('" & descripcion.Text & "');"
End If

End Sub

Es importante tener en cuenta el detalle que el javascript nos tiene que devolver un valor true o false para invocar o no la funcion borra(), para ello debemos de ponerle el return antes del nombre de la función javascript que nos muestra la ventana de confirmación.

Por último el GridView estaría construido de la siguiente forma:

<'asp:gridview id="gvListado" runat="server">
<'columns>
<'asp:templatefield>
<'headertemplate>Descripción <'/headertemplate>
<'itemtemplate>
<'asp:label id="lblDescripcion" runat="server" text="<%# eval("") %>" />
<'/itemtemplate>
<'/asp:templatefield>
<'asp:templatefield>
<'itemtemplate>
<'asp:linkbutton id=" lnkEliminar " onclick="Borrar" runat="server" text="Eliminar" causesvalidation="false">
<'/itemtemplate>
<'/asp:templatefield>
<'/columns>
<'/asp:gridview>

Felizes reyes magos!!

... y más porque mañana es fiesta!! :D

Añadir item a un combo o utiliza el Intellisense más.

A veces la lógica de la programación con .NET me sorprende. Tiene sentido pero me sorprende.

El que aquí escribe lleva programando suficientes años para haber pasado por varias metodologías empezando por la PPE (Programación Plato de Espaguetis) basada en Goto y Gosub, la dureza del ensamblador con GEM, pasando por los predicados del PROLOG, el lenguaje estructurado del Turbo Pascal, la programación basada en eventos del LINGO, la exasperante simpleza del HTML (que NO es un lenguaje de programación), el tostón retorcido del Java Script y el ActionScript, o el indescriptible XSLT (que ES un lenguaje de programación).

Si ya con el ASP clásico siempre tuve la sensación que me perdía gran parte de la potencia de las capacidades, con .NET tengo la certeza (y más ahora con la certificación) que es un enorme mundo con una lógica muy especial en relación a mis anteriores experiencias.

Todo esto viene a cuento de que estoy haciendo una pequeña aplicación para practicar parte del material que tengo que preparar para el examen de Febrero, y estoy centrado en un menú desplegable.

En la anterior entrada daba un ejemplo del cómo definir qué columnas de un origen de datos para el valor y el texto de un ítem del dropDownList. Obviamente el paso siguiente era incluir una nueva option al principio del combo que tenga como valor el “0” y el texto “Haga una selección”.

Y allí voy yo tan contento diciéndome a mí mismo –esto está chupao, si los ítem son una colección pues le añado un ítem en la posición 0 y san se ha acabao-

dropDownList.DataSource = dataTable

dropDownList.DataValueField = "campo1"

dropDownList.DataTextField = "campo2"

dropDownList.DataBind()

dropDownList.Items.Insert(0,”Haga una selección”)

… pues no. De esta manera efectivamente inserto en la posición 0 la option con el texto elegido, pero también me introduce la cadena como valor. Dita sea, no encuentro la forma de poder introducir un ítem con tres parámetros. Es decir, la posición para insertarlo, el valor y el texto.

Ale, a tirar de San Google, y así me encuentro en algún ejemplo la lógica aplastante a la que me tengo que ir acostumbrando y que no es otra que en .NET TODO es un objeto.

Si invoco el Intellisense me informa que el método Insert tiene dos sobrecargas. Una en donde el ítem es una cadena de texto, como lo hago arriba, y una segunda en donde me admite un entrada tipo ListItem.

La declaración del New de un ListItem tiene varias sobrecargas pero me interesa la tercera que me permite introducir el campo texto y el campo valor.

Y así, y para terminar este largo post, está es una forma elegante de introducir el ítem al principio del combo con los datos del texto y el valor que quiero.

dropDownList.Items.Insert(0, New ListItem("Sin restricción por tipo de matricula", 0))

dataValueField y dataTextField, la potencia de la sencillez.

Bueno, esto es una mini entrada sobre una pequeña capacidad que tienen los controles tipo dropDownList, entre nosotros menús desplegables, que se trata de poderle decir qué campos del origen de datos vamos a utilizar para rellenarlo (Bind).

Veamos el ejemplo y luego lo analizamos:

dropDownList.DataSource = dataTable
dropDownList.DataValueField = "campo1"
dropDownList.DataTextField = "campo2"
dropDownList.DataBind()

Primero tenemos definido un control tipo combo llamado dropDownList y seleccionamos la tabla dataTable como la fuente de datos.

El truco del almendruco viene a continuación, ya que puedo indicarle por medio del nombre del campo de la tabla, cual quiero que sea el que se use para el value y cual para el texto visible.

¿Qué tiene esto de interesante? Pues así a bote pronto puedo traerme una tabla con 50 campos y utilizarla para rellenar diferentes combos al poder definir que columnas usar para cada uno. Lo cual también me lleva a que si lo introduzco en un SELECT CASE, puedo poblar el combo de manera condicional o, incluso de manera aún más interactiva, que se rellenen los menús de acuerdo a eventos de usuario. O, liandola más, que pueda seleccionar más de un value en cada combo (sincronizando la selección con la tabla).

Una capacidad sencillita pero que descarga mucho las llamadas a la base de datos y mejora la dura vida del programador.

P.D. No debería, pero recordaré que un dropDownList no es más que un control .NET que genera el código html tal cual el siguiente:

<.select>
<.option value="value">text
<./select>

En donde se observa en donde se representan cada uno de los dos valores antes mencionados.

Expresiones Regulares, esas grandes desaprovechadas.

He de reconocer que esta certificación cada día me abre las puertas a formas de desarrollar más simples y eficiente. Y también he de reconocer que los programadores tenemos tendencia a si no entendemos el concepto en los primeros quince minutos, olvidarnos del tema y seguir con la cuenta de la abuela.

Esto viene al caso porque hoy estoy liado con un proyecto personal y estoy haciendo la validación de los campos de una clase dentro de un método privado. Y me he acordado del lio de condicionales que tienes que montar para validar un email, y más aún ahora con los subdominios tipo .com.ar o .eu.nom.

Y he vuelto a recuperar una vieja investigación que dejé en su momento y que me ha vuelto aparecer en la certificación. Expresiones regulares.

No voy a hacer un discurso de qué son y porqué son tan raras. Pero si hay que dejar clarísimo que es el método más eficiente, compacto y elegante para extraer información de cadenas alfanuméricas para, por ejemplo, validar que cumple los requisitos necesarios.

En .NET 2.0 está chupado:

Primero importamos la clase System.Text.RegularExpressions, despues creamos una variable del tipo Regex. A continuación la instanciamos con la cadena que contiene la expresión regular… y ya ta!!

Mirad que sencillo:

Private Function compruebaEmail() As Boolean
Dim ok As Boolean = False
Dim r As Regex

r = New Regex("^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$")
ok = r.IsMatch(email)

Return ok

End Function

Lo más lioso, con mucho, es la construcción de la expresión regular en sí, pero para ello existen librerías muy completas en Internet.

A continuación os pongo unos enlaces recomendados:

1. El sitio del “boss” de Visual Basic.Net en España… El Guille:

http://www.elguille.info/regexp/indice.aspx#introRegExp

2. La mejor y más completa librería de expresiones regulares que he encontrado:

http://www.elguille.info/regexp/indice.aspx#introRegExp

3. Wikipedia en Español:

http://es.wikipedia.org/wiki/Expresi%C3%B3n_regular

Eha, a disfrutarlo.

Feliz Año 2008!!!

Oño, me se había olvidado...

Cadenas seguras y POO.

Como en todos los proyectos, en este (la certificación) también me ha pillado el toro y estoy estudiando a marchas forzadas para presentarme al examen en febrero. Por ello he tardado tanto en hacer otra entrada.

Ahora mismo estoy machacando todo el tema de seguridad y me ha llamado la atención la poca o nula información e implementación de buenas maneras con respecto a la seguridad de la información que observo tanto en mi pasado laboral como en las decenas de compañeros con quienes he trabajado.

Ninguno teníamos en cuenta que con traceando la memoria (algo simple y sencillo) se puede acceder a esa información a la que NADIE debería acceder, menos su destinatario.

Por ello un pequeño capítulo al final del temario de seguridad me ha llamado poderosamente la atención y también me ha servido para hacer un poquito de programación orientada a objetos que, vergüenza la mía, tiene poquito que ver con la programación que he realizado antes de este curso.

OBJETIVO: Quiero coger una cadena de texto, y poderla codificar y recuperar de forma sencilla. De forma que nadie la pueda leer en la memoria. Y que cuando la use, desaparezca todo rastro de su contenido.

Pues bien, en antiguos y cercanos tiempos, hubiera escrito dos o tres mil líneas para obtener lo que obtengo con la clase que he escrito a continuación y que me parece de lo más elegante.

Private Class cadenaSegura
‘Declaro dos campos de la clase.
Dim cadena As String = String.Empty
Dim clave As SecureString

‘ En la declaración New instancio una nueva clase SecureString
‘ que me hace almacena el string en memoria pero codificandolo
‘ con DPAPI. Le asigno el texto a el campo cadena y que me
‘ lo codifique.
Public Sub New(ByVal texto As String)
clave = New SecureString
cadena = texto
codifica()
End Sub

‘ Método que codifica el campo cadena dentro de la cadena segura clave.
Public Sub codifica()
For Each letra As Char In cadena
clave.AppendChar(letra)
Next
‘ Hago la clave solo de lectura para que no se pueda modificar por nadie.
clave.MakeReadOnly()

End Sub

‘ Y siguiendo el consejo del Guille, sustituyo el método
‘ toString para que automáticamente me decodifique la
‘ cadena segura almacenada en el campo clave y me lo
‘ devuelva como una cadena de texto.
Public Overrides Function ToString() As String

‘ Como vés no es una tarea directa. Ya que realmente
‘ clave es un puntero que señala una dirección de
‘ memoria a la que se accede por medio de una estructura
‘ tipo IntPtr.
Dim bstr As IntPtr = Nothing
bstr = Marshal.SecureStringToBSTR(clave)
cadena = Marshal.PtrToStringAuto(bstr)

‘ Esto borra la cadena segura sobreescribiendo de ceros
‘ la posición de memoria que ocupaba.
Marshal.ZeroFreeBSTR(bstr)
Return cadena

End Function

End Class

Para mí lo más elegante viene ahora. El cómo usar esta clase.

Instacio la clase mándandole como parámetro el texto que quiero convertir en una cadena segura. Y luego, para recuperar el contenido de la cadena segura, simplemente llamo al método .toString.

Dim texto As New cadenaSegura(TextBox6.Text)
hash.Text = texto.ToString

Que bonita es la POO!!

Políticos y el canon II

Es impresionante acaba de decir una auténtico mentencato que con el canón no será ilegal bajarse la música de internet… y se ha quedado tan pacho. Se acaba de cargar toda la industria de la música Y NI TAN SIQUIERA SE HA DADO CUENTA.

Y los del PP lo único que hacen es política, política y basura. Y le importa una carajo todo esto.

QUE VERGÜENZA SEÑORES DIPUTADOS, QUE VERGÜENZA.

Politicos y el canon, menuda verguenza!!

Hoy estoy muy cabreado con nuestro poder legislativo. Con los políticos y su, cada vez, más lejana percepción de la realidad de la sociedad que le da el pan, y a un precio de oro.

Hoy se celebra el debate sobre la ley de la sociedad de la información, una de las leyes con más repercusión en el futuro de nuestra civilización, y el 90% de los políticos estaban ausentes de sus carísimos escaños y sin darle la importancia merecida al momento histórico que representa este debate.

El señor Labordeta hace un alegato absolutamente estúpido e incoherente y prácticamente alega por aumentar aún más el canon (como decían hoy en Buenafuente, al final nos cobrarán un canon por tener ojos y lengua)!!.

No entiendo qué está ocurriendo con nuestra clase política, ¿es tan difícil entender que al igual que no se puede pedir un Canon sobre el papel, tampoco se puede pedir un canon sobre los DVD? ¿Qué les ocurre a estos señores que están ciegos y sordos en algo tan simple que la inmensa mayoría de los DVD NO SE USAN para copia privada?¿Acaso es TAN DIFICIL entender que no se puede obligar a todo un país el que pague para que cuatro personas no trabajen para tener jubilación? ¿Qué se hacia antes de existir los medios telemáticos, morirse de hambre todos? Pues Julio Iglesias mira que bien vive sin el canon.

Para estos señores esto es algo sin importancia y solo ha valido para demostrar la profunda ignorancia de los políticos que toman decisiones que nos afectan a todos, que oyendo a los grupos de presión cercanos, se olvidan que este canon es absolutamente injusto, inaceptable y profundamente antisocial.

Mi desprecio a estos señores que se supone me representan y que deberían velar por los derechos de todos y no de cuatro.

P.D. Me voy a inscribir en la SGAE y voy a pedir la jubilación anticipada. Porque estoy haciendo el tonto trabajando 41 horas a la semana cuando puedo rascarme las narices toda la vida y que despúes los demás me paguen mi pensión.

Confirmación de borrar en un Grid.

Este truquito lo he visto en un par de cientos de páginas y blog sa través del mundo mundial, pero no me puedo resistir a publicarlo ya que me parece tan simple, tan bonito y tan cómodo que merece la pena dedicar estos minutos en plantarlo a los cuatro lectores que siguen este blog.

Tengo un dataGrid , o gridView, y le he puesto tremendo botonazo para cargarme una fila. Pero haciendo pruebas me encuentro con que he hecho desaparecer media hora de trabajo que me costó introducir un test de pruebas (es una aplicación para gestionar test de autoescuela) sin tan siquiera avisarme de la barbaridad que iba a hacer.

Me acuerdo que ya he visto la solución por algún lado y, efectivamente, está en múltiples sitios pero creo que puedo mejorar la comunicación y explicarlo aún más sencillo.

En javascript hay una serie de métodos que abren una ventana de alerta. Uno de ellos se llama “confirm();” que abre la típica ventana de ¿Estás seguro?

Este caso específico lo he implementado para un botón de un grid, pero nos vale para cualquier control tipo botón o similar.

asp:button id="Button1" runat="server"
CausesValidation="False"
CommandName="Delete"
Text="Borrar"
CssClass="boton"
OnClientClick="return confirm('¿Está seguro de borrar esta Pregunta?');" />

Como vés es un botón normal y corriente, con un CommandName al estar integrado en un Grid. De aquí solamente hay que quedarse con la copla de las partes subrayadas.

“OnClientClick”, que nos permite que este comportamiento suceda en el cliente, “return” que le devuelve al cliente si el usuario ha aceptado o no, “confirm()” en donde le decimos que nos abra una ventana de confirmación y el texto de la pregunta.

Por último esto no funcionaría a menos que le digamos que no valide el control, es decir “CausesValidation=false”.

Esto lo que consigue es que si el cliente pulsa aceptar, al retornar true se ejecuta el postback del botón y todo lo que implica. Vamos, en este caso borra la fila. En el caso que se retorne false entonces no realiza el postback y todo se queda como está.

Si quieres la información detallada del porqué pásate por este foro en donde RootK lo explica muy bien.

¿Tengo Internet? System.Net.WebResponse.

Metiéndome en berenjenales para practicar con las clases de la librería system.net me propuse hacer una pequeña aplicación que me indique cuando los "magos" de sistemas me cortan internet.

Primero pensé en un Ping, pero me he encontrado que con lo de los ataques del "Ping de la muerte" es mas fácil encontrar un punto y coma en un listado de Javascript que un servidor que responda a dicha petición.

Entonces me digo ¿Y si llamo a una URL? Asín, si tengo la seguridad que funciona la dirección a la que llamo (o también probando una colección de URL's) si conecto y obtengo respuesta es que tengo Internet y si no conecto es que estoy desconectado (y me ha salido un bonito pareado).

Para ello hago esta función que invoco desde el Main() de una aplicación de consola.


Sub probarinternet()

Try
Dim url As String = "http://www.nesquicia.com/"
Dim request As WebRequest = WebRequest.Create(url)
' Le bajo el tiempo TimeOut para que vaya más alegre la aplicación
request.Timeout = 1000

Dim response As WebResponse = request.GetResponse

' Hago que espere 3 segundos entre conexiones correctas
System.Threading.Thread.Sleep(3000)
response.Close()

Catch ex As Exception
' Escribo el error y la hora en que ha fallado.
Console.WriteLine(Date.Now & ": " & ex.Message & vbCrLf)
End Try

End While

End Sub

Y el resultado es... que los chapuzas de sistemas nos hacen una desconexión cada pocos segundos!!! Así va de lento esto y falla tanto.

Un poquito de SQL

Este es un truquillo que me enseñó hace unos años mi amigo Virgilio para evitar el tostón de andar con condicionales en SQL, en ciertos casos.

Tengo un listado de personas con cuatro parámetros (Nombre, apellido, dirección y teléfono) y quiero buscar por alguno de estos parámetros, por ninguno o por todos. Osea, si meto un nombre que me devuelva todas las personas con ese nombre, y si además le meto la dirección que me devuelva todas las personas con ese nombre y dirección.

¿Qué es lo primero que se le ocurre a un lego en programación SQL como yo? Ale, hacer un condicional y un select por cada uno de los parámetros. Algo como

@nombre
@apellido
@direccion
@telefono

IF @nombre = NULL
BEGIN
Select * from tabla where apellido = @apellido AND dirección = @direccion AND telefono = @telefono
END

Y así por cada uno de los parámetros… y eso sin contar con la tabla auxiliar donde meter los resultados para evitar duplicados, etc. Osea, un porrón de líneas de código.

También he visto hacerlo por medio de código dinámico. Para mi gusto una guarreria que debe dar unos problemas de depuración horrorosos.

@nombre
@apellido
@direccion
@telefono

SET @Select = “select * from table”
SET @Where = ''”
IF NOT @nombre IS NULL SET @Where = @Where + 'nombre=’ + @nombre
IF NOT @apellido IS NULL SET @Where = @Where + 'AND apellido=’ + @apellido
IF NOT @ direccion IS NULL SET @Where = @Where + 'AND direccion =’ + @ direccion
IF NOT @ telefono IS NULL SET @Where = @Where + 'AND telefono =’ + @ telefono

BEGIN
EXEC (@Select + ' WHERE ' + @Where)
END

Y ahora viene la maravilla que me enseño Virgilio, y que ahora comparto en este blog.

@nombre
@apellido
@direccion
@telefono


BEGIN
SELECT * FROM tabla WHERE
(Nombre=@nombre OR @nombre IS NULL)
AND (apellido =@ apellido OR @ apellido IS NULL)
AND (direccion =@ direccion OR @ direccion IS NULL)
AND (telefono =@ telefono OR @ telefono IS NULL)

END

¿A que es complejo de leer?

Pues es muy sencillo. Primero en mi código tengo que asegurarme que el parámetro es uno de dos, o un valor o un NULL. Pero ojo, un NULL de base de datos, osea, un DBNull.value.

¿Qué ocurre cuando, por ejemplo, envío el parámetro @nombre = NULL? El selector de la base de datos lee de forma secuencial desde el principio hasta el final la tabla y va preguntando a cada fila:
-¿Oshes, tu nombre es igual a @nombre? - Y la fila le dice - no, ni parecido-

A lo cual el puntero le vuelve a preguntar a la fila:

¿Oshes el parámetro @nombre es NULL?, a lo cual la fila le dice –pues sí, mira tú-

Y el selector coge la fila y la almacena para ser enviada al finalizar de hacer las mismas preguntas a todas las filas de la tabla.

¿Me entiendess?

Resumen, con estas líneas consigues reducir de forma drástica el código necesario para búsquedas de este estilo.