tarea progra
DESCRIPTION
Todo acerca de androidTRANSCRIPT
Universidad Francisco Gavidia
PROGRAMACION PARA WINDOWS PHONE2015
Laboratorio 04
2
Contenido1. Introducción...............................................................................................................................3
2. Windows Phone.........................................................................................................................4
3. Kernel de Windows Phone.........................................................................................................5
3.1. Kernel Windows NT............................................................................................................5
3.2. Núcleo................................................................................................................................6
4. Arquitectura software de Windows Phone................................................................................7
5. Lenguaje C#................................................................................................................................9
5.1. C# en Windows Phone......................................................................................................10
6. Herramientas de Desarrollo para Windows Phone..................................................................11
7. Estructura de una página en Windows Phone..........................................................................11
8. Estructura de un proyecto........................................................................................................13
9. Controles Gráficos....................................................................................................................15
9.1. TextBox.............................................................................................................................15
9.2. PasswordBox....................................................................................................................17
9.3. Botones............................................................................................................................18
9.4. RadioButtons....................................................................................................................19
9.5. CheckBox..........................................................................................................................20
9.6. ComboBox........................................................................................................................23
9.7. DatePicker........................................................................................................................24
9.8. TimePicker........................................................................................................................27
10. Conclusión............................................................................................................................29
3
1. Introducción
Para nadie es un secreto que a finales de la década pasada, el gran apogeo de los
Smartphone comenzó a ser relevante para la industria software, pues el mundo comenzó
una migración hacia el uso de tecnología desde el alcance de sus manos, y el uso de
equipos tradicionales comenzó a reducir gracias a esta migración, el número de usuarios
comenzó a crecer, y comenzaron a usar un diferenciador particular entre un dispositivo
Smartphone y otro, y precisamente no era por sus características hardware, sino por su
Sistema Operativo, de ahí en adelante comienza relucir como factor diferenciador entre
dispositivos móviles el sistema operativo.
Apple y Google son los principales competidores en estas plataformas, Microsoft ocupa el
tercer lugar en esta competencia con su nueva plataforma para dispositivos móviles
Windows Phone. Microsoft está haciendo una apuesta muy grande hacia los
desarrolladores de sus tecnologías. Actualmente obsequia diferentes opciones para crear
aplicaciones para Windows Phone, una de esas es brindar el kit de desarrollo de manera
gratuita y abundante documentación como soporte. También está decidido a entrar a
competir al mismo nivel junto a Apple y Google, pero quiere que sus principales
protagonistas sean los mismos desarrolladores de aplicaciones para Windows Phone. Este
documento está orientado a aquellos desarrolladores que deseen comenzar en el nuevo
mundo de Windows Phone, Conociendo sus estructuras hardware y software, lenguajes
usados para el desarrollo App, documentación para poder usar el Kit de desarrollo, una
guía de desarrollo de una aplicación básica donde se aplique los conceptos básicos que se
involucran en todo el documento, entre otras cosas.
4
2. Windows Phone
Windows Phone es la nueva versión del sistema operativo móvil de Microsoft, este nuevo
sistema operativo se ha reconstruido para brindar una mejor experiencia a sus usuarios, y
para los desarrolladores una plataforma de desarrollo sencillo pero a la vez bastante
robusta. Windows Phone, antes llamado Windows Mobile fue diseñado para su uso en
teléfonos inteligentes (Smartphones) y está basado en el núcleo del sistema operativo
Windows CE 6.0.
El 15 de Febrero de 2010, durante el Mobile World Congress celebrado en Barcelona,
Microsoft presentó al mundo su nuevo sistema operativo para Smartphones: Windows
Phone 7.
Su desarrollo comenzó en 2008 tras la reorganización del equipo de Windows Mobile y la
cancelación del proyecto “Photon”, la versión del sistema en la que Microsoft trabajaba
desde 2004 con pocos resultados. Originalmente se planteó su salida al mercado en 2009,
pero una serie de retrasos obligaron a preparar una versión de transición de Windows
Mobile (WM 6.5) y retrasar el lanzamiento de Windows Phone 7 hasta Octubre de 2010
en Europa, Noviembre de 2010 en USA y 2011 para Asia. (Geek.ms)
Siguiendo con las fechas, el 20 de Junio de 2012, Joe Belfiore en un evento celebrado en
San Francisco, presentó al mundo la nueva versión del sistema operativo móvil de
Microsoft; lo que hasta el momento se conocía como Apollo, pasó formalmente a llamarse
Windows Phone 8.
Una de las principales modificaciones que incorpora dicha actualización es la adopción del
núcleo del sistema de Windows 8. A partir de este momento Windows Core (nombre
como se le denomina actualmente) constituye las tripas de nuestro sistema móvil,
dejando así de lado al utilizado hasta ese momento, el cual era conocido como Windows
CE.
Una de las mayores ventajas que aporta el uso de un núcleo común es que la integración
entre ambos sistemas es muy extensa. La API de desarrollo, a partir de este momento, es
5
un subsistema de WinRT, conocido como WinPRT, compartiendo entre ambos mundos
muchas de las instrucciones.
3. Kernel de Windows Phone
Antes de hablar del Kernel de Windows Phone, es necesario saber qué es un Kernel.
El Kernel, o núcleo, es un software que constituye una parte fundamental del sistema
operativo, y se define como la parte que se ejecuta en modo privilegiado (conocido
también como modo núcleo). Es el principal responsable de facilitar a los distintos
programas acceso seguro al hardware de la computadora o en forma básica, es el
encargado de gestionar recursos, a través de servicios de llamada al sistema. Como hay
muchos programas y el acceso al hardware es limitado, también se encarga de decidir qué
programa podrá hacer uso de un dispositivo de hardware y durante cuánto tiempo, lo que
se conoce como multiplexado. Acceder al hardware directamente puede ser realmente
complejo, por lo que los núcleos suelen implementar una serie de abstracciones del
hardware. Esto permite esconder la complejidad, y proporciona una interfaz limpia y
uniforme al hardware subyacente, lo que facilita su uso al programador.
3.1. Kernel Windows NT
Actualmente, en su versión número 8, Windows Phone tiene un Kernel basado en el
Kernel Windows NT, el cual se caracteriza por tener sistemas operativos reentrantes que
han sido diseñados para trabajar tanto con computadoras con un sólo procesador como
computadoras de multiprocesamiento simétrico que en inglés es el Symmetrical Multi
Processor o SMP. Para procesar las peticiones de entrada/salida (en inglés Input/Output,
I/O) acude a una dirección de paquetes de E/S que utiliza peticiones (IRPs) y E/S asíncrona.
A partir de Windows XP, Microsoft comenzó a desarrollar sistemas operativos que
soportaban 64-bits. Antes sus sistemas operativos estaban basados en un modelo de 32-
bits.
6
Windows NT contiene características como: servicios multiusuario. Esto implica que tanto
la interfaz como los privilegios del sistema pueden variar, en función del usuario que esté
conectado al sistema, características nativas de red, etc.
La arquitectura de Windows NT es altamente modular y se basa en dos capas principales:
Modo usuario: Cuyos programas y subsistemas están limitados a los recursos del sistema
a los que tienen acceso.
Modo núcleo: Tiene acceso total a la memoria del sistema y los dispositivos externos. Los
núcleos de los sistemas operativos de esta línea son todos conocidos como núcleos
híbridos, aunque hay que aclarar que este término está en discusión ya que este núcleo es
esencialmente un núcleo monolítico que está estructurado al estilo de un micronúcleo. La
arquitectura dentro del modo núcleo se compone de lo siguiente:
Un núcleo híbrido.
Una Capa de Abstracción de Hardware (HAL).
Controladores o drivers.
Executive: Sobre el cual son implementados todos los servicios de alto nivel.
El modo núcleo de la línea de Windows NT está compuesto por subsistemas capaces de
pasar peticiones de E/S a los controladores apropiados usando el gestor de E/S. Dos
subsistemas crean la capa del modo usuario de Windows 2000: el subsistema de Entorno
(ejecuta aplicaciones escritas para distintos tipos de sistemas operativos), y el subsistema
Integral (maneja funciones específicas de sistema de parte del subsistema de Entorno). El
modo núcleo en Windows 2000 tiene acceso total al hardware y a los recursos del sistema
de la computadora. El modo núcleo impide a los servicios del modo usuario y las
aplicaciones acceder a áreas críticas del sistema operativo a las que no deberían tener
acceso.
3.2. NúcleoEl núcleo del sistema operativo se encuentra entre el HAL y el Executive y proporciona
sincronización multiprocesador, hilos y envío y planificación de interrupciones, gestión de
7
interrupciones y envío de excepciones. También es responsable de la inicialización de
controladores de dispositivos que son necesarios en el arranque para mantener el sistema
operativo funcionando. Esto es, el núcleo realiza casi todas las tareas de un micronúcleo
tradicional. La distinción estricta entre el Executive y el núcleo consiste en que quedan
más restos en este último del diseño original del micronúcleo, (la documentación histórica
del diseño se refiere al componente del núcleo como "el micronúcleo").
El núcleo a menudo interactúa con el gestor de procesos.10 El nivel de abstracción es tal
que el núcleo nunca llama al gestor de procesos: únicamente se permite lo contrario
(salvo para un puñado de casos, sin llegar aún hasta el punto de una dependencia
funcional).
4. Arquitectura software de Windows Phone.
Modelo de software de Windows Phone
Todo el modelo general de software de Windows Phone está compuesto por estos elementos que se ven en la imagen.
El modelo de aplicación, siendo la forma en que se empaquetan y actúan los archivos que componen una aplicación.
El modelo de UI (Interfaz de Usuario), que define una filosofía de diseño única con sus características fundamentales.
Integración con la nube, y su importante papel en el mundo móvil para el éxito de una App.
Application Runtime, siendo una estructura base para el proceso de ejecución de una aplicación.
8
Estructura de una ejecución de aplicaciones en Windows Phone 7
Estructura de una ejecución de aplicaciones en Windows Phone 8
a) Shared Windows Core (Núcleo del sistema operativo).
El sistema operativo Windows Compact Embedded (WinCE) que actúa como núcleo en
WP7.x fue sustituido por un nuevo sistema operativo para la nueva versión de WP8, con el
fin de generar una compatibilidad con el OS de Windows para escritorios, Windows 8. Esto
quiere decir que una gran variedad de cosas en WP8 son compartidas con la
implementación para escritorios, incluyendo cosas como: Kernel, Networking, driver
FrameWork, entre otros.
El hecho de compartir el núcleo aporta como beneficios características innovadoras que
facilita un solo flujo trascendental a través de dos factores: escritorio tradicional, y
9
dispositivo móvil. También contribuye con la reducción de redundancia de ingeniería por
el lado de Microsoft.
b) CoreCLR
.NET Compact FrameWork (NETCF) que se usa en WP7 contiene una filosofía de diseño e
implementación diferente a .NET para escritorios. NETCF es un núcleo que se considera
muy portable y está diseñado para ser estrechamente versátil en diferentes plataformas.
Por el contrario, el núcleo CoreCLR, que se usa para equipos de escritorios, tiene un
vínculo estrecho con Windows y se adecua fácilmente a la arquitectura del
procesador.También trabaja muy de cerca con el hardware, ofreciendo el beneficio
máximo de rendimiento al código administrado que se ejecuta en él.
c) Compatibilidad del cambio.
Una de las declaraciones que se hizo durante el lanzamiento de WP8 fue que las App que
se encuentran en la tienda de aplicaciones de WP7 funcionarán sin ningún inconveniente
para WP8. Esto puede ser una declaración mínima, pero es un logro con mucho esfuerzo
para la implementación de la nueva perspectiva del sistema de ejecución de aplicaciones.
Construir aplicaciones en una plataforma en la cual se han generado cambios en su SO,
Runtime Application y chipset no es una tarea fácil, la cual el equipo de desarrollo de
Microsoft ha realizado para hacer esto posible.
5. Lenguaje C#
Siendo C# un lenguaje de programación que permite el desarrollo de aplicaciones para
internet, para móviles y aplicaciones de propósito general en diferentes plataformas, fue
desarrollado inicialmente para programar en la plataforma
La sintaxis de C# es muy expresiva, pero también es sencilla y fácil de aprender. Esta
sintaxis que está basada en signos de llave, podrá ser reconocida inmediatamente por
cualquier desarrollador familiarizado con C, C+ o Java. Los desarrolladores que conocen
cualquiera de estos lenguajes pueden empezar a trabajar de forma productiva en C# en un
10
plazo muy breve. La sintaxis C# simplifica muchas de las complejidades de C++ y
proporciona características eficaces.
Como lenguaje orientado a objetos, C# admite los conceptos de encapsulación, herencia y
polimorfismo. Todas las variables y métodos se encapsulan dentro de funciones de clase.
Las clases pueden heredar directamente de una clase primaria, y también pueden
implementar cualquier número de interfaces; los métodos que reemplazan a los métodos
virtuales en una clase primaria requieren la palabra clave Overrride como medio para
evitar redefiniciones accidentales.
5.1. C# en Windows Phone.En Windows Phone, C# es el lenguaje que permite construir el funcionamiento de cada
uno de los elementos que se declararon en XAML. Esto quiere decir que, mientras se crea
un elemento visual en XAML en tiempo de diseño (Campo de texto, Botón, Etiqueta,
CheckBox, RadioButton, etc.), genera una instancia dicho elemento creado y podrá ser
manipulado con facilidad desde el archivo designado como Code-Behind (Código interno).
En el interior del archivo Code-Behind, toda la estructura de negocio, puede ser manejada
por lenguajes administrados de .NET FrameWork, ya sea Visual Basic.NET, o C#. En los
siguientes casos se trabajará con C#.
En una página de Windows Phone, el archivo XAML con extensión ( .xaml) posee una
estrecha relación con un archivo Code-Behind con extensión (.xaml.cs) extensión que hace
referencia a Csharp (cs), si fuese para Visual Basic.NET sería (.xaml.vb). Esto indica que los
dos archivos actúan parcialmente en una misma página.
11
6. Herramientas de Desarrollo para Windows Phone
La cuestión de Windows Phone, de ser la más reciente plataforma operativa para
dispositivos móviles de Microsoft, y dado su retraso en optar por entrar a competir en un
negocio donde gran parte del mercado móvil está custodiado por Apple y Google; Apura al
mismo Microsoft a brindar beneficios de acceso al paquete de herramientas de desarrollo
de manera gratuita, para aquellos interesados en optar por el desarrollo de App para esta
plataforma. El Kit de desarrollo de software SDK para Windows Phone.
De manera breve un SDK (Software Development kit) o kit de desarrollo de software, es un
conjunto de herramientas de desarrollo de software que permite al desarrollador crear
aplicaciones para un sistema en concreto.
Normalmente un SDK incluye soporte para la detección de errores de programación como
un entorno de desarrollo o IDE, contienen también códigos de ejemplo, notas técnicas o
documentación de soporte, etc.
El SDK de Windows Phone proporciona las herramientas que son necesarias para
desarrollar Apps y juegos para Windows Phone 8 y Windows Phone 7.x. El paquete
completo contiene las siguientes herramientas:
Visual Studio Express 2012-2010 edition para Windows Phone
Blend para Visual Studio 2012-2010
Windows Phone Developer Registration tool
Windows Phone Connect tool
Emulators de Windows Phone 7.1 y 8.0
Windows Phone Application Analysis tool
Simulation Dashboard para Windows Phone
7. Estructura de una página en Windows Phone
Cuando se crea un proyecto en Windows Phone, el MainPage.xaml genera una plantilla
visual por defecto, dicha plantilla está compuesta por una estructura XAML que se apila de
la siguiente manera:
12
Name Space: En primera instancia se generan los espacios de nombre
correspondientes a los elementos XAML que propone El API de Silverlight, esto a
manera de importar todos los recursos necesarios para manipular los controles
nativos de Silverlight para Windows Phone.
LayoutRoot: luego se genera un contenedor “Grid” como raíz, con una labor en
particular, contener en su interior todos los controles necesarios. Generalmente el
LayoutRoot contiene en si mismo un TitlePanel y un ContentPanel.
TitlePanel: es generado por un contenedor “StackPanel”, Trabaja como
encabezado de una página en Windows Phone y habitualmente contiene el
nombre de la aplicación y el nombre de cada página.
ContentPanel: también es generado por un contenedor “Grid”, trabaja como el
cuerpo de la página, es aquí donde se ingresa el contenido visual de las
aplicaciones.
ApplicationBar: es una barra que actúa como un menú principal de cada página,
normalmente contiene botones, e ítems que hacen la labor de opciones de menú.
En términos visuales, lo anteriormente dicho se refleja de la siguiente manera:
Estructura de una página en Windows Phone
13
8. Estructura de un proyecto.
Cuando se crea un nuevo proyecto de Silverlight en visual Studio.NET lo primero que se
hace es definir para qué versión de sistema operativo Windows Phone desea apuntar la
aplicación a crear; esto por compatibilidad hace a WP 7.0, WP 7.1 y WP8 los sistemas
operativos soportados, no obstante el desarrollador tendría que tener muy buenas
razones para seleccionar en un proyecto nuevo a WP7.0 como sistema operativo ya que a
pesar de que existen muchas aplicaciones creadas que apuntan a WP7 no es
recomendable.
Una vez que se especifique el sistema operativo al que se desea apuntar,
Automáticamente se crea una estructura de carpetas con diferentes archivos como parte
de la estructura inicial de una aplicación:
14
Se puede apreciar en primera instancia los manifiestos. Los manifiestos son archivos que
poseen extensión .XAML, y brindan metadatos tanto para la aplicación Silverlight, como la
aplicación Windows Phone, necesarios para ubicar una App en la tienda de aplicaciones.
También se puede observar las referencias que se incluyen en un proyecto de WP, con el
fin de hacer referencia dentro de un proyecto a librerías, o proyectos construidos por
terceros. Así mismo se incluye un App.XAML y su Code-Behind, como archivo principal
donde se declaran todos recursos globales y sus respectivos manejadores de eventos
globales. También se incluye el archivo MainPage.XAML y su Code-Behind, que
elementalmente es la página principal de una aplicación, la cual, por defecto es la primera
página en ser visual en el momento de ejecutar una App. Y por último se incluyen algunas
imágenes, imágenes que corresponden al fondo de la aplicación, la pantalla de precarga
que normalmente es la imagen inicial que aparece cuando se ejecuta por primera vez la
aplicación en un teléfono, y el icono que representa a una aplicación en la lista de
programas instalados dentro de un teléfono.
15
9. Controles Gráficos
El framework XAML incluye diversos controles para el ingreso y edición de texto, así como
una lista de propiedades para darle formato. Los controles para el ingreso de texto son:
“Textbox”, “Passwordbox” y “RichEditBox”.
Así también posee otros elementos básicos y útiles para la creación de aplicaciones
sencillas o complejas; entre los diversos controles que existen, a continuación se explicará
de forma general algunos de los más utilizados, como lo son el TextBox, PasswordBox,
Botones, RadioButtons, entre otros.
9.1. TextBox
La clase Textbox representa un control que puede ser usado para mostrar y editar texto
plano, ya sea en una o varias líneas.
Para insertar este control, hacemos uso del siguiente código:
<TextBox Height="35" Width="200" Text="I am a TextBox" Margin="20"/>
Este control, así como todos, cuenta con una variedad de propiedades que pueden ser
utilizadas según convenga, por ejemplo, hacer que este textbox sea solo de lectura,
utilizando la propiedad <<IsReadOnly="True">>.
A continuación se muestra un ejemplo del uso de algunas propiedades y métodos. Lo que
se muestra es la funcionalidad que cuando se selecciona un texto en un textbox, el texto
seleccionado se mostrará en otro con la propiedad IsReadOnly activada:
<TextBox x:Name="textBox1" Height="75" Width="300" Margin="10"
16
Text="The text that is selected in this TextBox will show up in the read only TextBox
below."
TextWrapping="Wrap" AcceptsReturn="True"
SelectionChanged="TextBox1_SelectionChanged" />
<TextBox x:Name="textBox2" Height="75" Width="300" Margin="5"
TextWrapping="Wrap" AcceptsReturn="True" IsReadOnly="True"/>
<TextBlock x:Name="label1" HorizontalAlignment="Center"/>
<TextBlock x:Name="label2" HorizontalAlignment="Center"/>
Y a continuación el código en C#
// C#
private void TextBox1_SelectionChanged(object sender, RoutedEventArgs e)
{
textBox2.Text = textBox1.SelectedText;
label1.Text = "Selection length is " + textBox1.SelectionLength.ToString();
label2.Text = "Selection starts at " + textBox1.SelectionStart.ToString();
}
El resultado es:
17
9.2. PasswordBox
En el control PasswordBox se puede introducir una línea de texto que no será mostrada al
usuario, a menos que este así lo desee, en su lugar se mostrarán caracteres de contraseña
que representará el texto ingresado. Una de las propiedades de PasswordBox es que se
puede definir el carácter que se quiere utilizar para ocultar la contraseña, esta propiedad
es: “PasswordChar”.
A continuación se muestra un ejemplo del uso de un PasswordBox, siempre utilizando
XAML. El ejemplo concreto consiste en evaluar que la contraseña ingresada sea diferente
de la palabra “Password”.
Código en XAML
<PasswordBox x:Name="pwBox" Height="35" Width="200"
MaxLength="8" PasswordChanged="pwBox_PasswordChanged"/>
<TextBlock x:Name="statusText" Margin="10" HorizontalAlignment="Center" />
Código C#
// C#
private void pwBox_PasswordChanged(object sender, RoutedEventArgs e)
{
if (pwBox.Password == "Password")
{
statusText.Text = "'Password' is not allowed as a password.";
}
}
18
Y el resultado, será el siguiente:
El control PasswordBox tiene dos formas de mostrar la contraseña que se ha ingresado, ya
sea por medio de un botón que al tocarlo y mantenerlo presionado la mostrará y al dejar
de presionarlo la ocultará nuevamente:
O un CheckBox, que al seleccionarlo se mostrará la contraseña y al deseleccionarlo la
ocultará nuevamente:
9.3. BotonesLos botones proveen a los usuarios un camino para llevar a cabo ciertas acciones, ejecutar
ciertos comandos, tal como enviar un formulario, limpiar campos, o resetearlos, etc.
Para agregar un botón con XAML, se hace uso del siguiente código:
<Button Content="Button" Click="Button_Click"/>
19
Como se puede observar, se han establecido dos propiedades al control “Button”, las
cuales son “Content” y “Click”; la propiedad Content se refiere a la etiqueta del botón en
sí, en este caso el texto es “Button”.
Luego se escriben las líneas de código necesarias para realizar una acción con el botón
recién creado, en este ejemplo se utilizará el siguiente código que mostrará un mensaje:
private async void Button_Click(object sender, RoutedEventArgs e)
{
Windows.UI.Popups.MessageDialog messageDialog =
new Windows.UI.Popups.MessageDialog("Gracias por presionarme!");
await messageDialog.ShowAsync();
}
9.4. RadioButtons
Los RadioButton tienen dos estados, seleccionado o deseleccionado. Dicho estado se
puede identificar con la propiedad “IsChecked”, en el caso que la opción se encuentre
seleccionada, esta propiedad tomará el valor “True”, caso contrario tomará el valor
“False”.
Algo muy importante para hacer un uso adecuado de este control, es que los RadioButton
deben agruparse a través de su propiedad “GroupName” para que puedan ser
mutuamente exclusivos, es decir que al seleccionar una de las opciones, las demás no
podrán elegirse, y al cambiar de opción, la anterior deberá deseleccionarse, de manera
que solo exista una opción activa.
En el siguiente ejemplo se muestra la creación de un conjunto de RadioButton:
<RadioButton x:Name="TopButton" Margin="5" Checked="HandleCheck"
20
GroupName="First Group" Content="RadioButton1" />
<RadioButton x:Name="MiddleButton" Margin="5" Checked="HandleCheck"
GroupName="First Group" Content="RadioButton2" />
<RadioButton x:Name=" LowerButton " Margin="5" Checked="HandleCheck"
GroupName="First Group" Content="RadioButton3" />
<TextBlock x:Name="choiceTextBlock" Margin="5" />
El resultado sería el siguiente:
Al seleccionar una de las opciones, se mostrará el texto en el TextBlock programado, para
ello se utiliza el siguiente código:
private void HandleCheck(object sender, RoutedEventArgs e)
{
RadioButton rb = sender as RadioButton;
choiceTextBlock.Text = "Has seleccionado: " + rb.Name;
9.5. CheckBox
Un CheckBox es un control que permite al usuario marcar (check) o desmarcar una opción
(uncheck). Este control posee tres estados, marcado (o chequeado), desmarcado e
indeterminado.
21
Tal como el control RadioButton, el CheckBox permite la selección de ítems de una lista, a
diferencia del primero, el CheckBox permite marcar más de una opción en un grupo de
ítems.
Para la inserción de un CheckBox, se utiliza el siguiente código:
<CheckBox x:Name="checkbox1" Content="CheckBox"
Checked="CheckBox_Checked"/>
Lo que generará el siguiente resultado:
En el código que se muestra a continuación, se demuestra el uso y el comportamiento de
los estados que puede tomar el control.
Código en XAML
En este código se insertan dos controles CheckBox y dos TextBlocks:
<!-- two state CheckBox -->
<CheckBox x:Name="cb1" Content="Two State CheckBox"
Checked="HandleCheck" Unchecked="HandleUnchecked" Margin="5" />
<TextBlock x:Name="text1" Margin="5" />
<!-- three state CheckBox -->
<CheckBox x:Name="cb2" Content="Three State CheckBox"
IsThreeState="True" Checked="HandleCheck"
Indeterminate="HandleThirdState" Unchecked="HandleUnchecked" Margin="5" />
<TextBlock x:Name="text2" Margin="5" />
22
Las propiedades del control CheckBox que se utilizan, son: “x:Name” que sirve para
establecer el nombre con que se identificará el control; “Content”, que sirve para definir el
contenido del CheckBox; “Checked”, que sirve para definir la forma de manejar el control
cuando se marque la casilla; “Unchecked”, de igual manera que Checked, sirve para definir
la forma de manejar el control cuando se desmarque la casilla; “IsThreeState”, sirve para
definir si el CheckBox evalúa en forma de árbol, es decir, si representa el estado de un
conjunto de CheckBox que dependan de él; “Indeterminate”, que sirve para definir la
forma de manejar el control cuando se encuentre en el estado “Indeterminado”
Código en C#
private void HandleCheck(object sender, RoutedEventArgs e)
{
CheckBox cb = sender as CheckBox;
if (cb.Name == "cb1")
text1.Text = "Two state CheckBox checked.";
else
text2.Text = "Three state CheckBox checked.";
}
private void HandleUnchecked(object sender, RoutedEventArgs e)
{
CheckBox cb = sender as CheckBox;
if (cb.Name == "cb1")
text1.Text = "Two state CheckBox unchecked.";
else
text2.Text = "Three state CheckBox unchecked.";
}
23
private void HandleThirdState(object sender, RoutedEventArgs e)
{
CheckBox cb = sender as CheckBox;
text2.Text = "Three state CheckBox indeterminate.";
}
El código consta de 3 funciones que sirven para identificar los estados de los controles
CheckBox y se ejecutan dependiendo de la interacción del usuario, al final cada método
establece en el TextBlock una línea de texto definiendo el estado del CheckBox.
9.6. ComboBox
El ComboBox es un control de selección que representa la unión de un textbox NO
editable y un control ListBox, o control de lista, que permite al usuario seleccionar un ítem
de dicha lista.
Para insertar un objeto tipo ComboBox, se utiliza un código similar a la inserción de los
RadioButton, una etiqueta de apertura, etiquetas para añadir los elementos de la lista y la
etiqueta de cierre. Así también cuenta con una serie de métodos para poder manipular la
funcionalidad del control.
Para insertar un ComboBox con una lista predefinida, utilizando XAML, se utiliza el
siguiente código:
<ComboBox x:Name="comboBox1" SelectionChanged="ComboBox_SelectionChanged"
Width="100">
<x:String>Item 1</x:String>
<x:String>Item 2</x:String>
<x:String>Item 3</x:String>
</ComboBox>
24
El resultado del código sería el que se presenta a continuación:
También se puede utilizar C# para la inserción de este control, tal como se muestra en el
siguiente código:
ComboBox comboBox1 = new ComboBox();
comboBox1.Items.Add("Item 1");
comboBox1.Items.Add("Item 2");
comboBox1.Items.Add("Item 3");
comboBox1.Width = 200;
comboBox1.SelectionChanged += ComboBox_SelectionChanged;
9.7. DatePickerEl DatePicker es un control que se utiliza para un seleccionar un valor de tipo fecha. El
usuario selecciona la fecha utilizando controles tipo ComboBox para el día, mes y año.
A continuación se muestra el código para insertar un control DatePicker:
<DatePicker x:Name=arrivalDatePicker Header="Arrival Date"/>
En el código anterior, se utilizan dos atributos del control; “x:Name=arrivalDatePicker”
que corresponde al nombre con que se identificará al control en sí; y se utiliza el atributo
25
<<Header=“Arrival Date” >> para establecer una etiqueta. El código generará el siguiente
resultado:
Y se comportaría de la siguiente manera:
A continuación se muestra un ejemplo del uso de un DatePicker:
<StackPanel Orientation="Horizontal" Height="60">
<DatePicker x:Name="arrivalDatePicker" Header="Arrival Date"/>
<Button Content="Submit" Click="SubmitButton_Click"
Margin="5,0,0,-2" VerticalAlignment="Bottom"/>
<TextBlock x:Name="Control1Output"/>
</StackPanel>
26
El código contiene un panel donde se crean tres objetos, uno de tipo DatePicker, otro de
tipo Button y el último de tipo TextBlock. La funcionalidad de este código será que el
usuario al seleccionar una fecha y presionar el botón se mostrará la fecha en el control
TextBlock, teniendo el cuidado de validar que la fecha sea posterior al momento de
seleccionar los valores.
private void SubmitButton_Click(object sender, RoutedEventArgs e)
{
if (VerifyDateIsFuture(arrivalDatePicker.Date) == true)
{
Control1Output.Text = string.Format("Thank you. Your arrival is set for {0}.",
arrivalDatePicker.Date.ToString("D"));
}
else
{
Control1Output.Text = "Arrival date must be later than today.";
}
}
private bool VerifyDateIsFuture(DateTimeOffset date)
{
if (date > DateTimeOffset.Now)
{
return true;
}
return false;
}
En el código C# se utilizan dos funciones, una para verificar si la fecha seleccionada es una
fecha futura al momento de seleccionar los valores, y la otra función sirve para obtener
27
los valores seleccionados, enviarlos a la función evaluadora “VerifyDateIsFuture” y
devolver el resultado en el TextBlock.
9.8. TimePickerEl control TimePicker tiene muchas similitudes en su comportamiento y forma con el
control DatePicker, ambos utilizan 3 ComboBox por defecto, los cuales a partir de las
propiedades del mismo control pueden ser modificados.
Para el caso del TimePicker, los ComboBox corresponden, el primero para seleccionar la
Hora, el segundo para seleccionar los Minutos y el tercero para la fracción horaria, es decir
AM o PM y tal como lo dice su nombre, su funcionalidad es permitir al usuario seleccionar
una hora específica.
La forma de insertar un TimePicker con XAML se define con el siguiente código:
<TimePicker x:Name="arrivalTimePicker" Header="Arrival Time"/>
El cual genera el siguiente resultado:
Tal como el DatePicker, se utilizan los atributos “X:Name” y “Header”, para establecer el
nombre del control y un encabezado, respectivamente.
El siguiente código es un ejemplo de la utilización del TimePicker, se presenta tanto el
código en XAML y el C# que realiza los procesos indicados:
XAML
<StackPanel Orientation="Horizontal" Height="60">
<TimePicker x:Name="arrivalTimePicker" Header="Arrival Time"/>
<Button Content="Submit" Click="SubmitButton_Click"
Margin="5,0,0,-2" VerticalAlignment="Bottom"/>
28
<TextBlock x:Name="Control1Output"/>
</StackPanel>
C#
private void SubmitButton_Click(object sender, RoutedEventArgs e)
{
if (VerifyTimeIsAvailable(arrivalTimePicker.Time) == true)
{
Control2Output.Text = string.Format("Thank you. Your appointment is set for {0}.",
arrivalTimePicker.Time.ToString());
}
else
{
Control2Output.Text = "Sorry, we're only open from 8AM to 5PM.";
}
}
private bool VerifyTimeIsAvailable(TimeSpan time)
{
// Set open (8AM) and close (5PM) times.
TimeSpan openTime = new TimeSpan(8, 0, 0);
TimeSpan closeTime = new TimeSpan(17, 0, 0);
if (time >= openTime && time < closeTime)
{
return true; // Open
}
return false; // Closed
}
29
10. Conclusión
Se avecina una nueva tendencia de desarrollo de software orientado hacia los dispositivos
móviles. Es importante incentivar como futuros desarrolladores a conocer la nueva
plataforma móvil de Microsoft por medio de un diversos materiales que se pueden
encontrar en la web, respaldado con una base teórica sólida, para que tengan una
alternativa de recibir esta nueva tendencia y sacar provecho de ella.
Windows Phone es una plataforma móvil que actualmente se encuentra subordinada
gracias a Apple con IPhone, y Google con Android. Pero es una plataforma que seguirá en
la lucha de este negocio ya que su creador no dejará de ser el grande del software, y
mientras permanezca viva en el mercado, siempre estará disponible, con muchas
oportunidades de negocio para todo aquel interesado en adoptarla.
El enfoque del desarrollo del software comienza a evolucionar hacia nuevas plataformas,
la construcción de aplicaciones software para equipos tradicionales tiende a reducirse, y
ser superado por el auge de los dispositivos móviles.
Microsoft es una corporación muy exitosa en su campo, y el hecho de que brinde facilidad
de accesibilidad a sus plataformas de desarrollo, quiere decir que tiene a su alrededor
muchos competidores, y por eso le urge que muchos desarrolladores conozcan sus
plataformas, y para que así, crezca más y más su tienda de aplicaciones. Lo que hace de
esto, un beneficio grande para el desarrollador de software.