Hola a Tod@s
Aquí les comparto la información y el material del WebCast del día de ayer:
Espero que aprovechen y disfruten esta información.
viernes, diciembre 07, 2012
viernes, noviembre 30, 2012
[Evento Virtual] MVP de Colombia
Hola a tod@s!
Hoy quiero invitarlos a estas charlas que realizarán algunos de los MVP de Colombia, en la cual participare con una charla sobre desarrollo para Windows Phone.
Aquí les dejo el flayer:
Las charlas serán 2 por noche y tendrán una duración de 1 hora cada una, hay charlas tanto de infraestructura como de desarrollo.
Aquí los enlaces de cada una de las charlas:
Queries de información de diagnóstico en SQL Server 2012 (Guillermo Taylor)
https://www.livemeeting.com/cc/mvp/join?id=9TMHDJ+role=attend
https://www.livemeeting.com/cc/mvp/join?id=T3G792+role=attend
https://www.livemeeting.com/cc/mvp/join?id=JBK5M5+role=attend
https://www.livemeeting.com/cc/mvp/join?id=4PWQTM+role=attend
https://www.livemeeting.com/cc/mvp/join?id=5PTSBD+role=attend
https://www.livemeeting.com/cc/mvp/join?id=BMKT3G+role=attend
No se lo pierdan!!!
Hasta la próxima!
lunes, noviembre 05, 2012
[Win8] Puntos a tener en cuenta para publicar Apps en el Store de Windows 8
Hola a tod@s,
Hoy voy a explicarles que puntos son importantes al momento de publicar un App en la tienda de Windows 8.
A continuación enumero lo que debemos tener en cuenta para publicar Apps en la tienda de Windows 8.
1. Seleccionar el idioma del App y de la tienda:
Independiente que el idioma de Visual Studio sea ingles, el idioma de la aplicación y sobre el cual se certificará en la tienda debe ser claro y especifico.
En mi caso, el idioma es español y en Colombia.
2. La descripción de la aplicación que se va a colocar en la tienda debe ser una frase que tenga mínimo 7 palabras, no debe ser una palabra. Debe describir de manera rápida y sencilla lo que hace la aplicación.
3. Se deben enviar mínimo 2 imágenes de 1366 x 768, a pesar de que solo se exige 1, si se envía 1 imagen nos rechazan el App.
4. Es muy importante tener una pagina web o Url en donde se publique una Política de privacidad para nuestro App.
Si no tiene una, puede utilizar esta, que es la de la comunidad BDotNet, tiene el texto tanto en ingles como en español. http://bdotnet.wix.com/privacypolicy
Además su App debe tener un charm en donde indique la política de privacidad que utilizas, en este link te indico como puedes crear este charm: Crear página de Política de Privacidad de un App Windos 8
5. Llenar o dar las instrucciones necesarias a los que prueban nuestra Aplicación sobre el manejo de la aplicación para que no sea rechazada porque no la saben manejar.
En la imagen un ejemplo sobre este punto.
6. Es muy importante el rango de edad en el cual coloca su App, si su rango de edad es de 3 años o superior, o de siete años o superior, su App no debe tener conexión a Internet ni hacer utilización de la cámara del dispositivo.
Tengamos muy en cuenta las opciones y recomendaciones que nos da la misma tienda de Windows para ubicar nuestro App en uno de los rangos de fechas disponibles.
En este momento no hay posibilidad si no de estas 4 opciones para nuestro App.
7. La imágenes del App, si verificamos la carpeta Assets del explorador de soluciones de Visual Studio, debemos dejar los mismos nombres de las imágenes, el mismo formato y principalmente las mismas dimensiones de lo contrario nuestro App será rechazado el momento de ejecutar el kit de Certificación de App para Windows 8.
Un ejemplo de esto:
Si cambia el nombre de la imagen del logo por ejemplo debe indicarlo en el manifiesto también del App de manera correcta.
8. Si utiliza una base de datos local, como SQLite, debe asegurarse que en las propiedades del proyecto en la pestaña de Compilación (Build) esté seleccionado el procesador correcto de su PC, y asegurarse que en las referencias del proyecto, la referencia de SQLIte no tenga una davertencia, si la tiene, elimine la referencia y vuelva a crear la referencia a SQLite.
9. Al publicar su App debe asegurarse que tener en “Release” su App al momento de las compilaciones y verificaciones que se realizan con el KIT de Certificación.
Pronto si encuentro mas puntos importantes a tener en cuenta al momento de subir Apps al Store de Windows 8 se las estaré comunicando por aquí.
Dios los bendiga a tod@s!
miércoles, octubre 17, 2012
[Windows8] Crear la pagina de Settings
Hola a tod@s!
Hoy vamos a ver como podemos crea la pagina de settings de nuestra App para windows 8 en donde mostramos la Política de Privacidad de nuestra app.
Este es uno de los motivos mas frecuentes por los cuales devuelven App al subirlas al Store de Windows 8.
Nos envían un mensaje como:
Cumplimiento del contenido: error
Con esta prueba se evalúa tu software para ver si su contenido cumple los requisitos de certificación de la Tienda Windows.
Tu aplicación no cumple el requisito 4.1.
Notas de los evaluadores:
C:: Our reviewer could not find a privacy statement in the Windows Charm settings of this app.
1. creamos nuestro proyecto para el App de Windows 8:
Adicionamos un nuevo item, que va a ser una nueva página en blanco:
Llamaremos a nuestra página SettingsFlyuot.xaml, seleccionaremos una página en Blanco de la lista que nos presenta Visual Studio al momento de seleccionar App para Windows Store.
Adicionamos la página a nuestro proyecto, y nos genera el código XAML siguiente:
<Page
x:Class="Celeste.CharmsPrivacyPolicy.SettingsFlyout" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="using:Celeste.CharmsPrivacyPolicy" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d"> <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}"></Grid>
</Page>
Vamos a adicionar el siguiente codigo XAML dentro de los tags <Grid> y </Grid>:
<StackPanel>
<TextBlock Margin="5,30,0,30" Style="{StaticResource SubheaderTextStyle}" >App desarrollada por:</TextBlock>
<TextBlock Margin="5,0,0,0" FontSize="24"
Style="{StaticResource SubheaderTextStyle}" >Roberto Alvarado Taborda
</TextBlock>
<TextBlock Margin="5,0,0,0" FontSize="24"
Style="{StaticResource SubheaderTextStyle}" >Celeste Software SAS
</TextBlock>
<TextBlock Margin="5,0,0,0" FontSize="24"
Style="{StaticResource SubheaderTextStyle}" >Bogotá D.C., Colombia</TextBlock>
<TextBlock Margin="5,0,0,0" FontSize="24"
Style="{StaticResource SubheaderTextStyle}" >ralvaradot@hotmail.com
</TextBlock>
<TextBlock Margin="5,0,0,0" FontSize="24"
Style="{StaticResource SubheaderTextStyle}" > http://bdotnet.wix.com/privacypolicy</TextBlock> <TextBlock Margin="5,30,0,30" Style="{StaticResource SubheaderTextStyle}" >Política de privacidad</TextBlock>
<TextBlock Margin="5,0,0,0" FontSize="18"
Style="{StaticResource SubheaderTextStyle}" >La aplicación hace uso de la conexión a internet, única y exclusivamente,
para descargar información relativa de la misma desde nuestros servidores.</TextBlock>
<TextBlock Margin="5,0,0,0" FontSize="18"
Style="{StaticResource SubheaderTextStyle}" >Ninguna información de la máquina o del usuario es enviada de vuelta a ellos
ni a ningún otro servidor a través de internet ni de ningún otro medio por
parte de esta aplicación.</TextBlock>
<TextBlock Margin="5,0,0,0" FontSize="18"
Style="{StaticResource SubheaderTextStyle}" >Es responsabilidad del usuario el manejo que este haga de los datos que son
registrados a través de la aplicación.</TextBlock>
</StackPanel>
De estos datos son importantes: el link de la página en internet donde están publicadas las políticas de privacidad de la aplicación, el email de contacto.
La línea del nombre de la empresa la pueden obviar o eliminar.
El diseño de la pagina se verá mas o menos así:
Vamos a abrir la pagina principal o inicial de nuestra App, en nuestro caso es MainPage.xaml:
Vamos a abrir el “Code Behind” y colocar este código en la clase:
public sealed partial class MainPage : Page
{ private Rect windowBounds;private double settingsWidth = 400;
private Popup settingsPopup; public MainPage() { this.InitializeComponent();}
Estas variables nos servirán para adecuar el manejo de Charms de settings que es lo que deseamos.
Vamos ahora a abrir el archivo App.xaml.cs para incluir una variable de Aplicación:
namespace Celeste.CharmsPrivacyPolicy{ /// <summary> /// Provides application-specific behavior to supplement the default Application class. /// </summary>sealed partial class App : Application
{public static bool isEventRegistered;
/// <summary> /// Initializes the singleton application object. This is the first line of authored code /// executed, and as such is the logical equivalent of main() or WinMain(). /// </summary> public App() { this.InitializeComponent(); this.Suspending += OnSuspending;}
Regresamos a nuestra página principal, Mainpage.xaml.cs y allí adicionamos código al constructor de tal forma que se vea como se muestra a continuación:
public MainPage() { this.InitializeComponent();windowBounds = Window.Current.Bounds;
Window.Current.SizeChanged += OnWindowSizeChanged;
if (!App.isEventRegistered) {SettingsPane.GetForCurrentView().CommandsRequested += onCommandsRequested;
App.isEventRegistered = true;}
}
Lo que estamos haciendo aquí es configurar el tamaño de la ventana, adicionar el método a ejecutar al evento SizeChanged y verificar si el evento está o no registrado en el App para hacerlo solo 1 vez.
Si el evento no esta registrado lo registramos en el App, en la línea:
SettingsPane.GetForCurrentView().CommandsRequested += onCommandsRequested;
Ahora vamos a adicionar el código del método onCommandsRequested que adiciona un handler para verificar al ventana del Setting a mostrar.
private void onCommandsRequested(SettingsPane sender, SettingsPaneCommandsRequestedEventArgs eventArgs)
{ UICommandInvokedHandler handler = new UICommandInvokedHandler(onSettingsCommand);SettingsCommand generalCommand = new SettingsCommand("DefaultsId", "Acerca de", handler);
eventArgs.Request.ApplicationCommands.Add(generalCommand);
}
Ahora el método onSettingsCommand en el cual definimos y configuramos la ventana de Settings:
private void onSettingsCommand(IUICommand command)
{ // Create a Popup window which will contain our flyout. settingsPopup = new Popup();settingsPopup.Closed += OnPopupClosed;
Window.Current.Activated += OnWindowActivated;
settingsPopup.IsLightDismissEnabled = true;settingsPopup.Width = settingsWidth;
settingsPopup.Height = windowBounds.Height;
// Add the proper animation for the panel. settingsPopup.ChildTransitions = new TransitionCollection(); settingsPopup.ChildTransitions.Add(new PaneThemeTransition() {Edge = (SettingsPane.Edge == SettingsEdgeLocation.Right) ?
EdgeTransitionLocation.Right :
EdgeTransitionLocation.Left
});
// Create a SettingsFlyout the same dimenssions as the Popup. SettingsFlyout mypane = new SettingsFlyout();mypane.Width = settingsWidth;
mypane.Height = windowBounds.Height;
// Place the SettingsFlyout inside our Popup window.settingsPopup.Child = mypane;
// Let's define the location of our Popup.settingsPopup.SetValue(Canvas.LeftProperty, SettingsPane.Edge == SettingsEdgeLocation.Right ? (windowBounds.Width - settingsWidth) : 0);
settingsPopup.SetValue(Canvas.TopProperty, 0);
settingsPopup.IsOpen = true;}
Y por último los métodos onWindowSizeChanged se dispara al cambiar de tamaño la ventana, onWindowActivated, que se dispara al activar la ventana actual, y por último onPopupClosed, que se dispara al cerrar el popup que carga nuestra ventana de Settings.
void OnWindowSizeChanged(object sender, Windows.UI.Core.WindowSizeChangedEventArgs e)
{windowBounds = Window.Current.Bounds;
}
private void OnWindowActivated(object sender, Windows.UI.Core.WindowActivatedEventArgs e)
{ if (e.WindowActivationState == Windows.UI.Core.CoreWindowActivationState.Deactivated) { settingsPopup.IsOpen = false;}
}
void OnPopupClosed(object sender, object e)
{Window.Current.Activated -= OnWindowActivated;
}
Al ejecutar nuestra App agregando este corto código y esta página sencilla, podemos observar lo siguiente:
Podemos apreciar que aparece Acerca de, que es nuestra página de Settings.
Y al dar clic sobre “Acerca de” en el menú de settings:
Muestra nuestra pagina de settings con la política de privacidad.
Bueno amigos por hoy esto les quería contar para ayudarlos en que no rechacen sus Apps al subirlos al Windows Store.
Pueden utilizar la página de Políticas de Privacidad que ha publicado la Comunidad BDotNetLatam en la siguiente url para apuntar sus apps, es indispendable que coloquen tanto en el cuadro de texto de Política de Privacidad que se encuentra en el formulario de subir App al Store, como en esta pagina de settings que debe contener toda App a desarrollar para Windows 8.
Link a página pública de Política de Privacidad de Comunidad BDotNet
Espero que lo disfruten y logren certificar sus Apps en el Store de Windows 8.
Hasta una proxima oportunid@d, Dios los bendiga mucho!
lunes, octubre 08, 2012
[Windows8] Tip de Publicación
Hola a tod@s!
Al momento de publicar nuestro App en el Windows Apps Store, en la información que se nos solicita al momento de cargar el App para ser validado y posteriormente colocado en el Store se solicita una información que no es obligatoria, pero que si debemos colocar para que no nos devuelvan el App después de 7 días.
El tip es el siguiente:
Se debe diligenciar el campo de Política de Privacidad, aqui colocamos el link a una pagina en donde especifiquemos la política de privacidad de nuestra aplicación, por ejemplo: “Accedemos a internet, pero no tomamos información local del dispositivo y la enviamos a la web del fabricante”.
Saludos y espero que tengan en cuenta esto al momento de publicar su App en el Store.
Saludos,
Roberto Alvarado
viernes, octubre 05, 2012
[Curso] Mi Primera App Windows 8 con XAML
Hola a tod@s,
Como había prometido, aquí están los links de visualización y descarga de las sesiones 3, 4 y 5 del curso:
Pasos:
1. Ingresar a la siguiente url: https://www323.livemeeting.com/cc/usergroups/view
Les aparecerá la siguiente pantalla:
Digiten su nombre, y el Id de la grabación que deseen ver o descargar. La clave no es necesaria.
Presionan el botón “Ver grabación”, les mostrará a continuación otra pantalla en la cual deben digitar su email, y el nombre de la empresa que puede ser su nombre completo.
Presionamos el botón de “Ver grabación”, y le muestra una nueva pantalla:
Desde aquí en los iconos de la izquierda podemos ver o descargar el vídeo en cualquiera de los formatos que nos ofrece.
Ahora aquí la lista de los ID de Grabación de cada video para poder verlos y/o descargarlos:
Sesión I : R4T76T
Sesión II : RRHR6G
Sesión III: 8FF2D9
Sesión IV: 9ZPCK4
Sesión V : GMTK9D
Espero que los disfruten y aprovechen!
Saludos,
Roberto Alvarado
martes, septiembre 25, 2012
[Curso] Mi Primera App de Windows 8 con XAML
Hola a tod@s!
Aquí están los link de los videos de las dos primeras sesiones del curso:
La primera sesión:
https://www.livemeeting.com/cc/usergroups/view?id=R4T76T&pw=cD%7c6pb8Dt
la segunda sesión:
Asunto: SESION II - Mi primera App Windows 8 con XAML
Dirección URL de la grabación: https://www.livemeeting.com/cc/usergroups/view
Id. de la grabación: RRHR6G
Clave de asistente: cD|6pb8Dt
Espero los disfruten y los aprovechen
Saludos,
viernes, septiembre 14, 2012
Mi primera App de Windows 8 con XAML
Hola a tod@s!
Esta vez los estoy invitando a un curso para desarrollar Apps para Windows 8, utilizando XAML y Visual C#, el curso es totalmente virtual, serán 8 sesiones en 4 semanas, 2 sesiones semanales.
Para los que estén en Colombia tendrán posibilidad de ganar varios premios y subir su App de Windows 8 totalmente gratuita al Apps Store.
Las inscripciones en Sitio web de la comunidad BDotNet
Los llevaremos de la mano para crear su propia aplicación para Windows 8.
No se lo pierdan, pueden empezar a ganar dinero con sus Apps muy rápidamente.
Hasta la Próxima.
lunes, julio 02, 2012
[Programathon WP7] Material de la Programathon
Hola a todo@s,
A continuación les dejo los links para que puedan descargar los pdf de la presentación y el ejemplo que utilizamos para el demo y la explicación de los conceptos vistos en el evento.
Aquí las diapositivas de la presentación:
Presentancion Fundamentos Windows Phone
Acá la ruta de Skydrive para escargar el codigo ejemplo utilizado:
Descarga del código fuente del demo
Cualquier duda adicional con mucho gusto se las tratare de resolver.
Hasta una próxima oportunidad:
miércoles, junio 20, 2012
[EVENTO] Windows Phone Professional Programathon
Hola a tod@s,
Esta vez es para invitarlos este 30 de Junio a una Programathon de Windows Phone, en este momento es solo presencial en Bogotá, Pueden inscribirse en: http://www.meetup.com/BDotNet/events/69979492/
Estamos haciendo arreglos para que podamos trasmitirla en video o por Live Meeting, les estaré avisando, o en la misma pagina de meetup les avisare si esto lo logramos.
Los espero!!!
Saludos!!!
jueves, mayo 03, 2012
[EVENTO] APPSLAB {Microsoft–NOKIA} VII
Hola, el día de hoy estuvimos en la Universidad Catolica, continuando con la maratón de Windows Phone 7
Las Fotos:
El registro:
Iniciando….
En plena maratón:
Y el ganador del Nokia Lumia 800:
martes, mayo 01, 2012
[WP7] Bases de datos Locales en Windows Phone 7.5 (II)
Hola,
Hoy vamos a explicar como utilizar nuestra clase DataContext, creada en el post anterior, y vamos ya a crear directamente nuestra aplicación Windows Phone que utilice este DataContext y que podamos tener nuestra base de datos local en nuestro dispositivo.
Crear el proyecto de Windows Phone
Lo primero que debemos hacer es crear el proyecto desde Visual Studio para Silverlight para Windows Phone.
El proyecto lo vamos a desarrollar con el lenguaje C#, pero es muy similar hacerlo con VB.NET.
Abrimos VS2010 y seleccionamos un proyecto de C# y Silverlight para Windows Phone.
Seleccionamos la opción de Nuevo proyecto y nos aparece la pantalla de creación del proyecto:
Escribimos el nombre del proyecto y de la solución que vamos a crear para acceder a los datos locales de una base de datos.
Vamos a colocar el nombre a nuestro aplicativo en Windows Phone, para nuestro caso vamos a darle el nombre de AccesoDBWinPhone a nuestro proyecto. Como se aprecia en la siguiente imagen:
Al dar clic sobre el botón de OK de la pantalla, nos muestra una pantalla en la que seleccionamos la versión del SDK sobre la cual deseamos trabajar, para poder trabajar con bases de datos locales debemos seleccionar la versión 7.1 del SDK como se muestra en la imagen.
Presionamos el botón OK y Visual Studio nos muestra la ventana inicial y una pagina principal que es la página principal de nuestra aplicación.
Como se puede apreciar en la imagen, en la parte izquierda aparece la imagen de la pagina como se dibujará en la pantalla de nuestro teléfono, en la parte derecha, encontramos el código XAML que representa todo el diseño de nuestra página de la aplicación.
Lo primero que vamos a hacer es cambiar un poco el aspecto de nuestra primera pagina, que también es la principal, para esto vamos a seleccionar el control TextBlock que muestra el texto “MY APPLICATION” vamos a cambiar este titulo de la aplicación por “CODIGO MOBILE”, para esto vamos a cambiar el texto directamente en la ventana de código XAML.
Simplemente seleccionamos en la ventana de diseño el control, de inmediato en la ventana de XAML se selecciona el control correspondiente indicando en el código XAML cual es la línea correspondiente.
Vamos a cambiar el titulo de la página a “BD Locales” también haciendo uso de la pantalla de código de XAML.
Luego de hacer estos cambios nuestra pantalla se verá de la siguiente manera:
Esta página principal vamos a crear unos botones que nos servirán para realizar las operaciones necesarias en nuestra base de datos.
Vamos a crear un control StackPanel dentro del Grid llamado “ContentPanel” y dentro del StackPanel vamos a crear los botones que necesitaremos para nuestro ejemplo.
Pero antes vamos a utilizar una de las características de Silverlight para Windows Phone muy importantes y fáciles de utilizar que nos ahorran mucho código y que hacen que nuestra interfaz sea consistente, esto lo vamos a lograr creando un estilo, para crear este estilo vamos a abrir el archivo App.Xaml haciendo doble clic sobre el.
Apreciamos el código xaml de este archivo:
<Application
x:Class="AccesoDBWinPhone.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone">
<!--Application Resources-->
<Application.Resources>
</Application.Resources>
<Application.ApplicationLifetimeObjects>
<!--Required object that handles lifetime events for the application-->
<shell:PhoneApplicationService
Launching="Application_Launching" Closing="Application_Closing"
Activated="Application_Activated" Deactivated="Application_Deactivated"/>
</Application.ApplicationLifetimeObjects>
</Application>
Para crear el estilo lo debemos colocar en la sección <Application.Resources> con esto logramos que nuestro estilo sea un recurso de la aplicación.
Nuestro estilo para tener nuestros botones con fondo Azul quedara de la siguiente manera:
<!--Application Resources-->
<Application.Resources>
<Style x:Key="FondoBotones" TargetType="Button">
<Setter Property="Background" Value="Blue" ></Setter>
</Style>
</Application.Resources>
Ya con esto podemos empezar a crear nuestros botones de la pagina principal. Creamos un StackPanel y dentro el primer botón de nuestra aplicación, nuestra pantalla se verá de la siguiente manera:
El código XAML a crear es el siguiente:
<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
<StackPanel>
<Button Width="300" Height="75" Content="Crear Base de Datos"
Style="{StaticResource FondoBotones}"></Button>
</StackPanel>
</Grid>
Podemos apreciar en las propiedades del control Button, la propiedad Style como se asocia un estilo creado a un control, en este caso a los Botones de la aplicación. Para estar mas claros en la forma de asignar un estilo a nuestros controles, lo hacemos con este codigo: Style="{StaticResource FondoBotones}">
Bien es hora de asociar nuestra clase DataContext creada en el post anterior a nuestro proyecto.
Para hacerlo, simplemente abro el explorador de windows y busco el archivo, lo copio:
Luego en el proyecto de VS2010 lo pego:
Nuestro proyecto se verá de la siguiente manera:
Aquí ya incluimos nuestra clase que representa el DataContext, observen que nuestro archivo DBWinPhone.cs ya aparece dentro de los archivos del proyecto que creamos.
Ahora vamos a escribir el código para el evento click del botón que creamos, para esto hacemos doble clic sobre el botón y la ventana de código se abre. Antes vamos a darle un nombre a nuestro botón para que nuestro código sea mas claro.
Para esto seleccionamos el control de botón y vamos a la ventana de propiedades y le colocamos el nombre del control
En nuestro caso le colocamos a nuestro botón btnCrearBD para identificarlo de manera inequívoca, presionamos la tecla ENTER para que quede registrado el nombre.
Ahora en la ventana de diseño, damos doble clic en el botón para abrir la ventana de código, al hacer esto nos muestra la plantilla del método que responde al evento clic del botón.
private void btnCrearBD_Click(object sender, RoutedEventArgs e)
{
}
Como se puede apreciar en el código anterior el nombre del método toma el nombre del control button
y del evento que vamos a programar.
Lo que vamos a colocar aquí es el código para la creación de la base de datos local en nuestro dispositivo.
Pero antes debemos regresar a nuestra clase de Contexto de la base de datos y cambiar el NameSpace que tenga por el correcto:
namespace LocalDBDemo
{
using System.Data.Linq;
using System.Data.Linq.Mapping;
Debemos utilizar el NameSpace de nuestro proyecto:
namespace AccesoDBWinPhone
{
using System.Data.Linq;
using System.Data.Linq.Mapping;
Ya con este cambio, nuestro contexto de datos que vamos a utilizar para el manejo de la base de datos local en Windows Phone lo podremos acceder desde el codigo de MainPage.xaml.cs
Además necesitamos adicionar la referencia al proyecto de System.Data.Linq, sin esto no tendremos el manejo de nuestra clase DataContext agregada antes.
Para esto damos clic derecho sobre la carpeta de References de nuestro proyecto en el Explorador de Soluciones (Solution Explorer).
Esto nos muestra la ventana de los diferentes assemblies y proyectos de la solución para asociar una referencia al proyecto actual.
Aquí buscamos y seleccionamos System.Data.Linq para asignar la referencia al proyecto:
Nuestro Explorador de soluciones abrirá la carpeta de referencias si no la tenia abierta y debe lucir como la siguiente imagen:
Ahora debemos especificar la cadena de conexión a la base de datos local, esto lo haremos en una constante de tipo string en nuestro código:
// Cadena de Conexion a la base de datos local
private const string ConnectionString = @"isostore:/DBWinPhone.sdf";
Luego de haber creado la cadena de conexión para nuestra base de datos, ya podemos adicionar el código para la creacion de nuestra base de datos local.
El método quedará de la siguiente manera:
private void btnCrearBD_Click(object sender, RoutedEventArgs e)
{
try
{
using (DBWinPhoneDataContext context = new DBWinPhoneDataContext(ConnectionString))
{
if (!context.DatabaseExists())
{
// create database if it does not exist
context.CreateDatabase();
}
}
}
catch (Exception ex)
{
MessageBox.Show("Ha ocurrido un error:" + ex.Message, "Creando Base de Datos",
MessageBoxButton.OK );
}
}
Como podemos observar en el código utilizamos un bloque using para asegurarnos que los recursos a utilizar se cierren al finalizar el bloque using.
Lo que hacemos en el bloque using es:
- Crear una variable que llamamos “context” del tipo de la clase del DataContext adicionado al proyecto.
- En la instanciación de la variable, o sea en el new, le pasamos como parámetro la cadena de conexión de la base de datos a utilizar.
- Dentro del bloque using, verificamos si la base de datos existe, con la pregunta:
- if (!context.DatabaseExists())
- Si no existe, se crea la base de datos llamando al método “CreateDatabase()” del contexto.
Algo de lo cual debemos tener presente en este punto es que el Isolated Storage es como una unidad de disco para nuestra aplicación, entonces podremos en la cadena de conexión indicar la ruta en la cual quedará el archivo .sdf de la base de datos.
Ahora regresemos a nuestra página xaml y creemos un nuevo botón de Listar Países. Vamos a ir a la ventana de xaml de nuestra pagina ubicamos el código que representa al botón de Crear base de datos y lo copiamos y pegamos para luego modificar y colocar nuestro nuevo botón.
El código del botón quedará de la siguiente manera:
<Button Width="300" Height="75" Content="Listar Países"
Style="{StaticResource FondoBotones}" Name="btnListarPaises" Click="btnListarPaises_Click">
</Button>
Nuestro panel de diseño de la pagina se verá de la siguiente manera:
Ahora vamos a asegurarnos que este asociado el método para el evento click del botón, para esto seleccionamos el botón en la ventana de diseño:
Y en nuestra ventana de propiedades, seleccionamos Events en la parte superior del panel, ubicamos el evento Click, si no aparece el nombre del método damos doble click, con eso se crea el método y nos lleva a la ventana del code behind para escribir nuestro código C#.
Para mostrar la lista de los países vamos a crear un nuevo formulario en el cual mostraremos el listado de los países, para ello hacemos clic derecho sobre el nombre del proyecto y le damos a la opción del menú Add, y luego New Item..
Con esto logramos que aparezca la ventana de nuevos items para nuestro proyecto:
En esta ventana vamos a seleccionar la opción de “Windows Phone Portrait Page”, para crear una nueva pagina xaml, el nombre que le vamos a colocar es ListarPaises.xaml.
Cambiamos el texto del textblock ApplicationTitle por “CODIGO MOBILE” y el texto del textblock PageTitle por “listar países”.
Luego vamos al panel de ToolBox y buscamos el control ListBox y lo arrastramos y soltamos sobre el área debajo de los títulos, y lo acomodamos a nuestra página de tal forma que se vea así:
Si nos damos cuenta el ListBox esta seleccionado y lo hemos acomodado en la parte inferior del control Grid que muestra nuestra página.
Vamos al panel de propiedades del control ListBox, y le vamos a dar un nombre al control:
Ahora vamos a crear los Items del Listbox, para ello lo vamos a hacer desde el código XAML de la página pues vamos a tener mucho más control de lo que queremos realizar.
Vamos a utilizar ListBox.ItemTemplate y dentro de este un DataTemplate, para especificar como queremos se muestren los datos.
Para mostrar los datos vamos a utilizar dos TextBlock uno para el Id del País y otro para el nombre del país, entonces vamos a utilizar un control StackPanel para apilar los controles de manera Horizontal y dentro colocamos los dos textBlock para mostrar los datos, estos dos TextBlock se enlazaran (binding) con los datos a mostrar.
Nuestro Código XAML se verá de la siguiente forma:
<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
<ListBox Height="481" HorizontalAlignment="Left" Margin="0,120,0,0" Name="lstPaises"
VerticalAlignment="Top" Width="460">
<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal">
<TextBlock FontSize="40">
<Run Text="{Binding Id}"/>
<Run Text="{Binding Pais}"/>
</TextBlock>
</StackPanel>
</DataTemplate>
</ListBox.ItemTemplate>
</ListBox>
</Grid>
Ahora debemos crear una clase que nos sirva de Helper o que implemente el patrón facade (Fachada) que interactúe con el contexto y nos devuelva los datos que necesitamos mostrar .
Para ello nuevamente damos clic derecho en el nombre del proyecto en el panel de Explorador de Solución, buscamos la opción Add, en el submenú, buscamos Class…
Abre la ventana, y en el nombre de la clase colocamos PaisHelper.cs, con esto nos abre la ventana de código de la clase que acabamos de crear.
Debemos adicionar el using System.Collections.Generic a nuestra clase para poder utilizar las listas genéricas y trasladar nuestros datos en estas colecciones.
Además debemos definir aquí una variable constante que indique la cadena de conexión de nuestra base de datos.
Y por último el método que vamos a llamar GetPaises() el cual usaremos para obtener el listado de países de la tabla.
El código de nuestra clase:
using System.Collections.Generic;
namespace AccesoDBWinPhone
{
public class PaisHelper
{
// Cadena de Conexion a la base de datos local
private const string ConnectionString = @"isostore:/DBWinPhone.sdf";
public static List<Pai> GetPaises()
{
List<Pai> paises = new List<Pai>();
using (var context = new DBWinPhoneDataContext(ConnectionString))
{
if (context.DatabaseExists())
{
Pai pais = new Pai();
foreach (var item in context.Pais)
{
pais = new Pai();
pais.Id = item.Id;
pais.Pais = item.Pais;
paises.Add(pais);
}
}
}
return paises;
}
}
}
Nuestro método devuelve una lista genérica de los países en la tabla de país de la base de datos local de nuestro dispositivo.
Ahora retornamos a nuestra página ListarPaises.xaml para colocar el código.
Para ello mostramos la ventana de código dando clic derecho sobre la página y en el menú contextual que aparece seleccionamos la opción “View code” (ver código).
En el constructor de la página vamos a activar el evento Loaded para que al cargar la página se llene con los datos el ListBox.
Escribimos el código de la figura, al llegar el = nos muestra este mensaje, le damos al botón TAB dos (2) veces y se crea la plantilla del evento:
namespace AccesoDBWinPhone
{
public partial class ListarPaises : PhoneApplicationPage
{
public ListarPaises()
{
InitializeComponent();
this.Loaded += new RoutedEventHandler(ListarPaises_Loaded);
}
void ListarPaises_Loaded(object sender, RoutedEventArgs e)
{
throw new NotImplementedException();
}
}
}
Ahora vamos a colocar el código correcto en el método ListarPaises_Loaded, vamos a asignar a los items del ListBox la lista genérica que nos devuelve el Helper.
void ListarPaises_Loaded(object sender, RoutedEventArgs e)
{
lstPaises.ItemsSource = PaisHelper.GetPaises();
}
Ahora solo nos falta que desde el botón de la página principal llame a esta página para que nuestro ejemplo funcione.
Regresamos a la página MainPage.xaml y damos doble clic sobre el botón de Listar Paises, esto nos abre la ventana de código.
private void btnListarPaises_Click(object sender, RoutedEventArgs e)
{
// Aqui llamamos a una nueva página para mostrar la lista de los paises
NavigationService.Navigate(new Uri("/ListarPaises.xaml",UriKind.RelativeOrAbsolute));
}
Con esto llamamos a la página que muestra los datos de los países que hay en nuestra tabla de países de la base de datos.
Por hoy hasta aquí voy a llegar con este post, en próximos días estaré publicando los post para la creación, modificación y eliminación de registros.
Hasta pronto!!!
Suscribirse a:
Entradas (Atom)