Cet article a fait l'objet d'une traduction automatique.
Interplateforme
Partagez du code d'interface utilisateur sur les plateformes mobiles grâce à Xamarin.Forms
Avec Novell, vous pouvez utiliser c# pour construire de belles applications mobiles natives et partagent l'essentiel de votre code entre les plates-formes. Traditionnellement, vous deviez concevoir une interface d'utilisateur séparé pour chaque plateforme ciblée. Mais avec Xamarin.Forms, vous pouvez créer une interface utilisateur qui rend nativement sur l'ensemble d'entre eux.
Xamarin.Forms est une couche d'abstraction de l'interface utilisateur multi-plateformes. Vous pouvez l'utiliser pour partager des UI et dorsaux code entre plates-formes et pourtant toujours livrer une expérience de l'interface utilisateur entièrement native. Parce qu'ils sont autochtones, vos contrôles et les widgets ont l'apparence de chaque plate-forme cible.
Xamarin.Forms est entièrement compatible avec le modèle de conception Model-View-ViewModel (MVVM) donc vous pouvez lier des éléments de la page de propriétés et les commandes dans une classe de modèle d'affichage.
Si vous préférez concevoir vos pages de manière déclarative, vous pouvez utiliser XAML, un langage de balisage avec des fonctionnalités telles que des dictionnaires de ressources, les ressources dynamiques, liaison de données, commandes, les déclencheurs et les comportements.
Xamarin.Forms a une API petit, facile à utiliser. Si vous avez besoin de plus accès à l'interface native d'une plate-forme, vous pouvez créer des affichages personnalisés et convertisseurs spécifiques à la plateforme. Cela paraît compliqué, mais c'est vraiment juste une manière d'obtenir à l'ISU natif, et il ya beaucoup d'exemples sur le site Web de Novell pour vous aider à le faire.
Vous pouvez commencer en utilisant les pages prêt à l'emploi, mises en page et les vues qui viennent avec Xamarin.Forms. Pendant que votre application mûrit et vous découvrez de nouveaux cas d'utilisation et possibilités de conception, vous pourriez venir s'appuyer sur Xamarin.Forms en charge XAML, MVVM, moteurs de rendu personnalisés spécifique à la plateforme et une variété d'autres fonctionnalités telles que les modèles de données et les animations.
Je vais donner un aperçu de la fonctionnalité de Novell avec des exemples concrets pour illustrer comment partager la majeure partie de votre code d'interface utilisateur entre les plates-formes cibles différentes et incorporer du code spécifique à la plateforme lorsque nécessaire.
Mise en route
Tout d'abord, ouvrez le gestionnaire de package NuGet dans Visual Studio ou Studio de Novell et vérifier avec les nouvelles versions de Xamarin.Forms. Parce que vous ne sera pas être informé des nouveautés juste en ouvrant une solution Xamarin.Forms dans l'IDE, recherchant les paquets mis à jour de NuGet est la seule façon de vous assurer de qu'obtenir les dernières améliorations.
Créer une Solution de Xamarin.Forms lorsque vous ne savez pas vous avez la dernière version de Xamarin.Forms, créer une solution vide App (Xamarin.Forms Portable).
Votre solution a trois projets spécifiques à la plateforme et une bibliothèque Portable des classe (PCL). Concevez vos pages dans le PCL. Commencez par créer une page de connexion de base.
Utiliser c# pour créer une Page ajouter une classe à votre projet PCL. Puis ajoutez des contrôles (appelés « vues » dans Novell), comme indiqué dans Figure 1.
Figure 1 Ajout de vues (contrôles)
public class LogInPage : ContentPage
{
public LogInPage()
{
Entry userEntry = new Entry { Placeholder = "Username" };
Entry passEntry =
new Entry { Placeholder = "Password", IsPassword = true };
Button submit = new Button { };
Content = new StackLayout
{
Padding = 20,
VerticalOptions = LayoutOptions.Center,
Children = { userEntry, passEntry, submit }
};
}
}
Pour afficher la page au démarrage d'une application, ouvrez la classe MyApp et assignez une instance de celui-ci à la propriété MainPage :
public class MyApp : Application
{
public MyApp()
{
MainPage = new LogInPage();
}
}
Il s'agit d'un bon moment pour discuter de la classe Application. À partir de v1.3.0, toutes les apps Xamarin.Forms contiendra cette classe. C'est le point d'entrée d'une application Xamarin.Forms et, entre autres choses, il fournit des événements de cycle de vie, mais aussi un magasin de données persistantes (le dictionnaire de propriétés) pour toute donnée sérialisable. Si vous devez obtenir une instance de cette classe de n'importe où dans votre application, vous pouvez utiliser la propriété Application.Current.
Dans l'exemple précédent, j'ai enlevé le code par défaut à l'intérieur de la classe application et remplacée par une seule ligne de code qui rend le cas apparaissent lorsque vous exécutez l'application. Elle apparaît lorsque l'application s'exécute, car ce code attribue une page (le login) à la propriété actuelle de la classe Application. Vous devrez fixer dans le constructeur de la classe Application.
Vous pouvez également substituer les trois méthodes de cette classe :
- La méthode OnStart, qui est appelée lorsqu'une application est tout d'abord démarrée.
- La méthode OnSleep, qui est appelée lorsque l'application est sur le point d'entrer dans un état de fond.
- La méthode OnResume, qui est appelée lorsqu'une application retourne à partir d'un état de fond.
En général, pages ne sont pas très intéressants jusqu'à ce que vous connecter avec une sorte de données ou de comportement, donc je vais montrer comment faire cela.
Lier une Page aux données si vous utilisez le modèle de conception MVVM, vous pouvez créer une classe comme celle de Figure 2 qui implémente l'interface INotifyPropertyChanged.
Figure 2 implémentation de l'Interface INotifyPropertyChanged
public class LoginViewModel : INotifyPropertyChanged
{
private string usrnmTxt;
private string passWrd;
public string UsernameText
{
get { return usrnmTxt; }
set
{
if (usrnmTxt == value)
return;
usrnmTxt = value;
OnPropertyChanged("UsernameText");
}
}
public string PassWordText
{
get { return passWrd; }
set
{
if (passWrd == value)
return;
passWrd = value;
OnPropertyChanged("PassWrd");
}
}
public event PropertyChangedEventHandler PropertyChanged;
private void OnPropertyChanged(string propertyName)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
}
Vous pouvez lier les vues de votre page de connexion pour les propriétés de cette classe, comme le montre Figure 3.
Figure 3 liaison vues aux propriétés de la classe
public LogInPage()
{
Entry userEntry = new Entry { Placeholder = "Username" };
userEntry.SetBinding(Entry.TextProperty, "UsernameText");
Entry passEntry =
new Entry { Placeholder = "Password", IsPassword = true };
passEntry.SetBinding(Entry.TextProperty, "PasswordText");
Button submit = new Button { Text = "Submit" };
Content = new StackLayout
{
Padding = 20,
VerticalOptions = LayoutOptions.Center,
Children = { userEntry, passEntry, submit }
};
BindingContext = new LoginViewModel();
}
Pour lire davantage sur la façon de lier aux données dans votre application de Xamarin.Forms, voir « De données liaisons à MVVM » sur le site de Novell à bit.ly/1uMoIUX.
Utiliser XAML pour créer une Page pour les plus petites applications, créer vos interfaces utilisateur à l'aide de c# est une approche tout à fait raisonnable. Toutefois, comme la taille de votre application se développe, vous pourriez trouver vous-même tapant beaucoup de code répétitif. Vous pouvez éviter ce problème en utilisant XAML au lieu de code c#.
Ajoutez un élément de la Page XAML de formes à votre projet PCL. Puis ajoutez balisage de la page, comme indiqué dans Figure 4.
La figure 4 en ajoutant la balise dans une Page XAML de formes
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="https://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Jason3.LogInPage"
xmlns:local="clr-namespace:XamarinForms;assembly=XamarinForms">
<StackLayout VerticalOptions="Center">
<StackLayout.BindingContext>
<local:LoginViewModel />
</StackLayout.BindingContext>
<Entry Text="{Binding UsernameText}" Placeholder="Username" />
<Entry Text="{Binding PasswordText}"
Placeholder="Password" IsPassword="true" />
<Button Text="Login" Command="{Binding LoginCommand}" />
</StackLayout>
</ContentPage>
Le code XAML dans Figure 4 pourrait paraître familier si vous avez écrit apps Windows Presentation Foundation (WPF). Cependant, les balises sont différentes car elles font référence à des types de Xamarin.Forms. En outre, l'élément racine fait référence à une sous-classe de la classe Xamarin.Forms.Element. Tous les fichiers XAML dans une app Xamarin.Forms doivent pour ce faire.
Pour en savoir plus sur l'utilisation de XAML pour créer des pages dans une application de Xamarin.Forms, voir « XAML pour Xamarin.Forms » sur le site Web de Novell à bit.ly/1xAKvRN.
Conception d'une plate-forme spécifique
Xamarin.Forms a un nombre relativement restreint d'API par rapport aux autres plateformes mobiles natives. Cela le rend plus facile pour vous aider à concevoir vos pages, mais parfois Xamarin.Forms n'affichent une vue exactement comme vous le souhaitez à sur un ou plusieurs de vos objectifs de la plate-forme.
Si vous exécutez contre cette barrière, il suffit de créer un affichage personnalisé, ce qui est juste une sous-classe de n'importe quel affichage disponible dans Xamarin.Forms.
Pour agrandir l'affichage sur une page, étendre le rendu de la vue. Dans les cas plus avancés, vous pouvez même créer un convertisseur personnalisé à partir de zéro. Code de convertisseur personnalisé est spécifique à une plate-forme, donc vous ne pouvez pas le partager. Mais cette approche pourrait être vaut le coût, afin d'introduire des fonctionnalités natives et facilité d'utilisation de l'app.
Créer une vue personnalisée tout d'abord, créez une sous-classe de n'importe quel affichage disponible dans Xamarin.Forms. Voici le code pour deux affichages personnalisés :
public class MyEntry : Entry {}
public class RoundedBoxView : BoxView {}
Étendre un moteur de rendu existantsFigure 5 s'étend le rendu qui restitue la vue de l'entrée pour la plateforme iOS. Vous placerez cette classe dans le projet de plateforme iOS. Ce convertisseur définit la couleur et le style du champ texte natif sous-jacent.
La figure 5, qui s'étend d'un moteur de rendu existant
[assembly: ExportRenderer (typeof (MyEntry), typeof (MyEntryRenderer))]
namespace CustomRenderer.iOS
{
public class MyEntryRenderer : EntryRenderer
{
protected override void OnElementChanged
(ElementChangedEventArgs<Entry> e)
{
base.OnElementChanged (e);
if (e.OldElement == null) {
var nativeTextField = (UITextField)Control;
nativeTextField.BackgroundColor = UIColor.Gray;
nativeTextField.BorderStyle = UITextBorderStyle.Line;
}
}
}
}
Vous pouvez faire à peu près ce que vous voulez dans votre moteur de rendu, car que vous référencez des API natives. Si vous souhaitez afficher l'échantillon qui contient cet extrait de code, voir « Xamarin.Forms Custom Renderer » à bit.ly/1xTIjmR.
Créer un moteur de rendu de vous pouvez créer un convertisseur flambant neuf qui ne s'étend pas n'importe quel autres moteurs de rendu. Vous ferez un peu plus de travail, mais il est logique d'en créer un si vous voulez faire ces choses :
- Remplacer le moteur de rendu d'une vue.
- Ajouter un nouveau type d'affichage à votre solution.
- Ajoutez un contrôle natif ou page natif à votre solution.
Par exemple, si vous souhaitez ajouter un contrôle natif de UIView vers une page dans la version iOS de votre application, vous pouvez ajouter un convertisseur personnalisé à votre projet iOS, comme indiqué dans Figure 6.
La figure 6, ajout d'un contrôle de UIView natif à une application avec un moteur de rendu de Custom iOS
[assembly: ExportRendererAttribute(typeof(RoundedBoxView),
typeof(RoundedBoxViewRenderer))]
namespace RBVRenderer.iOS
{
public class RoundedBoxViewRenderer :
ViewRenderer<RoundedBoxView,UIView>
{
protected override void OnElementChanged(
ElementChangedEventArgs<RoundedBoxView> e)
{
base.OnElementChanged(e);
var rbvOld = e.OldElement;
if (rbvOld != null)
{
// Unhook any events from e.OldElement here.
}
var rbv = e.NewElement;
if (rbv != null)
{
var shadowView = new UIView();
// Set properties on the UIView here.
SetNativeControl(shadowView);
// Hook up any events from e.NewElement here.
}
}
}
}
Le modèle général qui apparaît dans ce convertisseur assure que vous pouvez l'utiliser dans des mises en page virtualisés tel qu'une vue de liste, que j'aborderai plus tard.
Si vous souhaitez afficher l'échantillon qui contient cet extrait de code, voir xf-bit.ly/customrenderer.
Ajouter des propriétés à un affichage personnalisé vous pouvez ajouter des propriétés à un affichage personnalisé, mais assurez-vous juste que vous leur faites bindable donc vous pouvez les lier aux propriétés dans un modèle de vue ou à d'autres types de données. Voici une propriété pouvant être liée à la vue personnalisée de RoundedBoxView :
public class RoundedBoxView : BoxView
{
public static readonly BindableProperty CornerRadiusProperty =
BindableProperty.Create<RoundedBoxView, double>(p => p.CornerRadius, 0);
public double CornerRadius
{
get { return (double)base.GetValue(CornerRadiusProperty);}
set { base.SetValue(CornerRadiusProperty, value);}
}
}
Pour vous connecter de nouvelles propriétés à votre moteur de rendu, substituez la méthode OnElementPropertyChanged du convertisseur et ajoutez le code qui s'exécute lorsque la propriété :
protected override void OnElementPropertyChanged(object sender,
System.ComponentModel.PropertyChangedEventArgs e)
{
base.OnElementPropertyChanged(sender, e);
if (e.PropertyName ==
RoundedBoxView.CornerRadiusProperty.PropertyName)
childView.Layer.CornerRadius = (float)this.Element.CornerRadius;
}
Pour en savoir plus sur la création d'affichages personnalisés et convertisseurs personnalisés, voir « Personnalisation des contrôles pour chaque plate-forme » à bit.ly/11pSFhL.
Pages, schémas et vues : Les blocs de construction de Xamarin.Forms
J'ai présenté quelques éléments, mais il y a beaucoup d'autres. Ce serait un bon moment à leur rendre visite.
Xamarin.Forms applications contiennent des pages, des mises en page et des vues. Une page contient une ou plusieurs mises en page et une mise en page contient un ou plusieurs affichages. La vue de terme est utilisée dans Novell pour décrire ce que vous pourriez être utilisé pour appeler un contrôle. Au total, le cadre de Xamarin.Forms contient cinq types de pages, sept types de disposition et les types d'affichage 24. Vous pouvez en savoir plus sur eux à xamarin.com/forms. Je vais visiter certains types de page importante plus tard, mais tout d'abord je vais prendre un moment pour examiner certains des mises en page, que vous pouvez utiliser dans votre application. Xamarin.Forms contient quatre présentations primaires :
- StackLayout : Le StackLayout positionne les éléments enfants dans une seule ligne qui peut être orientée verticalement ou horizontalement. Vous pouvez imbriquer des StackLayouts pour créer des hiérarchies visuelles complexes. Vous pouvez contrôler comment les vues sont disposés dans un StackLayout en utilisant les VerticalOptions et HorizontalOptions des propriétés de chaque vue de l'enfant.
- Grille : La grille organise les vues en lignes et colonnes. Cette disposition est similaire à celui que vous obtenez avec WPF et Silverlight sauf que vous pouvez ajouter l'espacement entre les lignes et les colonnes. Vous le faire en utilisant les propriétés RowSpacing et ColumnSpacing de la grille.
- RelativeLayout : Le RelativeLayout positionne vues à l'aide de contraintes par rapport à d'autres vues.
- DispositionAbsolue : Le DispositionAbsolue vous permet de positionner les vues de l'enfant de deux façons : à une position absolue, ou proportionnellement par rapport à la société mère. Cela peut être utile si vous envisagez de créer split et superposées de hiérarchies. La figure 7 montre un exemple.
Figure 7 utilisation de la DispositionAbsolue
void AbsoluteLayoutView()
{
var layout = new AbsoluteLayout();
var leftHalfOfLayoutChild = new BoxView { Color = Color.Red };
var centerAutomaticallySizedChild =
new BoxView { Color = Color.Green };
var absolutelyPositionedChild = new BoxView { Color = Color.Blue };
layout.Children.Add(leftHalfOfLayoutChild,
new Rectangle(0, 0, 0.5, 1),
AbsoluteLayoutFlags.All);
layout.Children.Add(centerAutomaticallySizedChild,
new Rectangle(
0.5, 0.5, AbsoluteLayout.AutoSize, AbsoluteLayout.AutoSize),
AbsoluteLayoutFlags.PositionProportional);
layout.Children.Add(
absolutelyPositionedChild, new Rectangle(10, 20, 30, 40));
}
Notez que tous les schémas vous donnent une propriété nommée enfants. Vous pouvez utiliser cette propriété pour accéder aux membres supplémentaires. Par exemple, vous pouvez utiliser la propriété Children de la présentation de la grille pour ajouter et supprimer des lignes et des colonnes, ainsi que spécifier les travées de lignes et de colonnes.
Afficher les données dans une liste déroulante
Vous pouvez afficher des données dans une liste déroulante à l'aide d'un formulaire de vue de liste (nommé ListView). Ce point de vue effectue bien parce que les moteurs de rendu pour chaque cellule de la liste sont virtualisés. Parce que chaque cellule est virtualisé, il est important que vous gérer correctement l'événement OnElementChanged de n'importe quel convertisseurs personnalisés que vous créez pour les cellules ou les listes à l'aide d'un schéma similaire à celui illustré précédemment.
Tout d'abord, définir une cellule, comme le montre Figure 8. Tous les modèles de données pour un ListView doivent utiliser une cellule comme élément racine.
Figure 8 définissant une cellule d'une ListView
public class MyCell : ViewCell
{
public MyCell()
{
var nameLabel = new Label();
nameLabel.SetBinding(Label.TextProperty, "Name");
var descLabel = new Label();
descLabel.SetBinding(Label.TextProperty, "Description");
View = new StackLayout
{
VerticalOptions = LayoutOptions.Center,
Children = { nameLabel, descLabel }
};
}
}
Ensuite, définir une source de données et définissez la propriété ItemTemplate du ListView avec un nouveau modèle de données. Le modèle de données est basé sur la classe MaCellule créée précédemment :
var items = new[] {
new { Name = "Flower", Description = "A lovely pot of flowers." },
new { Name = "Tuna", Description = "A can of tuna!" },
// ... Add more items
};
var listView = new ListView
{
ItemsSource = items,
ItemTemplate = new DataTemplate(typeof(MyCell))
};
Vous pouvez le faire en XAML en utilisant la balise suivante :
<ListView ItemsSource="{Binding Items}">
<ListView.ItemTemplate>
<ViewCell>
<StackLayout VerticalOptions="center">
<Label Text="{Binding Name}" />
<Label Text="{Binding Description}" />
</StackLayout>
</ViewCell>
</ListView.ItemTemplate>
</ListView>
Naviguer entre les Pages
Plupart des applications contiennent plus d'une page, donc vous aurez besoin pour permettre aux utilisateurs de naviguer d'une page à l'autre. Les pages suivantes ont un support intégré pour la présentation de page navigation et soutien de plein écran page modale :
- TabbedPage
- MasterDetailPage
- NavigationPage
- CarouselPage
Vous pouvez ajouter vos pages comme des enfants à l'une de ces quatre pages et obtenir la navigation gratuite.
La Page à onglets TabbedPage A montre un tableau des onglets dans le haut d'un écran. En supposant que votre projet PCL contient des pages nommées login, DirectoryPage et AboutPage, vous pouvez les ajouter à une TabbedPage en utilisant le code suivant :
var tabbedPage = new TabbedPage
{
Children =
{
new LoginPage { Title = "Login", Icon = "login.png" },
new DirectoryPage { Title = "Directory", Icon = "directory.png" },
new AboutPage { Title = "About", Icon = "about.png" }
}
};
Dans ce cas, il est important de définir la propriété titre et l'icône de chaque page pour que quelque chose s'affiche sur les onglets de la page. Pas toutes les plateformes rendent des icônes. Cela dépend de la conception d'onglet de la plate-forme.
Si vous avez ouvert cette page sur un périphérique mobile, le premier onglet apparaît sous le nom sélectionné. Toutefois, vous pouvez modifier qu'en définissant la propriété CurrentPage de la page TabbedPage.
Le NavigationPage A NavigationPage gère la navigation et UX d'une pile de pages. Cette page vous propose le type le plus commun du modèle de navigation mobile app. Voici comment vous devez ajouter vos pages à elle :
var loginPage = new LoginPage();
var navigationPage = new NavigationPage(loginPage);
loginPage.LoginSuccessful += async (o, e) => await
navigationPage.PushAsync(new DirectoryPage());
Notez l'utilisation de PushAsync comme un moyen de naviguer les utilisateurs vers une page spécifique (dans ce cas la DirectoryPage). Dans un NavigationPage, vous « poussez » les pages dans une pile et puis « pop » leur off comme utilisateurs de naviguent vers l'arrière à la page précédente.
Les méthodes PushAsync et PopAsync d'un NavigationPage sont asynchrones, afin que votre code doit les attendent et pas pousser ou pop nouvelles pages alors que la tâche s'exécute. La tâche de chaque méthode retourne après l'animation d'un push ou pop se termine.
Pour plus de commodité, toutes les vues de Xamarin.Forms, mises en page et pages contiennent une propriété de Navigation. Cette propriété est une interface de proxy qui contient les méthodes PushAsync et PopAsync d'une instance de NavigationPage. Vous pouvez utiliser cette propriété pour accéder à une page au lieu d'appeler les méthodes PushAsync et PopAsync sur l'instance de NavigationPage directement. Vous pouvez également utiliser la valeur NavigationProperty pour rejoindre les méthodes PushModalAsync et PopModalAsync. Ceci est utile si vous souhaitez remplacer le contenu de la totalité de l'écran avec une nouvelle page modale. Vous n'avez pas à avoir un NavigationPage dans la pile de parent d'un affichage à utiliser la propriété de Navigation d'une vue, mais non modal PushAsync/PopAsync opérations peuvent échouer.
Remarque à propos des Design Patterns en général, pensez à ajouter NavigationPages en tant qu'enfants à TabbedPages et TabbedPages en tant qu'enfants à MasterDetailPages. Certains types de modèles peuvent causer un UX indésirables. Par exemple, la plupart des plateformes vous déconseille ajoutant un TabbedPage comme un enfant d'un NavigationPage.
Animer les vues dans une Page
Vous créez une expérience plus engageante en animant les points de vue sur une page, qui peut être fait de deux façons. Choisissez les animations intégrées qui viennent avec Xamarin.Forms ou construire un vous-même à l'aide de l'API d'animation.
Par exemple, vous pouvez créer un effet de fondu en appelant l'animation FadeTo d'une vue. L'animation de FadeTo est intégrée à une vue est facile à utiliser :
async Task SpinAndFadeView(View view)
{
await view.FadeTo(20, length: 200, easing: Easing.CubicInOut);
}
Vous pouvez enchaîner une série d'animation en utilisant le mot-clé await. Chaque animation s'exécute lorsque l'antérieure est terminée. Par exemple, vous pouviez faire pivoter une vue juste avant vous faner dans le foyer :
async Task SpinAndFadeView(View view)
{
await view.RotateTo(180);
await view.FadeTo(20, length: 200, easing: Easing.CubicInOut);
}
Si vous avez des difficultés à atteindre l'effet souhaité, vous pouvez utiliser l'animation complète API. Dans le code suivant, la vue s'estompe à mi-chemin à travers la rotation :
void SpinAndFadeView(View view)
{
var animation = new Animation();
animation.Add(0, 1, new Animation(
d => view.Rotation = d, 0, 180, Easing.CubicInOut));
animation.Add(0.5, 1, new Animation(
d => view.Opacity = d, 1, 0, Easing.Linear));
animation.Commit(view, "FadeAndRotate", length: 250);
}
Cet exemple compose chaque animation dans une seule instance de l'Animation et puis exécute la séquence de la totalité de l'animation à l'aide de la méthode Commit. Parce que cette animation n'est pas liée à une vue spécifique, vous pouvez appliquer l'animation à l'un d'entre eux.
Jaquette en haut
Xamarin.Forms est un nouveau moyen passionnant de construire des applications mobiles natives multi-plateforme. Il permet de construire une interface utilisateur qui rend nativement sur iOS, Android et Windows Phone. Vous pouvez partager presque tout le code entre les plates-formes.
Novell Inc. bâti de Novell et Xamarin.Forms pour le rendre possible pour les développeurs c# sauter dans le développement mobile, pratiquement du jour au lendemain. Si vous avez développé pour Windows Runtime, WPF ou Silverlight, puis vous trouverez que Xamarin.Forms est un pont facile dans le monde du développement mobile natif multi-plateforme. Vous pouvez installer Novell aujourd'hui et commencer immédiatement à utiliser c# pour construire de belles applications natives qui s'exécutent sur iOS, Android et Windows Phone devices.
Jason Smith est un génie technique chez Novell Inc. dans San Francisco, actuellement en tête du projet de Xamarin.Forms. Il fut l'un des principaux architectes de Xamarin.Forms, avant laquelle il a contribué au projet Studio de Novell et faisait partie de la recherche initiale menant à la création de Novell Test Cloud.
Grâce à l'expert technique Microsoft suivant d'avoir relu cet article : Norm Estabrook
Norm Estabrook un développeur de contenu chez Microsoft depuis plus de 10 ans, avec un accent particulier à aider les développeurs à construire des extensions de bureau et des applications mobiles natives à l'aide de Visual Studio. Il a publié de nombreux articles pour MSDN library et vit à Washington Nord-Ouest avec sa femme, deux enfants et un très doux malvoyants Schnauzer Miniature