• Artículo

Este artículo proviene de un motor de traducción automática.

Componentes de Windows en tiempo de ejecución

Componentes de Windows en tiempo de ejecución en un mundo .NET

Jeremy Likness

Descargar el ejemplo de código

El nuevo tipo de programa conocido como una aplicación de Windows Store — optimizado para ejecutarse en dispositivos Windows 8 — tiene un valor predeterminado ve con una ventana de pantalla completa y sin cromo de distracción, por lo que el contenido es el punto focal.Apps Store de Windows admiten diseños de fluido que se adaptan y escalan a una variedad de tamaños de pantalla y resoluciones.Proporcionan una experiencia de primer toque mientras proporciona soporte completo para el tradicional teclado y el ratón.

Aplicaciones de la tienda de Windows se ejecutan en un nuevo conjunto de API que se llama el tiempo de ejecución de Windows (WinRT).El tiempo de ejecución de Windows expone componentes que se construyen como parte del sistema operativo Windows 8 junto con componentes de terceros que puede desarrollar usted mismo.Aunque algunos componentes de tiempo de ejecución de Windows de base son accesibles desde aplicaciones de escritorio, componentes de tiempo de ejecución de Windows de terceros sólo están disponibles en el entorno de Windows 8.Se describen los tipos de WinRT usando archivos de metadatos de WinRT que tienen la extensión .winmd.Estos archivos están codificados con el mismo estándar los usos de Microsoft .NET Framework para proporcionar definiciones de metadatos y semántica para clases, ECMA-335 (ver bit.ly/sLILI).

Puede desplazarse rápidamente a las definiciones de tipo en una máquina Windows 8 cambiando al directorio que contiene archivos de sistema de Windows (normalmente c:\windows\system32).Una carpeta dentro de esa dirección­tory llamado WinMetadata contiene todas las definiciones de tipo.Puede utilizar la utilidad de ILDasm.exe para explorar los tipos.Abra un símbolo Visual Studio 2012, desplácese a la carpeta c:\windows\system32\WinMetadata y escriba lo siguiente en la línea de comandos:

Ildasm.exe windows.web.winmd

Debería ver un resultado similar al figura 1. Puede utilizar la utilidad de ILDasm.exe para inspeccionar todos los espacios de nombres y tipos definidos para ese componente concreto de tiempo de ejecución de Windows.

Inspecting WinRT Types
Figura 1 inspeccionar tipos de WinRT

Es interesante notar que no hay ningún código dentro del archivo; información de metadatos sólo está disponible. El componente es parte del sistema operativo subyacente. Lo más probable es escrito usando código nativo. Una característica única llamada proyección de idioma permite que componentes de tiempo de ejecución de Windows (nativo y administrado) ser accedidos desde cualquier lenguaje que apoya el desarrollo de app Store de Windows.

Proyección y asignación

Muchos lenguajes, como C#, Visual Basic, C++ y JavaScript, se han actualizado con Windows 8 para apoyar la proyección de la lengua. Esto permite que componentes de tiempo de ejecución de Windows acceder de una forma natural utilizando varios idiomas. Proyección encarga de exponer un tipo de WinRT como un objeto o una clase que es nativo de la lengua se utiliza para desarrollar la app Store de Windows. El código siguiente obtiene acceso a un componente de tiempo de ejecución de Windows nativo directamente desde una aplicación de Windows tienda construida usando C#:

var ui = new CameraCaptureUI();

El CameraCaptureUI es un componente de tiempo de ejecución de Windows. El componente no es un tipo administrado de C#, pero pueden ser fácilmente accedido y referencia desde dentro de código C# como si se tratara. Esto es porque el CLR genera automáticamente un Runtime Callable Wrapper (RCW) para el componente de tiempo de ejecución de Windows utilizando sus metadatos y provoca que aparezca como un tipo nativo de CLR a código administrado. Para obtener más información, consulte el artículo de MSDN Library, "Runtime Callable Wrapper", en bit.ly/PTiAly. El RCW hace fácil y sencillo interactuar con estos componentes. Lo contrario también es cierto. Permite proyección que un componente de tiempo de ejecución de Windows creado con código administrado para hacer referencia a como un C++ escriba desde código nativo y como un objeto JavaScript desde proyectos HTML/JavaScript.

Tipos fundamentales aparecen automáticamente como tipos de C#. El tiempo de ejecución de Windows tiene un tipo ELEMENT_TYPE_STRING que aparece en el código .NET como un objeto de cadena. Scalar ELEMENT_TYPE_I4 aparece como un Int32. El CLR también tomar ciertos tipos de WinRT y asignarlos para aparecer en el código como sus equivalentes de .NET. Por ejemplo, el tipo de WinRT para una colección de tamaño fijo es IVector <T>, pero este tipo aparecerá automáticamente como un IList <T> en el código. net. Un HRESULT WinRT aparece en .NET Framework como un tipo de excepción. El CLR automáticamente reunirá estos tipos entre las representaciones nativos y administrados. Algunos tipos, como arroyos, se pueden convertir explícitamente mediante un conjunto de métodos de extensión proporcionada por el CLR. Para una lista completa de tipos que se asignan de esta manera, consulte el tema del centro de desarrollo de MSDN, "Tipos de .NET Framework asignaciones de WinRT," en bit.ly/PECJ1W.

Estas características integradas permiten a los desarrolladores crear sus propios componentes de tiempo de ejecución de Windows utilizando código administrado con C# y Visual Basic. 2012 De Visual Studio proporciona una plantilla para crear componentes de tiempo de ejecución de Windows desde Visual Basic, C# y C++. Estos componentes pueden ser consumidos y llama desde cualquier otro lenguaje que admite el tiempo de ejecución de Windows, incluyendo JavaScript. Por esta razón, debe seguir algunas reglas específicas para crear un componente de tiempo de ejecución de Windows en C#.

Jugar según las reglas

En general, las reglas para la creación de tipos de WinRT en C# se refieren a cualquier tipos públicamente visibles y miembros de que su componente proporciona. Las restricciones existen porque el componente de tiempo de ejecución de Windows debe regirse por el sistema de tipo de WinRT. El conjunto completo de reglas aparece en el tema del centro de desarrollo de MSDN, "crear Windows Runtime componentes en C# y Visual Basic," a bit.ly/OWDe2A. Los campos, los parámetros y valores devueltos que usted exponga todos deben ser del tipo WinRT (esta bien exponer tipos de .NET que se asignan automáticamente a los tipos de WinRT). Puede crear sus propios tipos de WinRT para exponer proporciona los tipos, a su vez, siga el mismo conjunto de reglas.

Otra restricción es que no pueden ser genérico o implementar cualquier interfaz no WinRT clases públicas o interfaces que exponga. No debe derivar de tipos no WinRT. El espacio de nombres raíz para componentes de tiempo de ejecución de Windows debe coincidir con el nombre de la Asamblea, que a su vez no puede comenzar con "Windows". Estructuras públicas también están restringidas a sólo tienen campos públicos que son tipos de valor. Polimorfismo no está disponible para los tipos de WinRT, y el más cercano usted puede venir está implementando interfaces de WinRT; se deben declarar como sellado las clases que se exponen públicamente por su componente de tiempo de ejecución de Windows.

Estas restricciones podrían ser razón para considerar un enfoque alternativo a la integración de componentes dentro de sus aplicaciones, especialmente si usted está tratando con código heredado que requeriría refactorización significativa. Más adelante analizaremos posibles enfoques alternativos. Las restricciones son importantes para asegurar los componentes de tiempo de ejecución de Windows puede funcionar adecuadamente dentro del entorno de WinRT, por lo que puede hace referencia y llamados de todos los entornos de lenguaje, incluyendo C++ y JavaScript.

El generador de miniatura

Una aplicación simple demostrará cómo crear un componente de tiempo de ejecución de Windows administrado con C# y consumirlo desde una aplicación de Windows tienda construida con C#, JavaScript o C++. El componente acepta una referencia a un archivo de imagen que pasa por la interfaz de WinRT IStorageFile. Entonces crea una miniatura de 100 x 100 píxeles de la imagen y lo guarda en el almacenamiento local de la app Store de Windows. Finalmente devuelve un identificador URI que apunta a la miniatura. Los pasos incluyen:

  1. Crear la solución en Visual Studio 2012.
  2. Crear el componente de tiempo de ejecución de Windows.
  3. Crear el proyecto específico del lenguaje C#, JavaScript o C++.
  4. Hacer referencia al componente de tiempo de ejecución de Windows.
  5. Configurar la interfaz de usuario para cada proyecto para permitir al usuario seleccionar una imagen.
  6. Mostrar la imagen.
  7. Llamar al componente de tiempo de ejecución de Windows.
  8. Mostrar la miniatura.

Crear el proyecto y la solución

Desde dentro, Visual Studio 2012 empezar especificando su idioma de preferencia (en este caso, C#) y elegir las plantillas de app Store de Windows. Una plantilla existe específicamente para generar componentes de tiempo de ejecución de Windows. He seleccionado esta plantilla y creado un componente denominado ThumbnailLibrary con una solución del mismo nombre, como se muestra en figura 2.

Creating the Windows Runtime Component Project
Figura 2 crear el proyecto del componente de tiempo de ejecución de Windows

Para este ejemplo, he creado una clase simple denominada ThumbnailMaker. Un método privado devuelve una tarea para generar asincrónicamente la miniatura:

private static async Task<Uri> GenerateThumbnail(IStorageFile file)
{
}

El primer paso dentro del método es abrir el archivo de almacenamiento de información y utilizar la WinRT BitmapDecoder para decodificar la secuencia de la imagen:

using (var fileStream = await file.OpenReadAsync())
{
  var decoder = await BitmapDecoder.CreateAsync(fileStream);
}

A continuación, se crea un archivo en el almacenamiento local de la aplicación mantener la vista en miniatura. Su nombre "miniatura", con la misma extensión que el archivo de origen. La opción para generar un nombre único se asegurará de que se pueden generar varias miniaturas sin sobrescribir operaciones anteriores:

var thumbFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(
  string.Format("thumbnail{0}", file.FileType),
  CreationCollisionOption.GenerateUniqueName);

Un codificador es creado a partir de la secuencia descodificada. Simplemente escalas de mapa de bits a 100 x 100 píxeles y luego la escribe en el sistema de archivos:

using (var outputStream =
  await thumbFile.OpenAsync(FileAccessMode.ReadWrite))
{
  var encoder = await BitmapEncoder.CreateForTranscodingAsync(
    outputStream,
    decoder);
  encoder.BitmapTransform.ScaledHeight = 100;
  encoder.BitmapTransform.ScaledWidth = 100;
  await encoder.FlushAsync();
}

El último paso es construir una dirección URL que señala al archivo.El prefijo especial ms-appdata se utiliza para hacer referencia a los archivos de almacenamiento local.Para aprender más acerca de cómo contenido de referencia mediante URIs, lea el tema del centro de desarrollo de MSDN, "Cómo a contenido de referencia," a bit.ly/SS711o.Aunque el tema es para HTML y JavaScript, la Convención que se utiliza para acceder a los recursos es el mismo independientemente de qué opción de idioma que esté utilizando:

const string URI_LOCAL = "ms-appdata:///Local/{0}";
var storageUrl = string.Format(URI_LOCAL, thumbFile.Name);
return new Uri(storageUrl, UriKind.Absolute);

Componentes de tiempo de ejecución de Windows escrito en C# se puede utilizar cualquier funcionalidad de .NET que se permite para el perfil de app Store de Windows. Como se mencionó anteriormente, sin embargo, interfaces y tipos públicos sólo deben exponer tipos de WinRT. Porque la tarea no es un tipo de WinRT válido, el método público para el componente debe exponer la WinRT IAsyncOperation <T> Escriba en su lugar. Afortunadamente, existe un método de extensión para convertir fácilmente el tipo de tarea de .NET en el tipo de WinRT IAsyncOperation, como se muestra aquí:

public IAsyncOperation<Uri> GenerateThumbnailAsync(IStorageFile file)
{
  return GenerateThumbnail(file).AsAsyncOperation();            
}

Con el componente ahora completa, se puede compilar para hacerla listo para el consumo de aplicaciones de la tienda de Windows.

Debajo del capó: Metadatos

Crear el componente de tiempo de ejecución de Windows y desplácese hasta el directorio de resultados haciendo clic en el nombre del proyecto en el explorador de soluciones y elegir "Abrir la carpeta en el explorador de Windows." Cuando vaya al subdirectorio bin/Debug, encontrará que un archivo de metadatos se ha generado para el componente llamado ThumbnailLibary.winmd.Si abre el archivo con ILDasm.exe, verá que se ha generado una interfaz para el componente con un tipo de valor devuelto:

Windows.Foundation.IAsyncOperation <Windows.Foundation.Uri>

Son los tipos de WinRT que se han asignado para el componente. Es posible también inspeccionar los metadatos y ver cómo el CLR proyectos tipos WinRT. Abrir el mismo archivo de metadatos con la extensión/Project especial como este:

Ildasm.exe/Project ThumbnailLibrary.winmd

El tipo de retorno aparece ahora como:

Windows.Foundation.IAsyncOperation <System.Uri>

Observe que la versión WinRT del identificador URI se proyecta en el equivalente. net. La firma del método expone todo tipo de WinRT válido para aplicaciones de Windows tienda a consumir, pero desde el código administrado los tipos aparecerán como clases de .NET. Puede utilizar la extensión/Project para inspeccionar cómo afectará a la firma de componentes de tiempo de ejecución de Windows administrado y proyección.

Consumir desde C#

Consumir el componente desde C# debe parecer familiar porque es no diferente de la que hace referencia a una biblioteca de clases. Tenga en cuenta que no hay ninguna razón para construir un componente de tiempo de ejecución de Windows si su único objetivo es otro código administrado. Usted simplemente referencia el proyecto de WinRT y luego consume las clases como lo haría de una biblioteca de clases de C# ordinario. En el código de ejemplo, el proyecto CSharpThumbnails tiene una referencia a la ThumbnailLibrary. El XAML para la página principal define un botón que el usuario elija una fotografía y contiene dos imágenes para alojar la imagen original y la versión en miniatura. Figura 3 muestra el marcado XAML básico.

Figura 3 XAML para App Store de Windows construida C#

<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
  <Grid.RowDefinitions>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="Auto"/>
  </Grid.RowDefinitions>
  <TextBlock
    Text="Tap the button below to choose an image to generate a thumbnail."
    Style="{StaticResource BodyTextStyle}"
    Margin="12"/>
  <Button Content="Pick Image" Grid.Row="1" Margin="12"
    Click="Button_Click_1"/>
  <TextBlock Text="Thumbnail:" Style="{StaticResource BodyTextStyle}"
    Grid.Row="2" Margin="12"/>
  <Image x:Name="ThumbnailImage" HorizontalAlignment="Left" Stretch="None"
    Grid.Row="3" Margin="12"/>
  <TextBlock Text="Source Image:" Style="{StaticResource BodyTextStyle}"
    Grid.Row="4" Margin="12"/>
  <Image x:Name="SourceImage" HorizontalAlignment="Left" Stretch="None"
    Grid.Row="5" Margin="12"/>
</Grid>

El codebehind crea una instancia del componente WinRT FileOpenPicker y lo configura para buscar imágenes:

var openPicker = new FileOpenPicker
{
  ViewMode = PickerViewMode.Thumbnail,
    SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");

El selector se llama y se muestra un cuadro de diálogo simple si no hay archivos válidos se encuentran:

var file = await openPicker.PickSingleFileAsync();
if (file == null)
{
  var dialog = new MessageDialog("No image was selected.");
  await dialog.ShowAsync();
  return;
}

La imagen de origen, a continuación, está cableada para exhibición. El archivo se pasa para el componente de tiempo de ejecución de Windows para generar una imagen en miniatura y el identificador URI pasado atrás se usa para fijar la imagen en miniatura para la exhibición:

 

using (var fileStream = await file.OpenReadAsync())
{
  SourceImage.Source = LoadBitmap(fileStream);
  var maker = new ThumbnailMaker();
  var stream = RandomAccessStreamReference
    .CreateFromUri(await maker.GenerateThumbnailAsync(file));
  var bitmapImage = new BitmapImage();
  bitmapImage.SetSource(await stream.OpenReadAsync());
  ThumbnailImage.Source = bitmapImage;
}

Figura 4 muestra el resultado de ejecutar esto contra una foto que tomé de una calabaza tallada.

Windows Store Thumbnail App Built Using C#
Figura 4 App Store de Windows Vista en miniatura construido usando C#

Consumir desde JavaScript

A diferencia de la regulares C# bibliotecas de clases, componentes de tiempo de ejecución de Windows pueden llamarse desde cualquier lenguaje compatible para crear aplicaciones de Windows Store (principales componentes de tiempo de ejecución de Windows que son parte del sistema operativo se puede llamar desde aplicaciones de escritorio). Para verlo en acción, puede crear la aplicación en miniatura usando HTML y JavaScript. Este proyecto se llama JavaScriptThumbnails en la descarga de código de muestra que lo acompaña. El primer paso es crear una aplicación vacía utilizando la plantilla en blanco de la tienda de Windows para aplicaciones construidas usando JavaScript. Una vez que se ha creado la plantilla, puede utilizar formato HTML simple para definir la página utilizando el archivo default.html existente:

    <p>Tap the button below to choose an image to generate a thumbnail.</p>
    <button id="pick">Pick Image</button>
    <br/><br/>
    <p>Thumbnail:</p>
    <img id="thumbnail" src="images/logo.png" alt="Thumbnail"/>
    <p>Source Image:</p>
    <img id="sourceImage" src="images/logo.png" alt="Image"/>

A continuación, agregue una referencia al proyecto WinRT (ThumbnailLibrary) como lo haría para un regular proyecto C#. Construir el proyecto para que pueda utilizar IntelliSense para el componente de referenciado recientemente. Puede hacer referencia el código fuente del proyecto ver el código JavaScript equivalente para abrir el selector de archivos y seleccionar la imagen. Para crear una instancia del componente de tiempo de ejecución de Windows administrado, generar la miniatura y mostrar al usuario, utilice el siguiente código JavaScript:

var thumb = new ThumbnailLibrary.ThumbnailMaker();
thumb.generateThumbnailAsync(file).then(function (fileUrl) {
  var thumbImage = document.getElementById("thumbnail");
  thumbImage.src = fileUrl.rawUri;
  thumbImage.alt = thumbImage.src;
});

Como puede ver, la llamada API es casi idéntica a la utilizada en el proyecto de C#. Proyección cambia automáticamente la firma del método de caso de Pascal al caso camello (el llamado a generar la miniatura comienza con un carácter en minúscula, como es la Convención común en el código JavaScript), y una biblioteca especial llamada "promesas" se utiliza para controlar la naturaleza asíncrona del código utilizando una declaración luego o hecha. Usted puede aprender más sobre promesas por leer el tema del centro de desarrollo de MSDN, "Quickstart: Con promesas,"en bit.ly/OeWQCQ. La etiqueta de imagen admite URL fuera de la caja, por lo que la URL pasada hacia atrás desde el componente de tiempo de ejecución de Windows simplemente se establece directamente en el atributo src de la imagen.

Una advertencia importante para el uso de componentes administrados en el código JavaScript es que no puede depurar JavaScript y código administrado al mismo tiempo. Si usted necesita depurar su componente, debe haga el proyecto y elija la ficha de depuración y, a continuación, seleccione una opción de depuración que incluye código administrado. Esto se muestra en la figura 5.

Setting the Debug Options for a JavaScript Project
Figura 5 Configuración de las opciones de depuración para un proyecto de JavaScript

Consumir de C++

También puede utilizar componentes de tiempo de ejecución de Windows administrados de proyectos nativos. C++ comparte el mismo motor de renderizado como C#, por lo que el proyecto de CPlusPlusThumbnails tiene el mismo XAML como el proyecto CSharpThumbnails. El codebehind es diferente porque el proyecto utiliza la opción de lenguaje C++ nativa. C++ utiliza una biblioteca de concurrencia especial para manejar las operaciones asincrónicas. Usted puede aprender más sobre esta biblioteca leyendo el tema del centro de desarrollo de MSDN, "Asincrónica de programación en C++," a bit.ly/MUEqnR. El código resultante es similar a las promesas que usted vio en las versiones de JavaScript:

ThumbnailMaker^ maker = ref new ThumbnailMaker();
create_task(maker->GenerateThumbnailAsync(file)).then([this](Uri^ uri)
{
  RandomAccessStreamReference^ thumbnailStream =
    RandomAccessStreamReference::CreateFromUri(uri);
  create_task(thumbnailStream->OpenReadAsync()).then([this](
    IRandomAccessStream^ imageStream) {
    auto image = ref new BitmapImage();
    image->SetSource((IRandomAccessStream^)imageStream);
    ThumbnailImage->Source = image;
  });
});

Cuando se ejecuta la aplicación, usted encontrará parece y se comporta de forma idéntica a la versión de C#.

Entender el costo

Crear componentes de tiempo de ejecución de Windows utilizando lenguajes administrados es una característica de gran alcance. Sin embargo, esta característica tienen un coste, y es importante comprender el costo cuando estés usando en proyectos. Windows Store apps construidos utilizando código nativo no requieren el CLR ejecutar. Estas aplicaciones pueden ejecutarse directamente en el entorno de Windows 8. Asimismo, aplicaciones desarrolladas mediante JavaScript también no requieren una dependencia en el CLR. Se basan en el motor de renderizado Trident y motor JavaScript Chakra (los mismos motores que impulsan Internet Explorer 10) procesar HTML y CSS e interpretar el código JavaScript. Almacén de Windows aplicaciones construidas con JavaScript pueden llamar a componentes de tiempo de ejecución de Windows nativos directamente, pero cuando llaman componentes administrados de tiempo de ejecución de Windows, tienen una dependencia al CLR.

El código escrito para el componente de tiempo de ejecución de Windows administrado será compilado just-in-time (JIT) cuando se accede primero por el compilador JIT del CLR. Esto podría provocar algún retraso el primero que se accede. Un servicio de precompilación denominado controles NGen compilar módulos instalados en el dispositivo, pero puede tardar hasta un día completo eventualmente compilar todos los módulos en un paquete de una vez se ha instalado. El CLR también administra la memoria al realizar la recolección de basura. El recolector (GC) el montón se divide en tres generaciones y recoge sólo partes de la pila utilizando un algoritmo diseñado para optimizar el rendimiento.

El GC puede pausar su aplicación mientras realiza trabajo. Esto a menudo sólo introduce un retardo leve que no es reconocible para el usuario final, y más intensas operaciones de recolección de basura a menudo pueden ejecutar en segundo plano. Si tienes un montón bastante grande (cuando la parte administrada del código hace referencia a cientos de megabytes o más en objetos de memoria), recolección de basura podría pausar la aplicación lo suficientemente larga como para el usuario a percibir la falta de capacidad de respuesta.

La mayoría de estas consideraciones ya está en su lugar cuando usted está construyendo una app Store de Windows administrado. Código administrado agregar nuevas preocupaciones cuando usted está añadiendo a un app Store de Windows construida C++ o JavaScript. Es importante reconocer que su aplicación consume CPU adicional y administrado de memoria cuando se introducen componentes. También puede tomar un hit de rendimiento reconocible, dependiendo del componente (aunque muchas aplicaciones toman referencias administrado sin ningún impacto perceptible). El beneficio es que usted no tiene que preocuparse acerca de la administración de memoria usted mismo y, por supuesto, usted puede aprovechar habilidades y código heredado.

Alternativas para proyectos administrados

Si vas a compilar aplicaciones de almacén de Windows utilizando código administrado (C# o Visual Basic), tiene varias alternativas para crear componentes de tiempo de ejecución de Windows que no tienen las mismas restricciones. Usted puede crear fácilmente componentes reutilizables, mediante una simple biblioteca de clases de C#. Si la biblioteca de clases está construida para aplicaciones de almacenamiento de Windows, puede hacer referencia el proyecto desde su propia app Store de Windows. La creación de una biblioteca de clases también elimina las limitaciones de tener que exponer sólo los tipos de WinRT y no poder utilizar funciones que no forman parte del sistema de tipo de WinRT, como los medicamentos genéricos.

Otra alternativa a considerar es la biblioteca de clase Portable (PCL). Se trata de un tipo especial de biblioteca de clases que se puede hacer referencia de una variedad de plataformas sin volver a compilar. Utilice esta opción si usted han code que deseen compartir entre otras plataformas, como Windows Presentation Foundation, Silverlight y Windows Phone — y su app Store de Windows. Usted puede aprender más sobre el LCP leyendo mi serie de blog de tres partes, "Entendimiento el portátil biblioteca por persiguiendo ICommand," en bit.ly/pclasslib.

Cuando el componente incluye algo más que código, considere crear un SDK de extensión. Se trata de una forma especial de SDK de Visual Studio 2012 puede tratar como un solo elemento. El paquete puede incluir código fuente, activos y archivos binarios incluso, incluyendo componentes de tiempo de ejecución de Windows. También puede crear extensiones de tiempo de diseño para hacerlo más fácil consumir y utilizar su componente desde dentro de Visual Studio 2012. SDK de extensión no se pueden contabilizar a la tienda de Windows porque no son autónomos apps. Usted puede aprender más sobre el SDK de extensión por leer el artículo de MSDN Library, "Cómo: Crear un Kit de desarrollo de Software,"a bit.ly/L9Ognt.

Cuándo se debe crear componentes de tiempo de ejecución de Windows administrado

Con tantas posibilidades, ¿nunca tiene sentido para crear componentes de tiempo de ejecución de Windows utilizando código administrado? Sí, pero tenga en cuenta las siguientes preguntas. La primera pregunta es si usted necesita los componentes a ser referencia desde el almacén de Windows aplicaciones escritas usando JavaScript o código nativo en C++. Si esto no es el caso, no hay ninguna razón para utilizar un componente de tiempo de ejecución de Windows cuando las bibliotecas de clases y otras opciones trabajarán en su lugar. Si este es el caso, deberá crear un componente de tiempo de ejecución de Windows para consumo de todas las opciones de idioma disponibles.

La siguiente pregunta es si debe crear su componente en C++ o utilizar código administrado. Hay un número de razones para utilizar código administrado. Una razón podría ser que su equipo tiene más experiencia en C# o Visual Basic que en C++ y puede aprovechar las habilidades existentes para construir los componentes. Otra razón podría ser que los algoritmos existentes escritos en un lenguaje administrado que será más fácil al puerto si mantiene la misma selección de idioma. Existen algunas tareas que podrían ser más fáciles de escribir y mantener utilizando lenguajes administrados y las bibliotecas de clases en lugar de utilizar código nativo, y equipos que se utilizan para desarrollar en lenguajes administrados será mucho más productivos.

Terminando, en este artículo que has aprendido que puede crear componentes reutilizables del tiempo de ejecución de Windows usando logró C# y código de Visual Basic. Estos componentes pueden ser fácilmente referenciados y consumidos desde el almacén de Windows aplicaciones escritas en cualquier lenguaje, incluyendo JavaScript y C++. Si bien es importante entender las reglas para la creación de componentes de tiempo de ejecución de Windows y el impacto de la elección de utilizar código administrado, esta opción proporciona una oportunidad única para utilizar el idioma de su elección y aprovechar el código existente para crear componentes que pueden ser consumidos por todas las aplicaciones de la tienda de Windows.

Jeremy Likness  *es consultor principal de Wintellect LLC en Atlanta. Es un tres años Microsoft Silverlight MVP y autor de varios libros, incluyendo la próxima "edificio Windows 8 aplicaciones con C# y XAML" (Addison-Wesley Professional, 2012). Aprenda más en línea en bit.ly/win8design y siga su blog en csharperimage.jeremylikness.com.   *

Gracias a los siguientes expertos técnicos por su ayuda en la revisión de este artículo: Layla Driscoll, Shawn Farkas, John Garland, Jeff Prosise y Jeffrey Richter