Archive

Archive for the ‘Uncategorized’ Category

Creando una cuenta para acceder al Azure Storage

September 15th, 2014 No comments

Lee el post original de Víctor Moreno en: Azure Sin Límites

  • Crear una cuenta en el Azure Storage.
  • Escribir código para acceder al Azure Storage.
  • Ajustar las propiedades de un proyecto tipo rol para configurar una cuenta de almacenamiento del Azure Storage.

Leer más…

Categories: Uncategorized Tags:

Almacenamiento con Blobs

September 7th, 2014 No comments

Lee el post original de Víctor Moreno en: Azure Sin Límites

En una anterior publicación, hablé del Azure Storage y los tipos de almacenamiento en la nube (véase Azure Storage), en esta ocasión hablaré un poco más acerca de los Blobs.

Un blob es cualquier archivo que podamos imaginar: una imagen, un video, un archivo comprimido, un documento, etc. Existen básicamente dos tipos de Blobs: Leer más…

Categories: Uncategorized Tags:

WCF Ria Services V1.0 para Silverlight 4.- Eliminar un registro de la Base de Datos (Parte 9)

May 18th, 2012 No comments

Para terminar con el tema de acciones CRUD con datos por medio de WCF Ria Services en Silverlight, en este post hablaremos del último tema pendiente, eliminar un registro.

Nuevamente la recomendación es leer al menos los dos post previos en el tema para comprender de mejor manera las acciones de editar un registro y de agrear uno nuevo; ya que estaremos reutilizando los conceptos expuestos.

Eliminando el registro

Bajo la misma dinámica que hacer las cosas de la manera más facil, para eliminar un registro necesitaremos de solo dos lineas de código; o tres, en el caso de pedir la confirmación de la acción.

Agregamos un nuevo botón que nos permita eliminar el registro que actualmente se tiene seleccionado en el grid.

<Button x:Name="btnRemove"
        Content="Eliminar"
        Height="23"
        Width="115"
        HorizontalAlignment="Left"
        Click="btnRemove_Click" />

Y en la acción del click, escribiremos el código donde indicaremos que al DataView del Domain Data Source le removeremos el registro actual que podemos obtener desde el mismo DataView utilizando la propiedad CurrentItem y haciendo el cast al tipo de objeto que contiene. Y, como ya lo sabemos, tendremos que enviar los cambios a nuestro servicio wcf para que estos sean replicado a la base de datos. Adicionalmente agregaremos una ventana de confirmación de la acción que permitirá al usuario pensar dos veces sobre la acción a realizar.

private void btnRemove_Click(object sender, RoutedEventArgs e)
{
    if (System.Windows.Browser.HtmlPage.Window.Confirm("Estas seguro de querer eliminar el producto"))
    {
        productDomainDataSource.DataView.Remove(
            productDomainDataSource.DataView.CurrentItem as Product);
        productDomainDataSource.SubmitChanges();
    }
}

Cerrando el tema

Si bien, el tema de WCF Ria Services da para mucho más, con temas como validaciones desde el modelo o desde la misma vista, el indicador de actividad, entre muchos otros; con este post podremos decir que hemos cerrado los temas básicos sobre WCF Ria Services para Silverlight.

Gracias y saludos…

Categories: Uncategorized Tags:

Silverlight RIA Services y Windows Azure TableStorage

March 29th, 2012 No comments

 

Un escenario común al trabajar en Silverlight y SQL Server  es utilizar RIA Services para realizar operaciones CRUD, RIA services ofrece muchas ventajas, pero una vez más al pensar en la nube  debemos replantear cual es la mejor solución para minimizar costos de nuestra implementación .

Una alternativa es usar TableStorage de Windows Azure para realizar estas operaciones.

Para lograr esto necesitamos tener instalados los siguientes componentes:

Windows Azure SDK

La última version de RIA Services.

Teniendo todo listo podemos comenzar.

1.- Creamos un nuevo proyecto de silverlight con RIA Services habilitado.

2.- Agregamos un nuevo proyecto Cloud de Windows Azure en limpio.

3.-En nuestro proyecto Cloud de Windows Azure agregamos nuestro WebRole que ya existe en nuestra solución.

image

4.- En nuestro proyecto Web  agregamos un Domain Services en Blanco .

 

5.-Necesitamos agregar a nuestro proyecto Web las siguientes referencias:

  • System.Data.Services.Client
  • Microsoft.WindowsAzure.ServiceRuntime
  • Microsoft.WindowsAzure.StorageClient
  • Microsoft.ServiceModel.DomainServices.WindowsAzure

Con esto hemos preparado nuestro entorno para poder trabajar con TableStorage y RIA Services.

TableEntity

Como ya sabemos TableStorage ofrece muchas ventajas una de ellas es que ofrece un número practicamente ilimitado de tablas y registros , además que ofrece una forma estructurada de almacenamiento de nuestra información.

Algo que debemos recordar es que cada registro deben tener obligatoriamente 3 propiedades PartitionKey,RowKey,Timestamp, la combinacion de estas 3 propiedades forman una unica llave que identifica nuestro registro.

Para simplificar este trabajo nosotros podemos hacer uso de la clase TableEntity , esta clase incluye ya estas propiedades.

Ejemplo:

Lo que sigue es crear el DataContext para el Table Storage esto lo logramos gracias a la clase TableEntityContext

Por ultimo necesitamos agregar diversos metodos a nuestro Domain Service.

Con esto nostros podemos fácilmente realizar operaciones CRUD con RIA Services y Table Storage.


Puedes descargar el código fuente Aquí

MVVM Light Toolkit desde cero (paso 6)

August 19th, 2011 2 comments

Continuando con la serie acerca de la implementación del patrón arquitectural Model-View-ViewModel y en específico utilizando la herramienta MVVM Light Toolkit, este artículo dará por concluida la serie, con la implementación del ViewModel para Empleados y su correspondiente View.

Algunos seguidores del blog han sugerido nuevos ejemplos con algunas variantes y con la finalidad de visualizar las diferentes aristas que puede tener la implementación del patrón en conjunto con ADO.NET Entity Framework, lo cual estaré haciendo con mucho gusto en siguientes artículos.

Procedemos entonces a crear el ViewModel para Empleado, ubicados en el proyecto Empleados.WPF y en la carpeta ViewModel, damos clic derecho para agregar un nuevo ítem.

EmpleadoViewModel

podemos eliminar los comentarios que se crean por omisión, agreguemos los siguientes namespaces System.Collections.ObjectModel, Empleados.WPF.Model, System.Collections.Generic y continuamos con la creación de las propiedades necesarias que estarán enlazadas al View, creamos una #region ViewModel Properties y dentro de esta otra #region ViewModel Property : ListaEmpleados , utilizando el snippet mvvminpc creamos una propiedad de tipo ObservableCollection<EmpleadoModel> que se llame ListaEmpleados.

  1. #region ViewModel Property : ListaEmpleados
  2.  
  3.         /// <summary>
  4.         /// The <see cref="ListaEmpleados" /> property's name.
  5.         /// </summary>
  6.         public const string ListaEmpleadosPropertyName = "ListaEmpleados";
  7.  
  8.         private ObservableCollection<EmpleadoModel> _listaEmpleados;
  9.  
  10.         public ObservableCollection<EmpleadoModel> ListaEmpleados
  11.         {
  12.             get
  13.             {
  14.                 return _listaEmpleados;
  15.             }
  16.  
  17.             set
  18.             {
  19.                 if (_listaEmpleados == value) return;
  20.  
  21.                 _listaEmpleados = value;
  22.  
  23.                 // Update bindings, no broadcast
  24.                 RaisePropertyChanged(ListaEmpleadosPropertyName);
  25.             }
  26.         }
  27.  
  28.         #endregion

 

La siguiente propiedad a incluir es CurrentEmpleado, creamos una #region ViewModel Property : CurrentEmpleado y dentro de esta una propiedad de tipo EmpleadoModel

  1. #region ViewModel Property : CurrentEmpleado
  2.  
  3.         /// <summary>
  4.         /// The <see cref="CurrentEmpleado" /> property's name.
  5.         /// </summary>
  6.         public const string CurrentEmpleadoPropertyName = "CurrentEmpleado";
  7.  
  8.         private EmpleadoModel _currentEmpleado;
  9.  
  10.         public EmpleadoModel CurrentEmpleado
  11.         {
  12.             get
  13.             {
  14.                 return _currentEmpleado;
  15.             }
  16.  
  17.             set
  18.             {
  19.                 if (_currentEmpleado == value) return;
  20.  
  21.                 _currentEmpleado = value;
  22.  
  23.                 // Update bindings, no broadcast
  24.                 RaisePropertyChanged(CurrentEmpleadoPropertyName);
  25.             }
  26.         }
  27.  
  28.         #endregion

 

La siguiente propiedad nos permitirá desplegar en el View los puestos registrados en la base de datos y a su vez enlazar el puesto seleccionado a un empleado. Se crea otra #region ViewModel Property : ListaPuestos y se crea una propiedad de tipo List<PuestoModel> llamada ListaPuestos

  1. #region ViewModel Property : ListaPuestos
  2.  
  3.         /// <summary>
  4.         /// The <see cref="ListaPuestos" /> property's name.
  5.         /// </summary>
  6.         public const string ListaPuestosPropertyName = "ListaPuestos";
  7.  
  8.         private List<PuestoModel> _listaPuestos;
  9.  
  10.         public List<PuestoModel> ListaPuestos
  11.         {
  12.             get
  13.             {
  14.                 return _listaPuestos;
  15.             }
  16.  
  17.             set
  18.             {
  19.                 if (_listaPuestos == value) return;
  20.  
  21.                 _listaPuestos = value;
  22.  
  23.                 // Update bindings, no broadcast
  24.                 RaisePropertyChanged(ListaPuestosPropertyName);
  25.             }
  26.         }
  27.  
  28.         #endregion

 

Continuamos con los comandos, agregamos el siguiente namespace Galasoft.MvvmLight.Command  y creamos una #region ViewModel Commands y dentro de esta los comandos necesarios para manejar los botones del View y la selección en un Grid.

  1. #region ViewModel Commands
  2.  
  3.         public RelayCommand NewCommand { get; set; }
  4.         public RelayCommand SaveCommand { get; set; }
  5.         public RelayCommand DeleteCommand { get; set; }
  6.         public RelayCommand<EmpleadoModel> SelectionChangedCommand { get; set; }
  7.  
  8.         #endregion

 

Luego una nueva #region ViewModel Public Methods y dentro de esta incluimos el método constructor de la clase, en el constructor cargamos la lista de todos los empleados que haya en la base de datos en la propiedad de tipo ObservableCollection ListaEmpleados, cargamos todos los puestos así como la inicialización de los RelayCommand.

  1. /// <summary>
  2.         /// Initializes a new instance of the EmpleadoViewModel class.
  3.         /// </summary>
  4.         public EmpleadoViewModel()
  5.         {
  6.             ListaEmpleados = new ObservableCollection<EmpleadoModel>(EmpleadoModel.GetAllEmpleados());
  7.             ListaPuestos   = new List<PuestoModel>(PuestoModel.GetAllPuestos());
  8.             RegisterCommands();
  9.             New();
  10.         }

 

Lo que sigue es la creación de los métodos necesarios para que los comandos “RelayCommand” funcionen adecuadamente. Métodos New, Save, CanSave, Delete, CanDelete.

  1. public void New()
  2.         {
  3.             CurrentEmpleado = new EmpleadoModel();
  4.         }
  5.  
  6.         public void Save()
  7.         {
  8.             if (CurrentEmpleado.IdEmpleado == 0)
  9.             {
  10.                 CurrentEmpleado.IdEmpleado = EmpleadoModel.InsertEmpleado(CurrentEmpleado);
  11.                 ListaEmpleados.Add(CurrentEmpleado);
  12.             }
  13.             else
  14.             {
  15.                 EmpleadoModel.UpdateEmpleado(CurrentEmpleado);
  16.             }
  17.             New();
  18.         }
  19.  
  20.         public bool CanSave()
  21.         {
  22.             return !string.IsNullOrEmpty(CurrentEmpleado.Identificacion) &&
  23.                    !string.IsNullOrEmpty(CurrentEmpleado.Nombre) &&
  24.                    !string.IsNullOrEmpty(CurrentEmpleado.PrimerApellido) &&
  25.                    !string.IsNullOrEmpty(CurrentEmpleado.Genero) &&
  26.                    CurrentEmpleado.Puesto != null;
  27.         }
  28.  
  29.         public void Delete()
  30.         {
  31.             EmpleadoModel.DeleteEmpleado(CurrentEmpleado.IdEmpleado);
  32.             ListaEmpleados.Remove(CurrentEmpleado);
  33.             New();
  34.         }
  35.  
  36.         public bool CanDelete()
  37.         {
  38.             return CurrentEmpleado.IdEmpleado != 0;
  39.         }

 

procedemos a la inicialización de los comandos “RelayCommand” previamente declarados, creamos una #region ViewModel Private Methods y dentro de esta el método RegisterCommands

  1. #region ViewModel Private Methods
  2.  
  3.         private void RegisterCommands()
  4.         {
  5.             NewCommand = new RelayCommand(New);
  6.             SaveCommand = new RelayCommand(Save, CanSave);
  7.             DeleteCommand = new RelayCommand(Delete, CanDelete);
  8.             SelectionChangedCommand = new RelayCommand<EmpleadoModel>(empleado =>
  9.             {
  10.                 if (empleado == null) return;
  11.                 CurrentEmpleado = empleado;
  12.             });
  13.         }
  14.  
  15.         #endregion

Con esto concluímos el ViewModel de Empleados y como se puede apreciar a diferencia del ViewModel de Puesto, no se crearon propiedades individuales para enlazar a cada uno de los campos de captura de datos en el View como si se hizo con la descripción del Puesto, si no, que se está utilizando el objeto de tipo EmpleadoModel en este caso CurrentEmpleado, que a su vez cada una de sus propiedades implementa la interfaz INotifyPropertyChanged, para realizar la labor de DataBinding entre el ViewModel y el View como se verá a continuación con la creación del View, pero antes asegurémonos que el View podrá acceder el ViewModel por medio del ViewModelLocator.

Accedemos a ViewModelLocator.cs y creamos una nueva #region Empleado ViewModel seguidamente de la region Puesto ViewModel. Dentro de esta región utilizamos el snippet mvvmlocatorproperty que provee el MVVM Light Toolkit y una vez implementado el locator para EmpleadoViewModel realizamos un procedimiento similar al anterior locator para PuestoViewModel con el método Cleanup(), eliminando el creado por omisión pero dejando el llamado a ClearEmpleadoViewModel() en el otro método Cleanup() que ya se tenía como se ve a continuación.

  1. #region Empleado ViewModel
  2.  
  3.         private static EmpleadoViewModel _empleadoViewModel;
  4.  
  5.         /// <summary>
  6.         /// Gets the EmpleadoViewModel property.
  7.         /// </summary>
  8.         public static EmpleadoViewModel EmpleadoViewModelStatic
  9.         {
  10.             get
  11.             {
  12.                 if (_empleadoViewModel == null)
  13.                 {
  14.                     CreateEmpleadoViewModel();
  15.                 }
  16.  
  17.                 return _empleadoViewModel;
  18.             }
  19.         }
  20.  
  21.         /// <summary>
  22.         /// Gets the EmpleadoViewModel property.
  23.         /// </summary>
  24.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance",
  25.             "CA1822:MarkMembersAsStatic",
  26.             Justification = "This non-static member is needed for data binding purposes.")]
  27.         public EmpleadoViewModel EmpleadoViewModel
  28.         {
  29.             get
  30.             {
  31.                 return EmpleadoViewModelStatic;
  32.             }
  33.         }
  34.  
  35.         /// <summary>
  36.         /// Provides a deterministic way to delete the EmpleadoViewModel property.
  37.         /// </summary>
  38.         public static void ClearEmpleadoViewModel()
  39.         {
  40.             _empleadoViewModel.Cleanup();
  41.             _empleadoViewModel = null;
  42.         }
  43.  
  44.         /// <summary>
  45.         /// Provides a deterministic way to create the EmpleadoViewModel property.
  46.         /// </summary>
  47.         public static void CreateEmpleadoViewModel()
  48.         {
  49.             if (_empleadoViewModel == null)
  50.             {
  51.                 _empleadoViewModel = new EmpleadoViewModel();
  52.             }
  53.         }
  54.  
  55.         #endregion

 

  1. /// <summary>
  2.         /// Cleans up all the resources.
  3.         /// </summary>
  4.         ///
  5.         public static void Cleanup()
  6.         {
  7.             ClearMain();
  8.             ClearEmpleadoViewModel();
  9.             //ClearPuestoViewModel();
  10.         }

 

Nótese el comentario en //ClearPuestoViewModel() en la imagen anterior, esto se debe a que no vamos a ejecutar la pantalla PuestoView, que a su vez por medio del locator crea una instancia de PuestoViewModel, si no que lo haremos solamente para el View de Empleado.

En este último artículo de la serie, voy a introducir algunos conceptos de WPF, crear una interfaz de usuario un poco más agradable y así aprovechar el tutorial para explorar el tema de controles de usuario, por que no sería lógico tener que estar creando la misma botonera (botones de Nuevo, Guardar, Eliminar, etc.) para cada programa de mantenimiento que vayamos a crear.

Ubicados en el Proyecto Empleados.WPF damos clic derecho, Add/New/Folder, le asignamos el nombre images, y dentro de este folder colocamos las imágenes que tendrán nuestros botones http://bit.ly/mWJzY9 , una vez descargadas y ubicados en el folder recién creado, damos clic derecho Add/Existing Item… para seleccionar las imágenes

Crearemos algunos estilos para darle a nuestra interfaz de usuario un aspecto diferente y moderno, algunos de estos estilos serán generales para toda la aplicación, por lo cual estarán ubicados en el App.xaml y otros estilos serán locales para uso únicamente del View ó control donde se definan. Accedemos al archivo App.xaml y dentro de la etiqueta <Application.Resources> incluimos lo siguiente:

  1. Application.Resources>
  2.         <!–Global View Model Locator–>
  3.         <vm:ViewModelLocator x:Key="Locator"
  4.                              d:IsDataSource="True" />
  5.  
  6.         <LinearGradientBrush
  7.             x:Key="BottomBorderBackground"
  8.             EndPoint="0.5,1"
  9.             StartPoint="0.5,0">
  10.             <GradientStop Color="#FF96BFCD" Offset="0" />
  11.             <GradientStop Color="#FF4A7681" Offset="1" />
  12.         </LinearGradientBrush>
  13.  
  14.         <LinearGradientBrush
  15.             x:Key="InnerBorderBackground"
  16.             EndPoint="0.5,1"
  17.             StartPoint="0.5,0">
  18.             <GradientStop Color="#FFF3F3F3" Offset="0" />
  19.             <GradientStop Color="#FFF3F3F3" Offset="1" />
  20.             <GradientStop Color="#FFE0E0E0" Offset="0.45" />
  21.         </LinearGradientBrush>
  22.  
  23.     </Application.Resources>

 

Vamos a crear el control de usuario que nos permitirá colocar los botones que tendrán nuestros programas de mantenimiento, ubicados en el proyecto Empleados.WPF damos clic derecho, Add/New/Folder, le asignamos el nombre controles y ubicados en este folder damos nuevamente clic derecho Add/User Control…, le asignamos el nombre BotonesControl.xaml , ajustamos los valores de d:Designheight=”50” y d:DesignWith=”600” en el código xaml y antes de la declaración de la etiqueta <Grid> que se crea por omisión incluimos la etiqueta <UserControl.Resources> dentro de esta etiqueta se incluirán algunos estilos de uso local, solamente para este control de usuario.

  1. <UserControl.Resources>
  2.         <Style
  3.             x:Key="myLabelStyle"
  4.             TargetType="{x:Type Label}">
  5.             <Setter Property="Foreground" Value="White" />
  6.             <Setter Property="FontSize" Value="10" />
  7.             <Setter Property="Margin" Value="0,-5,0,0" />
  8.         </Style>
  9.         <Style
  10.             x:Key="myImageStyle"
  11.             TargetType="{x:Type Image}">
  12.             <Setter Property="Width" Value="26" />
  13.             <Setter Property="Height" Value="26" />
  14.             <Setter Property="Margin" Value="0,3,0,0" />
  15.         </Style>
  16.         <Style
  17.             x:Key="myButtonStyle"
  18.             TargetType="{x:Type Button}">
  19.             <Setter Property="BorderBrush" Value="Transparent" />
  20.             <Setter Property="Background" Value="Transparent"/>
  21.             <Setter Property="Cursor" Value="Hand"/>
  22.         </Style>
  23.         <Style
  24.             x:Key="myStackPanelStyle"
  25.             TargetType="StackPanel">
  26.             <Setter Property="Background" Value="Transparent"/>
  27.             <Setter Property="Margin" Value="2,0" />
  28.         </Style>
  29.     </UserControl.Resources>

 

Luego a la etiqueta <Grid> le agregamos los siguientes valores

  1. <Grid
  2.         VerticalAlignment="Top"
  3.         HorizontalAlignment="Stretch"
  4.         Height="50">
  5.         <Grid.Background>
  6.             <LinearGradientBrush
  7.                 EndPoint="0.5,1"
  8.                 StartPoint="0.5,0">
  9.                 <GradientStop Color="#FF999999" Offset="0" />
  10.                 <GradientStop Color="#FF142533" Offset="1" />
  11.                 <GradientStop Color="#FF3F3F3F" Offset="0.5" />
  12.                 <GradientStop Color="#FF0D161D" Offset="0.5" />
  13.             </LinearGradientBrush>
  14.         </Grid.Background>
  15.     </Grid>

 

Siempre dentro de la etiqueta <Grid> y después de la declaración de </Grid.Background> vamos a crear los botones de nuestro control, pero antes debemos crear el contenedor donde estarán los botones, para eso creamos un <StackPanel Orientation=”Horizontal”> y dentro del StackPanel los botones:

  1. <Grid
  2.         VerticalAlignment="Top"
  3.         HorizontalAlignment="Stretch"
  4.         Height="50">
  5.         <Grid.Background>
  6.             <LinearGradientBrush
  7.                 EndPoint="0.5,1"
  8.                 StartPoint="0.5,0">
  9.                 <GradientStop Color="#FF999999" Offset="0" />
  10.                 <GradientStop Color="#FF142533" Offset="1" />
  11.                 <GradientStop Color="#FF3F3F3F" Offset="0.5" />
  12.                 <GradientStop Color="#FF0D161D" Offset="0.5" />
  13.             </LinearGradientBrush>
  14.         </Grid.Background>
  15.         <StackPanel Orientation="Horizontal">
  16.             <Button
  17.                 Style="{StaticResource myButtonStyle}"
  18.                 Command="{Binding NewCommand, Mode=OneWay}">
  19.                 <StackPanel Style="{StaticResource myStackPanelStyle}">
  20.                     <Image Source="/images/New.png" Style="{StaticResource myImageStyle}" />
  21.                     <Label Content="Nuevo" Style="{StaticResource myLabelStyle}" />
  22.                 </StackPanel>
  23.             </Button>
  24.             <Button
  25.                 Style="{StaticResource myButtonStyle}"
  26.                 Command="{Binding SaveCommand, Mode=OneWay}">
  27.                 <StackPanel Style="{StaticResource myStackPanelStyle}">
  28.                     <Image Source="/images/Save.png" Style="{StaticResource myImageStyle}" />
  29.                     <Label Content="Grabar" Style="{StaticResource myLabelStyle}" />
  30.                 </StackPanel>
  31.             </Button>
  32.             <Button
  33.                 Style="{StaticResource myButtonStyle}"
  34.                 Command="{Binding DeleteCommand, Mode=OneWay}">
  35.                 <StackPanel Style="{StaticResource myStackPanelStyle}">
  36.                     <Image Source="/images/Delete.png" Style="{StaticResource myImageStyle}" />
  37.                     <Label Content="Borrar" Style="{StaticResource myLabelStyle}" />
  38.                 </StackPanel>
  39.             </Button>
  40.             <Button
  41.                 Style="{StaticResource myButtonStyle}"
  42.                 Command="{Binding SearchCommand, Mode=OneWay}">
  43.                 <StackPanel Style="{StaticResource myStackPanelStyle}">
  44.                     <Image Source="/images/Search.png" Style="{StaticResource myImageStyle}" />
  45.                     <Label Content="Buscar" Style="{StaticResource myLabelStyle}" />
  46.                 </StackPanel>
  47.             </Button>
  48.             <Button
  49.                 Style="{StaticResource myButtonStyle}"
  50.                 Command="{Binding RefreshCommand, Mode=OneWay}">
  51.                 <StackPanel Style="{StaticResource myStackPanelStyle}">
  52.                     <Image Source="/images/Refresh.png" Style="{StaticResource myImageStyle}" />
  53.                     <Label Content="Refrescar" Style="{StaticResource myLabelStyle}" />
  54.                 </StackPanel>
  55.             </Button>
  56.         </StackPanel>
  57.     </Grid>

 

Como se puede apreciar, para cada botón hemos establecido la propiedad Command que se estará enlazando en el ViewModel con los RelayCommand creados anteriormente y hemos optimizado el código xaml con los estilos creados anteriormente en la sección <UserControl.Resources> a fin de reutilizarlos y no tener que escribir las mismas propiedades para cada uno de los botones. Al final nuestro control de usuario debería verse de la siguiente forma:

ButtonControl

Compilamos el Proyecto, así nos aseguramos que todo vaya bien, y siempre ubicados siempre en el Proyecto Empleados.WPF y en la carpeta View, damos clic derecho y Add New Item para crear la Vista EmpleadosView.xaml

EmpleadoView

una vez creada la pantalla, en el código XAML ingresamos los valores de d:DesignWidth=”600” y d:DesignHeight=”640”, ingresamos la propiedad WindowsStartupLocation=”CenterScreen”, Title=”Gestión de Empleados” y DataContext=”{Binding EmpleadoViewModel, Source={StaticResource Locator}}” y el namespace xmlns:usrControl=”clr-namespace:Empleados.Wpf.controles”, luego agregamos al <Grid> la definición de 2 Rows y seguidamente al cierre de la definición de los Rows, agregamos el user Control de los botones colocando lo siguiente: <usrControl:BotonesControl Grid.Row=”0”> , Luego creamos un par de controles de tipo <Border>, uno dentro del otro, hasta ahora el código xaml debería verse así:

  1. <Window x:Class="Empleados.WPF.View.EmpleadoView"
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4.         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  5.         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  6.         mc:Ignorable="d"
  7.         d:DesignWidth="600"
  8.         d:DesignHeight="640"
  9.         WindowStartupLocation="CenterScreen"
  10.         Width="600"
  11.         Height="640"
  12.         DataContext="{Binding EmpleadoViewModel, Source={StaticResource Locator}}"
  13.         Title="Gesti?n de Empleados"
  14.         xmlns:usrControl="clr-namespace:Empleados.WPF.controles">
  15.     <Grid>
  16.         <Grid.RowDefinitions>
  17.             <RowDefinition Height="50" />
  18.             <RowDefinition />
  19.         </Grid.RowDefinitions>
  20.         <usrControl:BotonesControl
  21.             Grid.Row="0" />
  22.         <Border
  23.             Grid.Row="1"
  24.             Background="{StaticResource BottomBorderBackground}">
  25.             <Border
  26.                 Margin="10,8,10,10"
  27.                 CornerRadius="4"
  28.                 Background="{StaticResource InnerBorderBackground}">
  29.                 
  30.             </Border>
  31.         </Border>
  32.     </Grid>
  33. </Window>

 

Dentro del último <Border> agregamos un <Grid> y dentro de este lo siguiente es colocar los controles necesarios para la captura de información del mantenimiento de empleados, agregamos los siguientes namespaces al código xaml xmlns:i=”http://schemas.microsoft.com/expression/2010/interactivity”  y  xmlns:cmd="clr-namespace:GalaSoft.MvvmLight.Command;assembly=GalaSoft.MvvmLight.Extras.WPF4"

  1. <Grid>
  2.                     <TextBlock
  3.                         Height="23"
  4.                         HorizontalAlignment="Left"
  5.                         Margin="21,23,0,0"
  6.                         Text="Identificaci?n"
  7.                         VerticalAlignment="Top" />
  8.                     <TextBox
  9.                         Height="23"
  10.                         HorizontalAlignment="Left"
  11.                         Margin="122,20,0,0"
  12.                         Text="{Binding Path=CurrentEmpleado.Identificacion, UpdateSourceTrigger=PropertyChanged}"
  13.                         VerticalAlignment="Top"
  14.                         Width="173" />
  15.                     <TextBlock
  16.                         Height="23"
  17.                         HorizontalAlignment="Left"
  18.                         Margin="21,52,0,0"
  19.                         Text="Nombre"
  20.                         VerticalAlignment="Top" />
  21.                     <TextBox
  22.                         Height="23"
  23.                         HorizontalAlignment="Left"
  24.                         Margin="122,49,0,0"
  25.                         Text="{Binding Path=CurrentEmpleado.Nombre, UpdateSourceTrigger=PropertyChanged}"
  26.                         VerticalAlignment="Top"
  27.                         Width="173" />
  28.                     <TextBlock
  29.                         Height="23"
  30.                         HorizontalAlignment="Left"
  31.                         Margin="21,81,0,0"
  32.                         Text="Primer Apellido"
  33.                         VerticalAlignment="Top" />
  34.                     <TextBox
  35.                         Height="23"
  36.                         HorizontalAlignment="Left"
  37.                         Margin="122,78,0,0"
  38.                         VerticalAlignment="Top"
  39.                         Width="173"
  40.                         Text="{Binding Path=CurrentEmpleado.PrimerApellido, UpdateSourceTrigger=PropertyChanged}" />
  41.                     <TextBlock
  42.                         Height="23"
  43.                         HorizontalAlignment="Left"
  44.                         Margin="21,110,0,0"
  45.                         Text="Segundo Apellido"
  46.                         VerticalAlignment="Top" />
  47.                     <TextBox
  48.                         Height="23"
  49.                         HorizontalAlignment="Left"
  50.                         Margin="122,107,0,0"
  51.                         Text="{Binding Path=CurrentEmpleado.SegundoApellido, UpdateSourceTrigger=PropertyChanged}"
  52.                         VerticalAlignment="Top"
  53.                         Width="173" />
  54.                     <TextBlock
  55.                         Height="23"
  56.                         HorizontalAlignment="Left"
  57.                         Margin="21,139,0,0"
  58.                         Text="G?nero"
  59.                         VerticalAlignment="Top" />
  60.                     <ComboBox
  61.                         Height="23"
  62.                         HorizontalAlignment="Left"
  63.                         Margin="122,136,0,0"
  64.                         VerticalAlignment="Top"
  65.                         Width="173"
  66.                         Text="{Binding Path=CurrentEmpleado.Genero, UpdateSourceTrigger=PropertyChanged}">
  67.                         <ComboBoxItem
  68.                             Content="Masculino" />
  69.                         <ComboBoxItem
  70.                             Content="Femenino" />
  71.                     </ComboBox>
  72.                     <TextBlock
  73.                         Height="23"
  74.                         HorizontalAlignment="Left"
  75.                         Margin="21,168,0,0"
  76.                         Text="Puesto"
  77.                         VerticalAlignment="Top" />
  78.                     <ComboBox
  79.                         Height="23"
  80.                         HorizontalAlignment="Left"
  81.                         Margin="122,168,0,0"
  82.                         VerticalAlignment="Top"
  83.                         Width="173"
  84.                         ItemsSource="{Binding Path=ListaPuestos}"
  85.                         SelectedItem="{Binding Path=CurrentEmpleado.Puesto, UpdateSourceTrigger=PropertyChanged}"
  86.                         Text="{Binding Path=CurrentEmpleado.Puesto.Descripcion, UpdateSourceTrigger=PropertyChanged}"
  87.                         DisplayMemberPath="Descripcion" />
  88.                     <DataGrid
  89.                         AutoGenerateColumns="False"
  90.                         Height="288"
  91.                         HorizontalAlignment="Left"
  92.                         Margin="11,217,0,0"
  93.                         Name="dataGrid1"
  94.                         VerticalAlignment="Top"
  95.                         Width="529"
  96.                         ItemsSource="{Binding Path=ListaEmpleados, UpdateSourceTrigger=PropertyChanged}"
  97.                         CanUserAddRows="False">
  98.                         <DataGrid.Columns>
  99.                             <DataGridTextColumn
  100.                                 Binding="{Binding Path=Identificacion, UpdateSourceTrigger=PropertyChanged}"
  101.                                 Header="Identificacion"
  102.                                 Width="100"
  103.                                 IsReadOnly="True" />
  104.                             <DataGridTextColumn
  105.                                 Binding="{Binding Path=Nombre, UpdateSourceTrigger=PropertyChanged}"
  106.                                 Header="Nombre"
  107.                                 Width="125"
  108.                                 IsReadOnly="True" />
  109.                             <DataGridTextColumn
  110.                                 Binding="{Binding Path=PrimerApellido, UpdateSourceTrigger=PropertyChanged}"
  111.                                 Header="Primer Apellido"
  112.                                 Width="150"
  113.                                 IsReadOnly="True" />
  114.                             <DataGridTextColumn
  115.                                 Binding="{Binding Path=Genero, UpdateSourceTrigger=PropertyChanged}"
  116.                                 Header="Genero"
  117.                                 Width="130"
  118.                                 IsReadOnly="True" />
  119.                             
  120.                         </DataGrid.Columns>
  121.                         <i:Interaction.Triggers>
  122.                             <i:EventTrigger
  123.                                 EventName="SelectionChanged">
  124.                                 <cmd:EventToCommand
  125.                                     Command="{Binding SelectionChangedCommand, Mode=OneWay}"
  126.                                     CommandParameter="{Binding SelectedItem, ElementName=dataGrid1}" />
  127.                             </i:EventTrigger>
  128.                         </i:Interaction.Triggers>
  129.                     </DataGrid>
  130.                 </Grid>

 

Para finalizar y desplegar la aplicación modificamos el archivo App.xaml y la sección StartupUri=”View/EmpleadoView.xaml”, la aplicación deberá lucir así:

EmpleadoView

Tal y como lo mencioné en el artículo anterior, he obviado algunos procedimientos con la finalidad de no hacer el post mas grande de lo que ya es, concentrándome en las particularidades que hacen este mantenimiento diferente al anterior que habíamos desarrollado de Puestos.

No me queda mas que agradecer a los lectores que han seguido esta serie de artículos acerca de como implementar el patrón Model-View-ViewModel y en específico utilizando la herramienta MVVM Light Toolkit, ADO.NET Entity Framework y LINQ que eran los objetivos de la serie. Estaré complementado con otros artículos las sugerencias que han manifestado los seguidores del blog, así como también escribiendo acerca de otras funcionalidades que provee MVVM Light Toolkit, como la funcionalidad de “Messenger”, además de escribir algunos artículos trabajando directamente con Microsoft Expression Blend para el diseño de Interfaces ricas en UX en conjunto con MVVM Light Toolkit siempre en la línea de utilizar el patrón para el desarrollo de aplicaciones, así como aplicaciones para Windows Phone 7.

El código fuente de todo el desarrollo de la serie de artículos puede ser descargado aquí :

http://bit.ly/n96yy1

Saludos y nos vemos en el siguiente post.

Primer congreso de Innovación Tecnológica

April 20th, 2011 No comments

En el marco del XX aniversario de las universidades tecnológicas de mi país fui invitado a dar un taller acerca de la implementación de tecnologías Silverlight en los entornos empresariales en la Universidad Tecnológica de Tulancingo Hidalgo.

con_web_gde

Si gustan ver el programa completo visiten este link.

 

El taller hablará de los temas siguientes.

¿Qué es Silverlight?

Ventajas en el uso de la tecnología Silverlight

Interacción entre aplicaciones y servidores

Desarrollo de aplicaciones en Windows Phone 7

Práctica de ejemplo entre Silverlight, Servicios Web y Windows Phone 7

 

¡Ahí nos vemos!

Categories: Uncategorized Tags:

Usar el servicio de imagenes de Bing Maps

January 30th, 2011 1 comment

Usar un API a mi en lo personal siempre me causa cierta emoción me encanta la idea de consumir varios servicios dentro de una misma aplicación y una de las mejores APIs que he encontrado es la de Bing Maps, dado que permite muchos usos así como una enorme sencillez en su formato para Silverlight.

Ahora comencemos a ver que onda con el servicio de imágenes de Bing Maps, la idea aquí es aprender a como lograr que podamos obtener en una ventana nueva la imagen del mapa que estamos viendo, aclaro que esto es un tanto complicado, pues si queremos exportar del mapa a una imagen de una manera mas directa no podremos por la sencilla razón de que es un “contenido protegido” y no pueden leerse sus píxeles, entonces consumiendo el servicio de imágenes (que la misma API permite) podremos hacerlo sin mayor problema, la idea de este tutorial es que puedas enviar el “extent” de tu mapa a una imagen que puedas guardar, los usos como siempre serán tu idea.

Después de haber creado un nuevo proyecto lo primero que debemos hacer es agregar una referencia a la librería de:

Microsoft.Maps.MapControl

La cual podrás descargar abriendo una cuenta de desarrollador en la página de Bing Maps que por cierto necesitarás dado que necesitas igualmente la Bing Maps Key así que pasar por ahí no es opcional.

img701

Ya que tu referencia ha sido añadida, lo primero que debes hacer es añadir el namespace adecuado para poder usar el mapa en XAML.

 

xmlns:mapas="clr-namespace:Microsoft.Maps.MapControl;assembly=Microsoft.Maps.MapControl"

 

Ya que tu namespace esta listo, simplemente añade el mapa dentro de tu control principal de la siguiente forma.

 

<mapas:Map x:Name="mapa" Center="22.75791,-101.5966" ZoomLevel="5.900"
Mode="Aerial" NavigationVisibility="Collapsed" ScaleVisibility="Collapsed"
CredentialsProvider="Tu llave aquí" CopyrightVisibility="Collapsed"/>

 

Coloqué las coordenadas adecuadas para que el mapa se ubicara en la república mexicana, si quieres poner las coordenadas de otro país solo calcula un poco o si te da flojera hazlo desde la página de la API interactiva.

Ya con el mapa en la posición adecuada puedes seguir adelante, colocando cuatro botones en donde gustes para cambiar de tipo de mapa y uno mas para exportar la imagen.

img702

Algo así de sencillo, te servirá para seguir, ahora lo que debes hacer es solo crear los métodos, para los primeros tres botones la cosa es sencilla, solo inserta este código a cada uno.

 

private void CambiarMapa_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            Button elemento = sender as Button;

switch (elemento.Name)
            {
                case "btnMapa":
                    mapa.Mode = new RoadMode();
                    break;

case "btnImagen":
                    mapa.Mode = new AerialMode(false);
                    break;

case "btnImagenNombres":
                    mapa.Mode = new AerialMode(true);
                    break;
            }
        }

 

Listo, hasta aquí lo que has logrado es cambiar el modo en el que puedes cambiar el mapa, eso es prácticamente la mitad de lo que debes hacer, para continuar ve a insertar una referencia de servicio a la siguiente URL.

http://dev.virtualearth.net/webservices/v1/imageryservice/imageryservice.svc

img703

img704

Ya que tienes la referencia al servicio web de imagenes de Bing, crea una función de la siguiente forma.

 

private void ObtenerImagenes(string ubicacion, int zoom)
        {
            bool httpsUriScheme = !Application.Current.IsRunningOutOfBrowser && HtmlPage.Document.DocumentUri.Scheme.Equals(Uri.UriSchemeHttps);
            BasicHttpBinding binding = httpsUriScheme ? new BasicHttpBinding(BasicHttpSecurityMode.Transport) : new BasicHttpBinding(BasicHttpSecurityMode.None);
            UriBuilder serviceUri = new UriBuilder("http://dev.virtualearth.net/webservices/v1/imageryservice/imageryservice.svc");
            if (httpsUriScheme)
            {
                serviceUri.Scheme = Uri.UriSchemeHttps;
                serviceUri.Port = -1;
            }

Servicio1.ImageryServiceClient imagenServicio = new ImageryServiceClient(binding, new EndpointAddress(serviceUri.Uri));

MapUriRequest solicitud = new MapUriRequest();

solicitud.Credentials = new Credentials();
            solicitud.Credentials.ApplicationId = "Aquí tus credenciales";

solicitud.Center = new Location();
            string[] digitos = ubicacion.Split(‘,’);
            solicitud.Center.Latitude = double.Parse(digitos[0].Trim());
            solicitud.Center.Longitude = double.Parse(digitos[1].Trim());

opciones.ZoomLevel = zoom;
            opciones.ImageSize = new Servicio1.SizeOfint();
            opciones.ImageSize.Height = 428;
            opciones.ImageSize.Width = 758;

solicitud.Options = opciones;
            imagenServicio.GetMapUriCompleted += imagenServicio_GetMapUriCompleted;
            imagenServicio.GetMapUriAsync(solicitud);

}

 

Una función que recibirá dos parámetros, a la cual le estableces los parámetros necesarios para el contrato que utiliza el servicio de imágenes, después de eso con los objetos de tipo MapUriRequest y MapUriOptions (este último por favor colócalo de manera global pues lo necesitaremos mas adelante), establecerás la condición necesaria para poder ejecutar el método asíncrono de “GetMapUri” de tu servicio.

Ya que hayas pasado por este método, solo debes terminar por mandar el resultado en una nueva ventana para que puedas verlo, esto lo haces con el Event Handler del método “GetMapUri” de tu servicio.

 

void imagenServicio_GetMapUriCompleted(object sender, GetMapUriCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                MapUriResponse resultado = new MapUriResponse();
                resultado = e.Result;
                HtmlPage.Window.Navigate(new Uri(resultado.Uri), "_blank");
            }

}

Por último, lo único que necesitas hacer es mandar llamar la función con los parámetros adecuados para poder ejecutarla de manera adecuada

 

private void btnExportar_Click(object sender, RoutedEventArgs e)
        {
            string direccion = mapa.Center.ToString();
            int escala = Convert.ToInt16(mapa.ZoomLevel);
            ObtenerImagenes(direccion, escala);
        }

 

En donde estás pasando el centro del mapa que tienes en pantalla, así como su nivel de zoom, nada mas que eso, ejecuta tu proyecto y checa el resultado.

Podría decir que acabamos, pero se que como buen desarrollador te diste cuenta de que solo exportas la imagen en un solo tipo de mapa, el de tipo mapa, y lo que tu quieres es que la imagen se exporte con cada tipo de mapa que hayas seleccionado, para esto modifica la función de los tres primeros botones de la siguiente forma.

 

private void CambiarMapa_Click(object sender, System.Windows.RoutedEventArgs e)
       {
           Button elemento = sender as Button;

switch (elemento.Name)
           {
               case "btnMapa":
                   opciones.Style = Microsoft.Maps.MapControl.PlatformServices.MapStyle.Road;
                   mapa.Mode = new RoadMode();
                   break;

case "btnImagen":
                   opciones.Style = Microsoft.Maps.MapControl.PlatformServices.MapStyle.Aerial;
                   mapa.Mode = new AerialMode(false);
                   break;

case "btnImagenNombres":
                   opciones.Style = Microsoft.Maps.MapControl.PlatformServices.MapStyle.AerialWithLabels;
                   mapa.Mode = new AerialMode(true);
                   break;
           }

}

 

Ahora si lo puedo decir: Listo!!!!!! Ya estuvo, así puedes exportar tu mapa de Bing a una imagen usando el servicio de imágenes que la API de Bing te proporciona.

Puedes descargar el código aquí por cualquier duda que te haya surgido. (Recuerda que debes tener una API key para hacer funcionar el proyecto correctamente).

Categories: Uncategorized Tags:

Quinta entrada un pequeño SIG(Desplegar en WP7 el mapa y servicio WCF)

January 22nd, 2011 1 comment

Bien, pues ya vamos por la última, haciendo un resumen de lo que llevamos hecho, podemos comenzar con hacer una aplicación que me permitiera desplegar un mapa usando al API de Bing Maps para Silverlight, después hicimos un servicio web ASP.net para poder guardar información de los elementos que quisimos poner dentro de el mapa, en la tercera entrega vimos como publicar esa aplicación para considerar el hecho de cuando la pongamos en modo productivo, en la cuarta entrada vimos el gran salto hacia los servicios WCF que para ser honesto, son una maravilla y bastante cómodos de utilizar, llegaron para quedarse y con justa razón, entonces hasta ahora ya tenemos todo para trabajar con todos estos datos, opté por recibir los resultados vía Windows Phone 7 para cambiar un poco de plataforma y además para confirmar los recién adquiridos conocimientos en esta plataforma, (agradezco a Raúl Mayo por su artículo que fue el principal eje para comprender por completo los servicios WCF).

Pues bien, primero crea el proyecto que necesitas, esto es algo así (por costumbre es que siempre inicio mis proyectos en Blend, puedes comenzarlos como mejor te acomodes).

img51

Ahora para hacernos las cosas mas sencillas, puedes brincar a VS2010 y simplemente arrastrar y seleccionar un control de mapa que está entre tus herramientas, así nos quitamos de muchos pasos.

img52

Ya que tienes tu control de mapa en la aplicación, debes ponerle al igual que tu aplicación web las credenciales que obtuviste para desarrollar en Bing (puedes usar las mismas que en la parte uno de este tutorial), después de las credenciales puedes escoger el tipo de mapa que usarás así como cualquier ajuste que quieran, en mi caso por ser de México, pude poner los siguientes valores para el ZoomLevel y Center del mapa.

Center=”22.75791,-101.5966″ ZoomLevel=”5.900″

Entonces mi vista previa quedaría de la siguiente manera.

img53

Ya que tenemos el mapa lo único que nos hace falta es mandar llamar el servicio WCF que creamos en la parte 4 de esta serie, sino lo has publicado, ahora es cuando debas hacerlo pues usaremos esa URL (para saber como hacerlo esta la Parte 3 de esta serie a tu disposición ), para eso darás clic derecho sobre el proyecto y agrega una “Referencia de Servicio”.

img54

En el cuadro de diálogo escribe la URL de tu servicio WCF y presiona el botón de “Ir” para que te aparezca el servicio en el cuadro de abajo así como sus métodos existentes, solo falta que hasta abajo escribas el nombre de esa referencia para que quede de la siguiente manera (aclaro que no necesitas dar clic hasta dar con tu método, solo es un método para confirmar que si es el servicio que necesitas).

img55

Ahora en la interfaz agrega un botón para mandar llamar ese servicio (yo lo pondré hasta arriba para usar ese espacio sin chiste donde esta el título), y en su evento clic es donde vas a mandar traer al método de tu servicio.

Como puedes recordar, al momento de hacer el servicio WCF le estableciste cuatro parámetros, entonces ahora debes mandarlos para que el servicio haga lo suyo, si te preguntas de donde los sacas checa la siguiente imagen.

img56

Entonces el BoundingRectangle te permitirá obtener las coordenadas de tus cuatro extremos del mapa y gracias a eso el servicio podrá determinar el área de visibilidad que tienes en tu pantalla para que de acuerdo a ello te regrese solo los resultados que estén al alcance de tu vista y no todos.

Para continuar, antes de que escribas algo en el evento Completed, debes declarar una variable global de tipo MapLayer y crear un nuevo UserControl.

img57

En este nuevo UserControl, solo debes preocuparte por poner un PushPin, para que te quede algo así.

Y en por el lado de tu código C# debe quedar de la esta forma.

Y ya con variable y control de usuario creados puedes meter este código en el evento Completed del servicio WCF

Simplemente a partir del resultado obtenido asignas un valos a tu control de usuario y usas un objeto de tipo Location para recibir las coordenadas, ya que tienes ambos elementos, los colocarás dentro de un MapLayer (el que creaste antes) y ese objeto será el que insertes dentro de tu mapa, por último nos quedamos con el evento MouseLeftButtonDown de nuestro control creado, pero de nuevo, antes de continuar ahora necesitas crear una página nueva de la siguiente manera (Puede ser “Portrait” o “Landscape”, como la prefieras, no hay problema).

img58

Y en esa página inserta los controles necesarios para que quede de la siguiente manera en tu XAML

Y por el lado de tu code behind así.

Ok, ahora si puedes regresar a tu ventana principal y colocar el siguiente código en el evento que dejamos pendiente.

Listo!!! Si todo te marchó de acuerdo a lo requerido ahora si hagamos la prueba de fuego, entra a tu aplicación web y señala un par de lugares.

img59

Y después vete a tu aplicación móvil.

img60 img62

Aquí el código del proyecto móvil.

Descargar código.

Y por si se las perdieron, aquí están las entradas anteriores.

1.- Usar bing maps en Silverlight 4

2.- Implementar un servicio web ASP dentro de mi aplicación Silverlight

3.- Publicar mi aplicación web

4.- Crear un servicio WCF para obtener datos

Categories: Uncategorized Tags:

México: Desarrolla 3 Aplicaciones y Gana un WP7 LG Optimus 7

January 18th, 2011 No comments

Del blog de mi buen amigo Omar Avilés, les dejo esta información que les será de bastante interés si son desarrolladores de Silverlight y/o Windows Phone 7:

El hub de Marketplace en Windows Phone 7

No te quedes sin tu Windows Phone 7 LG Optimus 7 tenemos una nueva oportunidad donde sin duda podrás ganar uno. Disponible para los primeros 60 desarrolladores que publiquen 3 apps.

Para poder tener tu Windows Phone 7 tienes que desarrollar y publica 3 aplicaciones y/o juegos en Marketplace de Windows Phone 7 antes del 6 de mayo de 2011.

Considera lo siguiente:

  • Tus aplicaciones tienen que estar publicadas en la tienda a más tardar el 6 de mayo de 2011 a media noche. Ojo: si subes tus aplicaciones y no están publicadas estas no contarán para que puedas recibir tu Windows Phone. Tus aplicaciones tienen que poder ser descargables desde Marketplace a más tardar el 6 de mayo de 2011. El 9 de mayo de 2011 revisaremos la calificación (”ranking”) de tus apps/juegos: las apps/juegos que contarán serán aquellas que tengan una calificación mínima de 3 estrellas.
  • Ojo: considera el tiempo de creación de tu cuenta de Marketplace. Para no tener contratiempos te recomendamos abrir tu cuenta de Marketplace lo más pronto posible.
  • Oferta limitada a 1 teléfono por desarrollador. El teléfono se mandará a los datos registrados en la cuenta de Marketplace.
  • No se aceptarán variantes de la misma aplicación (si hiciste pac man y subes pac man 2 cambiando solo una pequeña variable en el juego solo contará como una sola aplicación). Tienen que ser 3 aplicaciones y/o juegos diferentes.
  • Si ya publicaste una o varias aplicaciones tienes una gran ventaja.
  • Válido para desarrolladores con cuenta AppHub basadas en México.
  • Oferta limitada a los primeros 60 desarrolladores que publiquen sus 3 aplicaciones o juegos antes del 6 de mayo de 2011. Recuerda que tus aplicaciones / juegos tienen que tener por lo menos 3 estrellas de calificación para poder contar como válidas y poder sumar tus 3 aplicaciones

Pasos a seguir para concursar:

  • Paso 1 : mándanos un correo a quieromiwp7@live.com  con (i) tu nombre, apellido (ii) teléfonos (iii) e-mail (iv) nombres de tus 3 aplicaciones o juegos antes del 6 de mayo 2011.
  • Paso 2:   publica tus 3 aplicaciones antes del 6 de mayo de 2011
  • Paso 3: el 9 de mayo checa la calificación de tus apps. Si tienes por lo menos 3 estrellas de calificación reclama tu teléfono mandando un correo a Omar Aviles indicando tu nombre y el nombre de tus 3 aplicaciones o juegos. Mandaremos tu Windows Phone 7 a la dirección registrada en Marketplace.

Si eres estudiante y eres miembro del programa DreamSpark la subscripción al programa de desarrolladores para Windows Phone 7 es gratuita, si aún no eres parte del programa DreamSpark solicita un código mandando un email a quiero un código para publicar mis apps

Cuarta entrada un pequeño SIG (Crear un servicio WCF)

January 16th, 2011 No comments

Bien, continuemos con la parte 4 del camino a hacer un pequeño SIG usando tanto Silverlight por el lado web, como para orientarlo a Windows Phone 7, en este caso harás el servicio que le mandará los datos a la aplicación del teléfono (me cuesta llamarlo así, pero bueno), así que empezamos en Visual Studio creando una nueva solución, y escogiendo un “WCF Service” (estas herramientas se instalan junto con las de Silverlight 4).

Ok debido a que tienes tu base de datos, lo primero que debes hacer será vincularla para eso en la pestaña del server Explorer (si no la ves puedes abrirla desde el menú “Ver”), ahí presiona el botón de “Añadir una conexión a base de datos” img23 y te aparecerá un cuadro de diálogo de la siguiente manera.

img24

Como puedes ver, debes establecer tu Servidor de Bases de datos así como la base de datos a consultar, no es nada difícil, si todo salió bien la base de datos aparecerá en una lista de conexiones en tu Ventana de “Explorador de Servidores” de la siguiente manera.

img25

Ya que tienes tu conexión establecida vamos a añadir un nuevo item en tu proyecto (ya lo vimos, pero solo para recordar).

img26

Y el nuevo item que vas a añadir será el de “Linq to SQL classes”.

img27

Llámalo como gustes, yo usaré “LugarEstablecido”, da clic en siguiente y selecciona la opción de generarlo desde una base de datos, en la tercer ventana deja por esta ocasión los valores preestablecidos, solo da clic en siguiente, en la última ventana escoge únicamente el checkbox que de Tablas, para salir da clic en finalizar.

img28

Como puedes ver, tienes un archivo .dbml ya añadido dentro de tu proyecto y solo debiste arrastrar la tabla de tu explorador de servidores hacia el área en blanco para ya tenerla ingresada, bien ahora ve al archivo que se llama “IService1.cs” y ahí coloca el siguiente código.

Aclaro que Lugare es el nombre con el que arrastré a mi tabla como lo puedes ver en la imagen anterior, así que deberás reemplazar esa parte por el nombre de tu tabla, además puedes notar que estoy pasando cuatro parámetros de tipo doble en el contrato, estos los aclararé en el siguiente paso, y para llegar a él pasa al archivo “Service1.svc.cs”, e inserta el siguiente código.

Lo que acabas de hacer es generar la método que te devolverá los resultados de una selección en forma de lista, la selección fue hecha en base a Linq, y si miras la imagen siguiente, será mas fácil de explicar.

img29

Si ya viste la imagen en grande puedes ver entonces que los valores que queremos serán los límites, aún así en la siguiente parte lo veremos un poco mas detallado.

Por ahora ejecuta tu servicio y tu resultado debe ser parecido al de esta imagen.

img30

Como puedes ver, al igual que la parte 2 de esta serie tu dirección tiene un número de puerto, así que sigue los mismos pasos de la parte 3 y publica tu servicio en tu IIS, para poder usarlo en la siguiente parte.

Categories: Uncategorized Tags:

Tercera entrada un pequeño SIG (Publicación)

January 16th, 2011 No comments

Muy bien, antes de comenzar, quiero aclarar que esta parte es completamente opcional, solo hago referencia pues es importante cubrir el hecho de que no siempre trabajaremos con una aplicación en modo de prueba y pues es bien importante que sepamos que modificar para poder ver nuestra aplicación ya publicada.

Si estás comenzando a partir de esta parte sin haber pasado por las dos anteriores, entonces puedes descargar el proyecto con los avances ya hechos desde aquí.

Descargar código.

Bien antes que nada ve a la dirección de tu IIS y crea una carpeta con cualquier nombre, después ve al botón inicio de tu máquina, (asumiendo que usan Windows 7) selecciona “Equipo” pero dando clic derecho para terminar en la opción “Administrar”.

En la ventana de administración, selecciona de la columna extrema izquierda Administración de Internet Information Services y después de la columna que sale a después selecciona con un clic derecho la carpeta que recién creaste, así al final escoge la opción “Convertir en aplicación” para que tu carpeta quede como una aplicación en lugar de un simple directorio.

Bien ya que terminaste con esto, entonces brinca a Visual Studio y en el menú de Generar escoge la opción de “Publicar Aplicación”

Esto abrirá un cuadro de diálogo que te va a permitir configurar el lugar en donde tu sitio será desplegado

Presiona el botón con los tres puntos para que puedas configurar vía IIS la dirección que usarás, es aquí en donde escogerás la carpeta del sitio que acabas de crear hace unos pasos.

Listo, un par de clics en “Aceptar” y se habrá publicado tu sitio en tu IIS, ahora viene algo muy IMPORTANTE, la dirección de tu servicio web sigue con la de desarrollo (lleva un número de puerto), para solucionar esto, entra a la que es la nueva dirección de tu servicio web, algo así como:

localhost / Nombre de tu folder/ServicioDatos.asmx

Ya con la nueva dirección en Visual Studio da clic derecho sobre la referencia de servicio y escoge la opción de “Configurar Referencia”, ahí reemplzarás la información de la siguiente manera.

De esta manera estarás haciendo referencia a la dirección sin tener que abrir tu proyecto, por último solo vuelve a publicar tu sitio y quedará listo.

Hasta aquí llegamos por la parte de subir información vía web a nuestra base de datos, a partir del siguiente artículo comenzaremos a obtener esa información.

Categories: Uncategorized Tags:

Sitios Silverlight de Inspiración

January 8th, 2011 No comments

Hola Universo:

Como sabrán, no soy un MVP en Silverlight, simplemente un estudiante y amante mas de esta tecnología. Pero mucha gente sabe esto y me ha preguntado ya sea por curiosidad o real interés la viabilidad de implementarlo en sus proyectos. Uno de los comentarios mas frecuentes que me hacen es que no ven Silverlight en la web, ósea en las paginas, blogs, sistemas de información en línea, etc. Por esta razón me he dado la tarea de recopilar sitios web que ya implementan Silverlight con increíbles resultados.

En este post les mostrare algunas paginas ya sea personales o empresariales que ocupan Silverlight para mejorar la experiencia de usuario. Si eres desarrollador Silverlight igual te interesara ya que es un recurso para inspiración Guiño:

Mondo Auto

Descripción:

Catálogos de Autos

site2

Enlace

Faith Cristian Center

Descripción:

Comunidad religiosa

site3

Enlace

ScandiumCMS

Descripción:

Sistema Manejador de Contenido (CMS)

site4

Enlace

ProtectionShield

Descripción:

Servicios de seguridad

site5

Enlace

360Master

Descripción:

Fotografía

site6

Enlace

Helnix

Multimedia

site7

Enlace

Tributo a Michael Jackson

Descripción:

No es necesaria

site8

Enlace

Fleur des Salines

Descripción:

Turismo

site10

Enlace

El Quinto Sol

Descripción:

Desarrollo de Software

site11

Enlace

DigidHamU

Descripción:

Fotografía

site14

Enlace

Por hoy han sido 10 sitios pero aumentare esta lista para agrado de todos ustedes. Si desean colaborar con la causa bienvenido sea, en comentarios pueden dejar los enlaces que quieran.

Compilación Completa!

Categories: Uncategorized Tags: