Tag Archives: Visual Basic

[ASP.NET] ASP.NET y las Microsoft jQuery Templates II – Fuente de datos externa

En el post pasado se hizo una introducción y un pequeño ejemplo de como utilizar las jQuery Templates (ver post), y en ese ejemplo manejamos una fuente de datos fija; ya en este post vamos a mejorar el ejemplo y nuestra fuente de datos será una base de datos, y para conectarnos vamos a usar Entity Framework, les recomiendo le den un ojo a este post sobre Entity Framework de Nicolás Herrera.

Entonces manos a la obra:

1. Base de datos

Vamos a tener una base de datos bastante sencilla, la cual maneja los mismos datos que teníamos en el ejemplo anterior, la idea es tener una tabla para departamentos y otra para ciudades, ahora para este ejemplo vamos a crear una vista donde consultemos esas dos tablas y solo vamos a traer los primeros 50 registros, la explicación de como crear vistas se sale de este tema, por eso solo coloco el T-SQL de la misma:

   1:  CREATE VIEW [dbo].[VIEW_DEPTO_MUNICIPIOS]
   2:  AS
   3:  SELECT TOP 50 Departamentos.CodDepto, Departamentos.Departamento, 
   4:          Municipios.CodMunicipio, Municipios.Municipio
   5:  FROM Departamentos 
   6:      INNER JOIN Municipios 
   7:      ON Departamentos.CodDepto = Municipios.CodDepto

2. Creando nuestro modelo de datos

Ya una vez tenemos la vista creada, creamos un modelo de EDM para ser consultado, lo importante acá es que cuando nos de la opción de seleccionar que objetos deseamos seleccionemos la vista creada anteriormente, para este ejemplo he seleccionado la tabla departamentos y ciudades, así como la vista creada, entonces nuestro modelo se verá así:

EntityDesignerDiagram

En este caso he creado un nuevo proyecto de librería de clases y allí he agregado mi modelo, lo he hecho así para poder utilizarlo en el siguiente demo.

3. Creando las plantillas T4

Aunque este es un tema bastante grande, voy a usar las plantillas para tener en un proyecto diferente mi entidades de dominio, estas se generan utilizando ADO.NET Self Tracking Entities, si desena ver como se hace pueden ver este post. Estas plantillas las he enviado a un nuevo proyecto, para que puedan ser referenciadas por cualquier otro proyecto.  Una vez generadas las plantillas vemos que por cada entidad tenemos una clase (se me paso cambiarle el nombre por default, por eso quedo Model1.tt):

Imagen1

4. Definiendo el HTML y la plantilla

En este punto, ya entramos al proyecto Web, allí al igual que en el post inicial creamos el contenedor y la plantilla, y no olviden agregar las referencias a los archivos js, entonces vamos a tener algo así:

   1:  //La plantilla
   2:  <script type="text/x-jquery-tmpl" id="TemplateDepto">
   3:      <tr class="contenido">
   4:          <td>${CodDepto}</td>
   5:          <td>${Departamento}</td>
   6:          <td>${CodMunicipio} </td>
   7:          <td>${Municipio}</td>
   8:      </tr>
   9:  </script>
  10:   
  11:  //El contenedor
  12:  <table border="1" cellspacing="2" cellpadding="2" id="tableDepartamentos">
  13:      <tr class="header">
  14:          <td>Cod Departamento</td>
  15:          <td>Departamento</td>
  16:          <td>Cod Municipio</td>
  17:          <td>Municipio</td>
  18:      </tr>
  19:  </table>

5. Obteniendo los datos

Ahora, para obtener los datos vamos a utilizar un Web Service, y dentro de el vamos a crear una función que se llama ObtenerDepartamentos(), dicha función va a devolver una lista genérica, y de que tipo? del tipo de la vista que hemos mapeado, y claro para consultar nuestro modelo vamos a utilizar Linq, entonces nuestra función se verá así:

   1:  <WebMethod()>
   2:  Public Function ObtenerDepartamentos() As List(Of VIEW_DEPTO_MUNICIPIOS)
   3:      Using contexto As New DeptoEntities
   4:   
   5:          Dim query As List(Of VIEW_DEPTO_MUNICIPIOS) = (From c In contexto.VIEW_DEPTO_MUNICIPIOS
   6:                                                         Select c).ToList()
   7:   
   8:          Return query
   9:   
  10:      End Using
  11:  End Function

6. Consumiendo el Web Service con jQuery y AJAX

Listo, ya tenemos los datos, tenemos el servicio, ahora llego el momento de consumir ese Web Service y esto lo haremos utilizando jQuery.

El código entonces jQuery para consumir ese Web Service es:

   1:  <script type="text/javascript">
   2:      $(document).on("ready", function () {
   3:          CargarTemplate();
   4:      })
   5:      var CargarTemplate = (function () {
   6:          $.ajax({
   7:              type: "POST",
   8:              url: "GetDepartamentos.asmx/ObtenerDepartamentos",
   9:              contentType: "application/json; chartset=utf-8",
  10:              dataType: "json",
  11:              success: function (resul) {
  12:                  if (resul.d)
  13:                      $("#TemplateDepto").tmpl(resul.d).appendTo("#tableDepartamentos");
  14:              },
  15:              error: function (error) {
  16:                  alert('Se ha producido un error al realizar la petición.');
  17:              }
  18:          })
  19:      });
  20:  </script>

En este caso lo importante es la línea 13, puesto que allí con el método tmpl le asignamos los datos al template, y como la respuesta del Web Service es en formato JSON le decimos resul.d, los demás parámetros de configuración ya los hemos tratado en post anteriores.

Bueno y una vez ejecutemos el ejemplo vamos a obtener lo siguiente:

Imagen1

Espero este post les haya gustado bastante, como ven es un implementación de las jQuery Templates más completa, y los espero en el otro post, donde a este mismo ejemplo le vamos a añadir la posibilidad de realizar búsquedas, para así luego de cargar los datos podamos ir filtrando los mismos.

El código del ejemplo, o mejor dicho la solución completa lo subiré con el siguiente post.

[Visual Basic] Extensión de métodos

Un método de extensión básicamente lo que permite hacer es añadir funcionalidades a clases ya existentes sin tener que utilizar herencia, ni nada semejante.

Un método de extensión debe ser necesariamente un método (sub) o una función (function), y debe ser creado dentro de un módulo. El método de extensión debe ser decorado con el atributo <Extension()> y para que este pueda ser utilizado se debe importar el namespace System.Runtime.CompilerServices.

Ahora para hacer un pequeño demo vamos a crear un método de extensión que tome un string y lo devuela en formato (para el ejemplo vamos a suponer que la cadena enviada siempre será numérica).

El método que creamos estará disponibles para el tipo de dato que le enviemos como primer parámetro a la función.

Entonces lo primero que debemos hacer es añadir un modulo, y dentro de ese modulo declaramos el método de extensión así:

   1:  <Extension()>
   2:  Public Function FormatoMoneda(ByVal sCadena As String) As String
   3:      Return Val(sCadena).ToString("$##,##0")
   4:  End Function

Como ven es una función muy sencilla que simplemente le da el formato deseado, y ahora cuando utilicemos un valor de tipo string y le demos . vamos a tener disponible la función formato moneda. Para verificar el ejemplo vamos a tener una aplicación Windows form (para que sea sencillo) con dos cajas de texto y un botón, y al idea es que cuando se de clic en el botón el número introducido en el primer textbox aparezca en el segundo pero con el formato deseado, así que el código del botón seria:

   1:  txtFormato.Text = txtOriginal.Text.FormatoMoneda()

Y una vez ejecutemos la aplicación tendremos algo como:

Imagen1

Espero les sea de utilidad.

[Visual Basic] Clases parciales

Las clases parciales permiten dividir la definición de una clase en varias partes. Las clases parciales no crean múltiples clases, simplemente crean una clase y dicha clase se implementa en diferentes partes.

Para definir una clase parcial basta con colocar antes del class el modificador Partial:

   1:  Partial Class MiClase
   2:  End Class

Ahora un pequeño ejemplo:

1. En un proyecto vamos a crear dos carpetas, la idea será simular que en una carpeta tenemos las clases bases y en la otra vamos a tener las clases que por decirlo de alguna manera siguen con la implementación de dichas clases, algo como:

Imagen1

2. En la carpeta de clases principales vamos a crear una clase que se llame Persona, la cual será pública y parcial, además que va a definir dos propiedades diferentes (nombre y apellido) y un método el cual asignara un valor al nombre, algo bastante simple:

 

   1:  Partial Public Class Persona
   2:      Private Property sNombre As String
   3:      Private Property sApellido As String
   4:   
   5:      Public Sub EstablecerNombre(ByVal nombre As String)
   6:          _sNombre = nombre
   7:      End Sub
   8:  End Class

3. Ahora en la carpeta de clases extendidas creamos una nueva clase llamada Persona y un método que establezca el apellido:

   1:  Public Class Persona
   2:      Public Sub EstablecerApellido(ByVal apellido As String)
   3:          _sApellido = apellido
   4:      End Sub
   5:  End Class

Como se puede observar la clase tiene el mismo nombre, pero al ser una de ellas parcial es compilador no nos genera error.

Ahora una vez utilicemos la clase vamos a disponer de los dos métodos:

   1:  Dim persona1 As New Persona
   2:  persona1.EstablecerNombre("Julio")
   3:  persona1.EstablecerApellido("Apellido")

Claro, el ejemplo que se ha hecho es bastante simple, pero la idea era mostrar el funcionamiento de las clases parciales.

[Visual Basic] Tipos nulos

Hola a todos, desde ahora y siguiendo con el nombre del blog “Todo en Visual Basic.Net”, voy a ir subiendo post sobre características de Visual Basic (claro de jQuery y ASP.NET también), para que podamos ir conociendo un poco más sobre este extraordinario lenguaje.

En este post vamos a ver que son y como poder utilizar los nullable type o tipos nulos.

Un nullable type  es un tipo de dato que permite almacenar valores nothing, lo cual es bastante útil si trabajamos con bases de datos, ya que si alguno de los valores que traemos tiene el valor null, y si es asignado a una variable de un tipo de dato que no permite almacenar ese tipo de valores vamos a tener una excepción.

Ahora como hacemos para declarar un tipo de dato nullable?.. pues es muy fácil, y tenemos dos opciones:

   1:  Dim iValor as Integer?

o

   1:  Dim iValor As Nullable(Of Integer)

y listo, ahora la variable iValor puede recibir como valor nothing sin generar alguna excepción:

   1:  iValor = Nothing

Eso es todo, una característica bastante sencilla de utilizar.

Subir archivos con FileUpload

Una funcionalidad recurrente en un desarrollo web es la necesidad de permitirle al usuario cargar archivos, para esta tarea asp.net ofrece un control llamado FileUpload, este control abre una ventana en al cual el usuario selecciona el archivo, pero esto no es suficiente, también se debe disponer de un botón generalmente que permita realizar la subida de dicho archivo al servidor.

Un punto importante es que a diferencia de las aplicaciones de escritorio en donde el componente OpenFileDialog permitía filtrar los tipos de archivos a seleccionar con el FileUpload esto no es posible, el usuario podrá seleccionar el tipo de archivo que desee.

El punto anterior puede traernos bastantes problemas, para lo cual tenemos dos opciones (aconsejo utilizarlas ambas):

  1. Validar el tipo de archivo en el cliente.
  2. Validar el tipo de archivo en el servidor.

Vamos a revisar como realizar ambas validaciones, la interfaz algo sencilla pero que servirá para realizar el ejemplo es:

Tenemos dos grupos, el primero realizará validación en el servidor y el segundo en el cliente, para el ejemplo se va a permitir subir solo imágenes, para luego ser mostrada por pantalla.

1. Validación en el servidor:

El código para realizar la validación en el servidor es:

        Dim sExt As String = String.Empty
        Dim sName As String = String.Empty
 
        imgSubida.Width = 0
        imgSubida.Width = 0
        imgSubida.ImageUrl = ""
 
        If uploadFile.HasFile Then
            sName = uploadFile.FileName
            sExt = Path.GetExtension(sName)
 
            If ValidaExtension(sExt) Then
                uploadFile.SaveAs(MapPath("~/images/" & sName))
                imgSubida.Width = 300
                imgSubida.Width = 300
                imgSubida.ImageUrl = "/images/" & sName
                lblMensaje.Text = "Archivo cargado correctamente."
            Else
                lblMensaje.Text = "El archivo no es de tipo imagen."
            End If
        Else
            lblMensaje.Text = "Seleccione el archivo que desea subir."
        End If
    Private Function ValidaExtension(ByVal sExtension As String) As Boolean
        Select Case sExtension
            Case ".jpg", ".jpeg", ".png", ".gif", ".bmp"
                Return True
            Case Else
                Return False
        End Select
    End Function

Se declaran dos variables, una va a tener el nombre del archivo y la otra la extensión del archivo, luego con la propiedad booleana uploadFile.HasFile validamos que el control si tenga un archivo, obtenemos el nombre del archivo con uploadFile.FileName,este obtiene exclusivamente el nombre con la extensión del archivo, si usamos uploadFile.PostedFile.FileName obtenemos la ruta completa y finalmente la extensión se obtiene con la función GetExtension() de la clase Path que pertenece al espacio de nombres System.IO.

Luego con la función ValidaExtension() se valida que la extensión del archivo sea correcta, de ser así devuelve true de lo contrario false.

Si la validación anterior ha sido correcta, se hace uso del método SaveAs del FileUpload, y se guarda la imagen en la carpeta images de la estructura del sitio, y finalmente la imagen es cargada al control image.

2. Validación en el cliente:

El código para realizar la validación en el cliente es:

$(function () {
    $("#<% = btnSubir2.ClientID %>").click(function () {
        var file = document.getElementById('<% = uploadFile2.ClientID %>').value;
        if (file == null || file == '') {
            alert('Seleccione el archivo a subir.');
            return false;
        }
        //DEFINE UN ARRAY CON LAS EXTENSIONES DE ARCHIVOS VALIDAS
        var extArray = new Array(".jpg", ".jpeg", ".bmp", ".png", ".gif");
        //SE EXTRAE LA EXTENSION DEL ARCHIVO CON EL PUNTO INCLUIDP 
        var ext = file.slice(file.indexOf(".")).toLowerCase();
 
        //SE RECORRE EL ARRAY PARA VERIFICAR SI LA EXTENSSION DEL ARCHIVO ESTA DEFINIDA 
        //EN EL ARRAY QUE CONTIENE LAS EXTENSIONES VALIDAS
        for (var i = 0; i < extArray.length; i++) {
            if (extArray[i] == ext) {
                alert("El archivo SI es una imagen.");
                return true;
            }
        }
        alert("El archivo NO es una imagen");
        return false;
    })
})

Primero con jQuery manejamos el evento clic del botón btnSubir2, en la variable file traemos el valor que tiene el fileupload, esto para poder verificar que se haya seleccionado un archivo.

Se define un array con las extensiones permitidas de los archivos a subir, luego en la variable ext se guarde la extensión del archivo seleccionado (recuerda q se incluye el punto) y finalmente con un ciclo for se recorre el array para revisar si la extensión del archivo se encuentra en algún item del array definido anteriormente.

Un punto importante acá es que el control FileUpload no es totalmente compatible con el UpdatePanel, por lo cual se tendrá que hacer se otro control del cual hablaré en los próximos artículos, además veremos como utilizar los plugin de jQuery para realizar la subida de archivos.

Les dejo el código del ejemplo en VB y C#.

Ejemplo en VB !

Ejemplo en C# !

Usando caché con ASP.NET

Hola, hoy quiero mostrar como podemos usar la cache para tener nuestros datos en memoria y evitar hacer idas y vueltas a nuestra base de datos continuamente.
El proceso para utilizar la cache consta de 3 pasos:

  1. Buscar si existe un determinado elemento en la cache.
  2. Si el elemento existe entonces utilizarlo.
  3. Si el elemento no existe ir a la base de datos y cachear el elemento.

Vamos a revisar tres escenarios:

  1. Cache simple: Podemos utilizar la cache de manera similar a si usáramos una variable de session, simplemente verificamos si existe el elemento, en caso de existir lo usamos de lo contrario vamos a la base de datos y luego cacheamos el elemento. La desventaja de este método es que una vez cacheado el elemento, no es posible determinar si nuetsro origen de datos ha cambiado, lo cual podria generar datos inconsistente.El código siguiente muestra la implementación de este caso:
        
           If Cache("cache1") Is Nothing Then
                dt = oConexion.GetUsers()
                Cache("cache1") = dt
                grvUsuarios.DataSource = dt
                grvUsuarios.DataBind()
                Response.Write("Cache created at: " & Now)
            Else
                dt = CType(Cache("cache1"), DataTable)
                grvUsuarios.DataSource = dt
                grvUsuarios.DataBind()
                Response.Write("Cache used at: " & Now)
            End If
    
    Lo primero es verificar si el objeto existe en la cache, si no existe entonces obtenemos los datos de la base de datos con la función GetUsers() y luego cacheamos el elemento, así en una segunda oportunidad como ya se encuentra el objeto en la cache no se realiza de nuevo la consulta a la base de datos.
  2. Cache con tiempo de expiración: Al igual que con el caso anterior, para acceder a la cache lo hacemos de manera similar a como se accede a una variable de session, la diferencia radica en que cuando creamos el objeto en la cache le definimos un tiempo de vida, así cuando dicho tiempo se cumpla el objeto cacheado “muere” y tendriamos que volver a cachearlo; de esta manera estariamos refrescando regularmente nuestros objetos cacheados para tener siempre los datos reales de la base de datos, sin embargo se puede dar el caso q los datos puedan ser cambiados y que le tiempo de cache no se haya cumplido, pero ya veremos en el siguiente caso como podemos solucionar este caso.
        
            Dim Expires As DateTime
            Expires = DateAdd(DateInterval.Second, 10, Now)
    
            If Cache("cache2") Is Nothing Then
                dt = oConexion.GetUsers()
                Cache.Insert("cache2",
                             dt,
                             Nothing,
                             Expires,
                             System.Web.Caching.Cache.NoSlidingExpiration,
                             System.Web.Caching.CacheItemPriority.Default,
                             Nothing)
                grvUsuarios.DataSource = dt
                grvUsuarios.DataBind()
                Response.Write("Cache created at: " & Now)
            Else
                dt = CType(Cache("cache2"), DataTable)
                grvUsuarios.DataSource = dt
                grvUsuarios.DataBind()
                Response.Write("Cache used at: " & Now)
            End If

    Lo primero es verificar si el objeto existe en la cache, si no existe entonces obtenemos los datos de la base de datos con la función GetUsers() y luego cacheamos el elemento, pero notese aca que el primer caso usamos Cache(“nombreitem”) y en este caso utilizamos Cache.Insert(…), lo que pasa es que cuando se utliza el método Insert(…) tenemos un mayor control y mayores funcionalidades al crear el objeto, con el método simple solo creamos el objeto en cache sin mayores características. En el ejemplo especificamos que el tiempo de vida del objeto en cache sea de 10 segundos, ya que en la línea Expires = DateAdd(DateInterval.Second, 10, Now) a la fecha actual le estamos diciendo que nos sume 10 segundos a la fechha y hora actuales.

  3. Cache con dependencia a SQL Server: Cuando utilizamos caché con dependencia a SQL Sever, lo que se logra es que nuetsra aplicación detecte automáticamente cuando se realiza algún cambio en la tabla origen, así podemos tener siempre en caché los datos actuales de nuestra base de datos. Para realizar este proceso primero debemos decirle a la base de datos que se va a utilizar para cachear con dependecia y luego le especificamos que tabla vamos a utilizar, con el primer proceso se crea una tabla llamada AspNet_SqlCacheTablesForChangeNotification para ir monitoreando los cambios realizados ademas de algunos procedimientos almacenado, al realizar el segundo proceso se crean algunos triggers sobre la tabla que vamos a cachear, la manera de realizar dicho proceso es por medio de la consola de comando ejecutar:
        
    aspnet_regsql -S NOMBRESERVIDORINSTANCIA -E -ed -d NOMBREBASE
    

    Allí lo único que se debe especificar es el nombreservidor por el servidor de base de datos y específicamos el nombre de la base de datos a utilizar.

        
    aspnet_regsql -S NOMBRESERVIDORINSTANCIA -E -d NOMBREBASE -et -t NOMBRETABLA
    

    En este segundo caso al final debemos especificar el nombre de la tabla que deseamos utilizar.
    Luego de tener nuestra base de datos lista, vamos al webconfig y especificamos:

        
        <caching>
          <sqlCacheDependency enabled="true">
            <databases>
              <add connectionStringName="MiCadena" name="AspCache" pollTime="500"/>
            </databases>
          </sqlCacheDependency>
        </caching>

    Ahora en nuestro código:

        
          If Cache("cache3") Is Nothing Then
                dt = oConexion.GetUsers()
                Dim scd As New SqlCacheDependency(databaseEntryName:="AspCache",
                                                                tableName:="Usuarios")
                Cache.Insert(key:="cache3",
                             value:=dt,
                             dependencies:=scd)
                grvUsuarios.DataSource = dt
                grvUsuarios.DataBind()
                Response.Write("Cache created at: " & Now)
            Else
                dt = CType(Cache("cache3"), DataTable)
                grvUsuarios.DataSource = dt
                grvUsuarios.DataBind()
                Response.Write("Cache used at: " & Now)
            End If
    

    Aca primero verificamos si existe el objeto, en caso negativo entonces llenamos un datatable con los datos, luego creamos un objeto SqlCacheDependency donde en el constructor especificamos el nombre de la base de datos y la tabla a utilizar, luego al crear el objeto en la cache le pasamos como parámetro el objeto creado anteriormente.

    Finalmente le dejo el código del ejemplo, y desde ahora los podrán descargar tanto en vb como en c#:
    Ejemplo en C# !
    Ejemplo en VB !

Thumbnail en Windows 7

Hola, siguiendo con esta serie de post sobre desarrollo para Windows 7, vamos a ver como podemos establecer thumbnails para nuestras aplicaciones, un thumbnail es la imagen que se muestra cuando ponemos el mouse sobre le icono de algún escritorio.
Si no establacemos uno personalizado por defecto se verá la ventana de la aplicación.
La idea aca es tener 8 imágenes diferentes, y al seleccionar alguna de las imágenes esta se convertira en el thumbnail de la aplicación.
La aplicación se verá algo así:
Asi cuando se cambie de selección la imágen el thumbnail tambien cambiara..ahora el poco código detrás…
Private Sub PictureBoxImage1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles PictureBoxImage1.Click,
PictureBoxImage2.Click,
PictureBoxImage3.Click,
PictureBoxImage4.Click,
PictureBoxImage5.Click,
PictureBoxImage6.Click,
PictureBoxImage7.Click,
PictureBoxImage8.Click
Dim oPicture As PictureBox
Call FondoBlanco()
oPicture = TryCast(sender, PictureBox)
If TypeOf (oPicture) Is PictureBox Then
oPicture.BackColor = Color.AliceBlue
End If

If ValidaSO() Then
Dim iLeft As Integer = 0
Dim iWidth As Integer = 0
iLeft = oPicture.Left + TabControl1.Left + GroupBox7.Left + TabPage4.Left
iWidth = oPicture.Top + TabControl1.Top + GroupBox7.Top + TabPage4.Top
Dim oRec As New Rectangle(iLeft, iWidth, oPicture.Width, oPicture.Height)
TaskbarManager.Instance.TabbedThumbnail.SetThumbnailClip(Me.Handle, oRec)
Else
MsgBox(“Su sistema operativo no permite ejecutar las nuevas caracterisiticas de Windows 7, por favor actulize su sistema.”, MsgBoxStyle.Information, “Sistema no soportado”)
End If
End Sub
Se define un manejador para todos los eventos clic de los 8 diferetnes picturebox, declaramos un objeto de tipo picturebox, luego hacemos un cast al sender (sender digamos en resumen que es el objeto que realiza el evento) para obtner el picturebox que genero el evento y lo asignamos al picturebox creado; cambiamos el color de fondo del picture para poder ver visualmente la imágen seleccionada, luego debemos obtener el rectangulo que corresponde a dicha imagen o picturebox, para este caso declaramos dos variables (iLeft, iWidth) para poder tener la posición en x y en y respectivamente.
Ahora, para poder obterne la posición tanto en x como en y, usamos la siguiente lógica, cada control dentro del formulario tiene una posición en x y una y relativa al control que lo contiene, es decir, para el ejemplo la posición x del picture será en relación al groupbox que lo contiene, este groupbox a su vez la tendrá en relación al tabpage, este tabpage al tabcontrol y el tabcontrol al formulario, asi que vamos a sumar todos estos valores en x y en y para poder obtener la posición correcta.
Luego creamos un objeto de tipo rectangle el cual será definido por la posición y el tamaño del picturebox.
Dim oRec As New Rectangle(iLeft, iWidth, oPicture.Width, oPicture.Height)
Por último lo asignamos al tasbarmanager…
TaskbarManager.Instance.TabbedThumbnail.SetThumbnailClip(Me.Handle, oRec)
Y listo.. como ven es algo sencillo, lo único (por lo menos para mi algo tedioso es obtener el rectangulo correcto para poder asignarlo como thumbnail…
Nos vemos en el siguiente post !

JumpList en Windows 7

Hola, de nuevo con Windows 7, ahora vamos a ver como podemos añardir accesos directos al jumplist de nuestra app, el jumplist resumiendo es la lista que se muestra cuando se da clic derecho sobre el icono de alguna aplicación.

Los pasos para poder agregar tareas al jumplist son los sigueintes:

1. Declarar una variable de tipo JumpList

Dim oJumpList As JumpList

2. Decirle que vamos a crear un nuevo jumplist (generalmente lo hago en el load)

oJumpList = JumpList.CreateJumpListForIndividualWindow(“OverlayIcon”, Me.Handle)

3. Ahora vamos a tener una interfaz con  cuatro opciones, las cuales van a hacer referencia a 4 carpetas especiales del disco, las cuales son:

  • Música
  • Documentos
  • Imágenes
  • Programas

La idea es que nuestro jumplist tenga accesos directos a estas 4 carpetas.

4. Para poder agregar un elemento al jumplist lo primero que hago es traer la ruta de la carpeta seleccionada:

Dim sRuta As String = String.Empty

sRuta = My.Computer.FileSystem.SpecialDirectories.MyMusic

5. Agregar esa ruta como tarea al jumplist, darle un título y establecerle un icono.

oJumpList.AddUserTasks(New JumpListLink(sRuta, “Mi Música”) With {.IconReference = New IconReference(Path.Combine(sFolder, “explorer.exe”), 0)})

6. Listo, es todo.

Ha sido un rápido ejemplo de como podemos agregar tareas al jumplist de nuestra aplicación, es realmente sencillo, al final la aplicación debe lucir algo así:

Espero sea de utilidad y por algunos post más seguiremos hablando sobre Windows 7…

Link al ejemplo !!

 

Barra de progreso en Windows 7

En el post anterior vimos como usar iconos de estado para mostrarle al usuario el estado de la aplicación, hoy vamos a ver como podemos usar una barra de progreso en el icono de nuestra app, asi como ls diferentes tipos/estilos de barra que podemos utilizar.

Usar este tipo de ayudas es de gran utilidad a los usuarios, ya que le premiten conocer sin necesidad de tener maximixada la aplicación el estado y/o progreso de cierta operación, además que nuestras aplicaciones dejan de lado la tipica ventana gris y el icono estático de siempre aprovechando las nuevas características de windows 7 creando mejores interfaces de usuario, mas amigables y mucho mas llamativas.

La interfaz que debemos pintar será algo asi (durante estos post ire completando el ejemplo del post anterior):

En la primera parte listamos los diferentes estilos que podemos usar, los cuales pertenecen a una enumerazciíon que tiene los siguientes valores:

  • Error
  • Indeterminate
  • NoProgress
  • Normal
  • Paused

En la segunda parte vamos a ir incrementando el valor de la barra de progreso (0-100) usando el control NumericUpDown con su valor minimo en 0 y el maximo en 100.

Ahora vamos a ver que debemos hacer:

1. Declaramos una enumeracion que contiene los diferentes “estilos” de barra,

Private Enum TipoBarra
Ninguna
Indeterminado
Normal
Pausado
Eror
End Enum

2. Declaramos una método que recibe como parámetro el estilo de barra escogida, y la setea a la instancia del TaskbarManager. Al igual que en el primer ejemplo validamos que el sistema operativo pueda utilizar esta caracteristica.

Private Sub EstableceBarra(ByVal oTipoBarra As TipoBarra)
If ValidaSO() Then
Select Case CInt(oTipoBarra)
Case 0
oIconTaskbar.SetProgressState(TaskbarProgressBarState.NoProgress)
Case 1
oIconTaskbar.SetProgressState(TaskbarProgressBarState.Indeterminate)
Case 2
oIconTaskbar.SetProgressState(TaskbarProgressBarState.Normal)
oIconTaskbar.SetProgressValue(NumericUpDownValor.Value, 100)
Case 3
oIconTaskbar.SetProgressState(TaskbarProgressBarState.Paused)
oIconTaskbar.SetProgressValue(NumericUpDownValor.Value, 100)
Case 4
oIconTaskbar.SetProgressState(TaskbarProgressBarState.Error)
oIconTaskbar.SetProgressValue(NumericUpDownValor.Value, 100)
End Select
Else
MsgBox(“Su sistema operativo no permite ejecutar las nuevas caracterisiticas de Windows 7, por favor actulize su sistema.”, MsgBoxStyle.Information, “Sistema no soportado”)
End If
End Sub

3. Al cambiar la selección del radiobutton llamamos la función:

Call EstableceBarra(oTipoBarra:=TipoBarra.Indeterminado)

En este caso se ha seleccionado indeterminado, es decir sera una barra continua e infinita.

4.Al cambiar el valor del NumericUpDownValor modificamos el valor de la barra, simplemente le mandamos el valor del control y le decimos que el máximo valor de la barra será de 100.

Private Sub NumericUpDownValor_ValueChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles NumericUpDownValor.ValueChanged
Call ValorBarra(iValor:=NumericUpDownValor.Value)
End Sub
Private Sub ValorBarra(ByVal iValor As Integer)
oIconTaskbar.SetProgressValue(iValor, 100)
End Sub

5. Ahora lo que vamos a hacer es a realizar algunas operaciones q ir mostrando el avance de la operación, al comienzo la barra será roja, luego amarrilla y despues del 80% será verde, asi el usuario sabrá en que estado se encuentran las operaciones.Para el ejemplo he usado un ciclo de 1 hasta 100 pero como saben esto se ejecutarpa demasiado rápido y no podremos ver el ejemplo, en ese caso en cada ciclo he colocado un sleep de la clase Thread el cual por el momento solo diré que “pone a dormir” al servidor durante un tiempo determinado (el tiempo se define en milisegundos), para el ejemplo serán 150.

Private Sub ButtonAutomatico_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ButtonAutomatico.Click
If ValidaSO() Then
oIconTaskbar.SetProgressState(TaskbarProgressBarState.Paused)
oIconTaskbar.SetProgressValue(0, 100)
For i As Integer = 1 To 100
oIconTaskbar.SetProgressValue(i, 100)
Thread.Sleep(150)
If i > 40 Then
oIconTaskbar.SetProgressState(TaskbarProgressBarState.Paused)
End If
If i > 80 Then
oIconTaskbar.SetProgressState(TaskbarProgressBarState.Normal)
End If
Next
Else
MsgBox(“Su sistema operativo no permite ejecutar las nuevas caracterisiticas de Windows 7, por favor actulize su sistema.”, MsgBoxStyle.Information, “Sistema no soportado”)
End If
End Sub

Y eso es todo, ahora podremos usar barras de progreso y así evitar que el usuario este constatemente “abriendo” nuestra aplicación para ver el progreso de alguna operación.

Ojala les sea bastante util este pequeño ejemplo.. seguiremos hablando de windows 7 en algunas entradas más..

Link del ejemplo !!

Usando overlay icons en Windows 7

Bueno, a pesar que ya salio hace bastante tiempo windows 7 el cual en lo personal me parece excelente (uso la version ultimate de 32 bits), me gusta su interfaz, las nuevas funcionalidades, lo gran usabilidad que tiene y sobretodo que todas esas caracteristicas que hacen de windows 7 un muy buen sistema operativo las podemso utilizar en nuestros desarrollos.

Asi que hare algunos post mostrando como poder utilizar el API para acceder a todas estas funcionalidades.. no voy a entran en detalles teoricos sobre el modelo de seguridad, y demás que debemos conocer para poder desarrollar aplicaciones compatibles con windows 7, ya que existe bastante y excelente información del tema…asi que voy a ir al grano, mostrar como se hace además por el poco tiempo que me queda.

Para los ejemplos vamos a necesitar un windows 7, y el API/ librerias que nos proveeran todo el acceso a las funcionalidades, de aqui lo puedes bajar !! alli tenemos la documentación, las dll necesarias y toda la documentación.

En este primer post vamos a mirar como podemos usar iconos sobrepuestos sobre el icono principal de nuestra aplicación para que así el usuario sepa el estado de la aplicación.

Ahora  a trabajar !!

Vamos a crear un nuevo proyecto de tipo windows.. para WPF y Windows Form funciona de la misma manera, lo hare en windows form porque luego quiero comenzar a realizar algunos post sobre como podemos trabajar con WPF…

Lo primero que debemos hacer es agregar la referencia a dos librerias:

  • Microsoft.WindowsAPICodePack.dll
  • Microsoft.WindowsAPICodePack.Shell.dll

Ahora vamos a ir agregando algunos elementos de interfaz a nuestro formulario, arrastermos un group, y dentro de él un boton con una caja de texto, este cumplira la funcion de informar al usuario si el sistema operativo soporta el taskbar, ahora en el codebehind importamos dos namespaces:

  • Microsoft.WindowsAPICodePack
  • Microsoft.WindowsAPICodePack.Taskbar

y para verificar si el sistema operativo soporta el API es tan fácil usando la clase TaskbarManger: If TaskbarManager.IsPlatformSupported Then y el método retorna true en caso de tener un SO correcto.

…hasta el momento nuestra aplicación se verá asi:

Bueno ahora vamos a ver como podemos colocar iconos sobrepuestos…

1. Agregamos algunas imagens de tipo icon a los recursos del proyecto.

2. Declaramos una enumeracion para listar los posibles tipos de iconos a usar

Private Enum TipoIcono
Ok
Help
Msn
End Enum

3. Obtenemos la instancia del taskbar

Private oIconTaskbar As TaskbarManager = TaskbarManager.Instance

4. Se crea el metodo que recibe como parametro la enumeración para establecer el icono.

Private Sub EstableceIcono(ByVal oIcono As TipoIcono)
Select Case CInt(oIcono)
Case 0:oIconTaskbar.SetOverlayIcon(My.Resources.ok, “AppOk”)
Case 1:oIconTaskbar.SetOverlayIcon(My.Resources.help, “AppHelp”)
Case 2:oIconTaskbar.SetOverlayIcon(My.Resources.msn, “AppHelp”)
End Select
End Sub

5. Desde el click de cada botón llamamos el método del paso anterior.

Private Sub ButtonIconOk_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ButtonIconOk.Click
Call EstableceIcono(oIcono:=TipoIcono.Ok)
End Sub

Y listo…ya podemos usar los iconos cobrepuestos en el taskbar de windows 7… asi lucira el icono:

Espero les sea de utilidad…nos vempos en un proximo post donde veremos otra funcionalidad de windows 7 y como poder usarla de una manera fácil…

Descarga del ejemplo !!

1 2