Lorsque l'on manipule du XAML, il n'est pas rare de rencontrer des choses comme ceci:
{Binding ...}, {StaticResource ...}, and {RelativeSource ...}
Ces chaînes de caractères, encadrées des signes {}, forment ce que l'on appelle des MarkupExtensions.
Il peut arriver, lors de vos développements WPF, que les fonctionnalités offertes par le XAML ne soient pas suffisantes. Pour pallier à ce problème, la solution est d'écrire la fonctionnalité manquante dans le ode behind. Cela marche très bien mais comment faire si l'on ne veut pas écrire cette fonctionnalité dans le code mais faire le maximum de choses en XAML ? On écrit sa propre MarkupExtension ! 
Pour faire cela, il n'y a rien d'extraordainire: il vous suffit de créer une classe qui hérite de MarkupExtension et de surcharger la méthode ProvideValue:
public override object ProvideValue(IServiceProvider serviceProvider)
{
return "Hello World";
}
Notez que les conventions WPF veulent que le nom de votre extension doit-être XXXExtension mais, dans le code, vous pouvez utitliser simplement XXX: c'est la même chose pour les attributs .NET par exemple (qui se nomme YYYAttribute mais que l'on utilise sous la forme YYY):
<TextBlock Text="{CustomExtension:CalculateSum}" HorizontalAlignment="Center" VerticalAlignment="Center" />
Si vous souhaitez utiliser des paramètres, rien de bien compliquer: il vous suffit de déclarer des propriétés dans votre classe:
public double FirstNumber { get; set; }
public double SecondNumber { get; set; }
public override object ProvideValue(IServiceProvider serviceProvider)
{
if (FirstNumber == 0.0 && SecondNumber == 0.0)
{
return "No parameters specify";
}
else
{
return Convert.ToString(FirstNumber + SecondNumber);
}
}
Et ensuite, de les utiliser dans votre code XAML:
<TextBlock Text="{CustomExtension:CalculateSum FirstNumber=5, SecondNumber=20}" HorizontalAlignment="Center"
VerticalAlignment="Center" />
A l'exécution, vous remarquez que l'affichage affiche bien le résultat escompté:
Vous avez sans doute remarquez que la méthode ProvideValue renvoit un object: cela sous-entend que vous pouvez lui faire renvoyer ce que vous voulez (chaîne de caractères, images, entier, etc...). Cependant, dans la majorité des cas, vous connaissez le type que vous souhaitez renvoyer: c'est pourquoi il est bon de le spécifier, sur la classe, l'attribut MarkupExtensionReturnType (qui prend en paramètre le type à renvoyer) qui est utilisé par le parseur XAML à la compilation pour s'assurer que vous assigner un type correct à la propriété sur laquelle l'extension est utilisée:
[MarkupExtensionReturnType(typeof(string))]
Au final, votre classe (le code de votre extension) ressemblera donc à ceci:
[MarkupExtensionReturnType(typeof(string))]
public class CalculateSumExtension : MarkupExtension
{
public double FirstNumber { get; set; }
public double SecondNumber { get; set; }
public override object ProvideValue(IServiceProvider serviceProvider)
{
if (FirstNumber == 0.0 && SecondNumber == 0.0)
{
return "No parameters specify";
}
else
{
return Convert.ToString(FirstNumber + SecondNumber);
}
}
}
Bon développement à tous !
A+
Maintenant que le SP1 est en bonne voie, on peut commencer à voir les différentes améliorations apportées à tout ce qui touche à WPF. Ainsi, Brad Adams nous en parle un peu plus et nous permet de savoir que l'on a droit à:
- Des améliorations de performances pour le texte, les graphics, les animations, etc....
- Une API sur les effets WPF. Ainsi, il sera possible d'utiliser des effets (profitant de l'accélération matérielle) sur n'importe quelle "shape" (composants) => Il va falloir que je creuse ca à l'occasion
- Le support de l'onglet "Evènements" dans Cider, le designer WPF de Visual Studio (et oui, c'est tout bête mais cela n'était pas dispo...):
- Le tri par ordre alphabétique des propriétés:
- La possibilité de faire, plus simplement, du design de formulaire:
- Un meilleur debugging XAML, qui vous renvoit directement sur la ligne XAML qui est incorrecte (voila qui va faire gagner pas mal de temps
):
- Un nouveau contrôle: le WebBrowser (dans System.Windows.Controls):
- Un nouveau "BindingGroup", dans System.Windows.Data
De son coté, Scott Guthrie nous livre également une liste des nouveauté/améliorations relatives à WPF:
WPF Performance Improvements
.NET 3.5 SP1 includes several significant performance optimizations and improvements to WPF. Some of the specific graphics improvements include:
- Smoother animations
- Hardware accelerated rendering of Blur and DropShadow Bitmap Effects
- Text Rendering speed improvements - especially with VisualBrish and 3D scenes
- 2D graphics improvements - especially with z-index scenarios
- A new WriteableBitmap class that enables real-time and tear-free bitmap updates. This enables custom "paint"-style applications, data visualizations, charts and graphs that optionally bypass the default WPF 2D graphics APIs.
- Layered window performance improvements
SP1 also adds support for better data scalability in WPF. The ListView, ListBox and TreeView controls now support "item container recycling" and "virtualization" support which allows you to easily achieve a 40% performance improvement with scrolling scenarios. These controls also now optionally support a "deferred scrolling" feature which allows you to avoid scrolling in real time and instead wait until a user releases the scroll thumb (the default scrolling mode in Outlook). This can be useful when scrolling over very large data sets quickly.
WPF Data Improvements
.NET 3.5 SP1 includes several data binding and editing improvements to WPF. These include:
- StringFormat support within {{ Binding }} expressions to enable easy formatting of bound values
- New alternating rows support within controls derived from ItemsControl, which makes it easier to set alternating properties on rows (for example: alternating background colors)
- Better handling and conversion support for null values in editable controls
- Item-level validation that applies validation rules to an entire bound item
- MultiSelector support to handle multi-selection and bulk editing scenarios
- IEditableCollectionView support to interface data controls to data sources and enable editing/adding/removing items in a transactional way
- Performance improvements when binding to IEnumerable data sources
WPF also now exposes hooks that enable developers to write custom panels w/ virtualized scrolling. We'll be using this support together with the above data binding improvements to build the new WPF datagrid that will be shipping later this year.
WPF Extensible Shader Effects
.NET 3.5 SP1 adds support in WPF for a new shader effects architecture and API that allows extremely expressive visual effects to be created and applied to any control or element within WPF. These shader effects support blending multiple input compositions together. What makes them particularly powerful is that WPF executes effects (including custom effects you build yourself) using the GPU - giving you fully hardware accelerated graphics performance. Like almost everything in WPF, you can also use WPF databinding and animation on the properties of an effect (allowing them to be fully integrated into an experience).
Applying an effect onto a Control is super easy - just set a Control's "Effect" property. For example, to add a hardware accelerated drop-shadow effect on a button you can use the built-in <DropShadowEffect> on it via either code or XAML:
Which will cause the button to render like so:
Because Effects are extensible, developers can create their own custom Effect objects and apply them. For example, a custom "DirectionalBlurEffect" could be created and added to a ListBox control to change its scroll appearance to use a blur effect if you rapidly scroll across it:
Keep an eye on Greg Schechter's blog to learn more about how the Effects architecture works and to learn how you can both create and apply new effects within your applications.
Note: In addition to introducing the new Shader Effects API, WPF in SP1 also has updated the existing Blur and DropShadow Bitmap effects already in WPF to be hardware accelerated.
WPF Interoperability with Direct3D
.NET 3.5 SP1 adds support to efficiently integrate Direct3D directly into WPF. This gives you more direct access to the hardware and to take full advantage of the Direct3D API within WPF applications. You will be able to treat Direct3D content just like an image within an application, as well as use Direct3D content as textures on WPF controls.
For example, below are three samples from the Direct3D SDK:
We could either load them in as image surfaces within a WPF application, or map them as textures on WPF controls. Below is an example of mapping them as textures onto cubes in a WPF 3D application:
Note: the Direct3D integration isn't today's SP1 beta release. It will appear in the final SP1 release.
VS 2008 for WPF Improvements
VS 2008 SP1 includes several significant improvements for WPF projects and the WPF designer. These include:
- Several performance improvements
- Events tab support within the property browser
- Ability to sort properties alphabetically in the property browser
- Margin snaplines which makes form layout much quicker
- Better designer support for TabControl, Expander, and Grid
- Code initiated refactoring now updates your XAML (including both control declarations and event declarations in XAML)
- Go to Definition and Find All References now support things declared in XAML
The debugger has also been updated in SP1 so that runtime errors in XAML markup (for example: referencing styles, datasources and/or other objects that don't exist) will now be better identified within the debugger:
Je sens que la fonctionnalité "StringFormat", utilisable lors du binding, va plaire à beaucoup de monde car elle permet de formatter l'affichage lors du binding: plus besoin de passer par un Converter :
Text="{Binding ElementName=slider, Path=Value, StringFormat='Amount: {0:C}'}"
Comme vous pouvez le voir, donc, pas mal de nouveautés et encore, je n'ai couvert ici que la partie WPF: il reste ce qui touche au Web, à ClickOnce, aux langages C#/VB.NET, etc.....
Pas mal de choses à tester/jouer avec pour vous en dire plus donc !
A+
Je suis surpris de ne pas encore avoir vu passer l'info sur les blogs de CodeS-SourceS mais bon, week-end prolongé oblige je suppose
Quoi qu'il en soit, Microsoft vient de mettre en téléchargement la première Beta du SP1 de Visual Studio 2008 et du Framework .NET 3.5, à cette adresse: http://msdn.microsoft.com/fr-fr/vstudio/products/cc533447(en-us).aspx
Soma Somasegar nous en parle sur son blog:
Today we released a Beta of Visual Studio 2008 and .NET Framework 3.5 Service Pack 1.
Traditionally our service packs address a range of issues found both through customer and partner feedback as well as our own internal testing. While this service pack holds true to that theme and delivers updates for these types of issues, it also builds on the tremendous value that Visual Studio 2008 and .NET Framework 3.5 deliver today and enables an improved developer experience by adding a number of additional components that cover a range of highly requested customer features. For example, the service pack is the first release for Visual Studio 2008 that delivers full support for SQL Server 2008 and the ADO.NET Entity Framework.
La suite ici: http://blogs.msdn.com/somasegar/archive/2008/05/12/visual-studio-2008-and-net-fx-3-5-sp1-beta-available-now.aspx
Au programme, pas mal d'amélioration/nouveautés/correction de bugs !
Attention, cette version ne supporte pas les Silverlight Tools Beta 1 donc pas de Silverlight avec cette version du SP1 mais heureusement, Microsoft devrait mettre à disposition, dans très peu de temps, les Silverlight Tools Beta 2 for Visual Studio 2008 SP1 !
Voir ici pour plus de détails: http://blogs.msdn.com/webdevtools/archive/2008/05/12/error-installing-visual-studio-2008-sp1-beta-and-silverlight-tools-beta-1.aspx
Je ne dirais qu'une chose: à vos VPCs pour tester tout cela
A+
Si la réponse à cette question est oui, alors je ne peux que vous conseiller d'aller sur le blog de Jesse Liberty. En effet, il a posté un petit concours pour tout ceux qui veulent tester leur compétences en terme de débugging.
Comme vous le verrez, cela n'a rien de bien compliqué mais la problématique est intéressante. De plus, Jesse promet de mettre à disposition une vidéo dans laquelle il corrige le bug et explique le "pouquoi du comment"
Pour en savoir plus, c'est par ici: http://silverlight.net/blogs/jesseliberty/archive/2008/05/01/silverlight-debugging-challenge.aspx
A+
J'ai répondu récemment à une question, sur les forums de Developpez.com, qui était forte intéressante et qui valait bien un petit post sur mon blog.
Pour faire simple, le demandeur était dans le cas suivant:
- Une listbox liée à une liste de personne
- Un attribut personnalisé sur les propriétés de la classe Person
Son besoin était simple: il voulait pouvoir afficher, lors d'un binding, la valeur d'une des propriétés de l'attribut personnalisé. En terme de code, nous avions donc ceci:
public class Person
{
[PersonProperties("LastName : ")]
public string LastName { get; set; }
[PersonProperties("FirstName : ")]
public string FirstName { get; set; }
}
public class PersonCollection : ObservableCollection<Person>
{
}
[global::System.AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
sealed class PersonPropertiesAttribute : Attribute
{
public string Header { get; private set; }
public PersonPropertiesAttribute(string header)
{
this.Header = header;
}
}
Il faut à présent remplir notre collection de personne, par exemple lors du chargement de la fenêtre:
private void Window_Loaded(object sender, RoutedEventArgs e)
{
ObjectDataProvider odp = this.TryFindResource("PersonCollectionDS") as ObjectDataProvider;
if (odp != null)
{
PersonCollection pc = odp.Data as PersonCollection;
if (pc != null)
{
pc.Add(new Person() { LastName = "LEBRUN", FirstName = "Thomas" });
pc.Add(new Person() { LastName = "SANTIN", FirstName = "Florent" });
pc.Add(new Person() { LastName = "SENTENAC", FirstName = "Philippe" });
pc.Add(new Person() { LastName = "FURUTA", FirstName = "Mitsuru" });
}
}
}
Maintenant, il faut faire en sorte que, lors du binding, on arrive à accéder à l'attribut "PersonProperties" (et à sa valeur) et à l'afficher. Pour cela, il faut déjà mettre en place le binding, en utilisant un convertisseur auquel on va passer un paramètre:
<TextBlock HorizontalAlignment="Right" Margin="0,17,8,0" VerticalAlignment="Top" Width="126" Height="16" Text="{Binding Path=SelectedItem, Converter={StaticResource GetPersonAttributeConverter}, ConverterParameter=LastName, ElementName=lbPersons, Mode=Default}" TextWrapping="Wrap" x:Name="tbLastName"/>
<TextBlock HorizontalAlignment="Right" Margin="0,52,8,0" VerticalAlignment="Top" Width="126" Height="16" Text="{Binding Path=SelectedItem, Converter={StaticResource GetPersonAttributeConverter}, ConverterParameter=FirstName, ElementName=lbPersons, Mode=Default}" TextWrapping="Wrap" x:Name="tbFirstName"/>
Comme vous pouvez en douter, toute la magie va se passer dans le convertisseur, qui va tout simplement faire un peu de reflection sur l'objet passé en paramètre (un objet de type Person) et accéder aux attributs personnalisés:
public class GetPersonAttributeConverter : IValueConverter
{
#region IValueConverter Members
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
string result = string.Empty;
if (value != null)
{
Person p = value as Person;
if (p != null)
{
var properties = p.GetType().GetProperties();
foreach (var propertyInfo in properties)
{
var attributes = propertyInfo.GetCustomAttributes(typeof(PersonPropertiesAttribute), true);
if (((PersonPropertiesAttribute)attributes.GetValue(0)) != null)
{
string header = ((PersonPropertiesAttribute)attributes.GetValue(0)).Header;
string parameterToUse = parameter as string;
if (parameterToUse != null)
{
if (header.Contains(parameterToUse))
{
switch (parameterToUse)
{
case "LastName":
result = string.Concat(header, p.LastName);
break;
case "FirstName":
result = string.Concat(header, p.FirstName);
break;
default:
break;
}
}
}
}
}
}
}
return result;
}
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
return null;
}
#endregion
}
A l'exécution, le biding est bien mis en place et grâce à la reflection, nous accédons à la valeur des propriétés de notre attribut personnalisé:
Pour ceux qui veulent tester, vous trouverez le code source de la démonstration ici: Source
A+
Voila un moment que je n'avais pas écrit d'articles sur le Web. Je reviens donc avec un nouvel article sur le site TechHeadBrothers:
"Windows Communication Foundation est une technologie très impressionnante qui permet de mettre en place, en quelques lignes de code, une architecture client/serveur. De son coté, Windows Presentation Foundation est la nouvelle technologie de création d'interfaces graphiques. Dès lors, il serait tout à fait possible, et c'est ce que nous allons faire au cours de cet article, d'implémenter une application WPF utilisant un service WCF, afin de tirer parti du meilleur de chacune des technologies."
La suite: Développer une visionneuse d'images avec WPF et WCF
Si vous voulez en savoir plus sur l'utilisation conjointe de WPF et WCF, alors cet article est fait pour vous !
Je tiens à remercier Laurent de m'accueillir parmis les auteurs de son site Web !
Bonne lecture à tous....
A+
En décembre, j'ai eu l'occasion de passer la certification suivante en version Beta:
Microsoft .NET Framework 3.5 ? Windows Presentation Foundation
Je viens d'apprendre que j'avais réussit avec succès cette certification:
Hormis le fait de me vanter de l'avoir réussit (bah oui, faut bien se faire des fleurs de temps en temps 
), je voudrais simplement vous souligner le fait que les questions correspondent parfaitement à ce que l'on peut voir dans des développements courants: j'ai été surpris des questions posées car celles-ci pouvaient aller de la question très très technique à des choses beaucoup plus simple.
D'une manière générale, cette certification en s'adresse pas spécialement à des développeurs expérimentés sur la technologie, mais à des débutants/nouveaux !
A+
Ca y est, nous y voila: l'ensemble des MVPs/RD de Winwise est arrivé à Seattle pour le MVP Summit. Vous aurez donc, pendant cette semaine, un ensemble de post de la part de ces personnes (et bien d'autres ;) ):
- Florent Santin
- Matthieu Mezil
- Philippe Sentenac
- Michel Perfertti
- Christian Robert
- Daniel Tizon (RD)
- Gaétan Bouverêt
Pour moi, c'est une première (aussi bien en terme de Summit que de venue aux Etats-Unis) donc j'espère passer de bons moments que je tâcherais de vous raconter si je le peux: stay tuned !
Beaucoup de gens se plaignent des lenteurs d'Outlook. Le dernier en date n'est autre que noter cher Nix qui a carrément finit par abandonner le produit (ct ce post pour plus de détails).
Je viens enfin de découvrir la raison pour laquelle Outlook peut parfois être aussi lent: c'est parce qu'il est fait en .NET. Vous ne me croyez pas ? La preuve en images:
Voila maintenant qui osera dire que .NET est performant ? 
A+
PS: Ce post est à prendre au second degré. En effet, même si je me doute bien qu'un outil comme Microsoft Outlook n'est pas développé en .NET mais plutôt en C++, il n'en reste pas moins que cela soit quelque peut... déroutant
Dans la version 1.1 Alpha de Silverlight 2, mais également dans la version 1.0, on disposait d'un composant bien pratique pour télécharger des éléments: le Downloader.
Avec la version 2 de Silverlight, ce contrôle n'existe plus mais a été remplacé par un composant nommé WebClient, le même que celui que l'on peut retrouver dans le Framework .NET.
Pour l'utiliser afin de télécharger des fichiers, il n'y a rien de plus simple: il vous suffit de vous abonner à l'évènement OpenReadCompleted et à lancer un appel à la méthode OpenReadAsync, qui va exécuter la requête de manière asynchrone:
WebClient client = new WebClient();
client.OpenReadCompleted += new OpenReadCompletedEventHandler(client_OpenReadCompleted);
client.OpenReadAsync(new Uri("../Files/Demo.txt", UriKind.Relative));
Vous pouvez remarquer que la méthode prend en paramètre un objet de type Uri qui pointe vers le fichier à télécharger. Vous pouvez aussi vous demander pourquoi avoir utiliser les ".." dans l'adresse du fichier. En fait, n'oubliez pas que le fichier qui va contenir votre application Silverlight, le fichier ".xap", est déployé dans le répertoire ClientBin: il vous faut donc remonter jusqu'à la racine ou, plus simplement, jusqu'à l'emplacement exact du fichier à télécharger.
Il ne nous reste plus qu'à écrire le contenu de la méthode client_OpenReadCompleted:
void client_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
StreamResourceInfo streamText = new StreamResourceInfo(e.Result, string.Empty);
StreamReader reader = new StreamReader(streamText.Stream);
this.tbText.Text = reader.ReadToEnd();
}
On utilise un objet de type StreamResourceInfo, en lui passant en paramètre le résultat de l'appel à la méthode OpenReadAsync. Cet objet est ensuite utilisé via un StreamReader qui sera manipulé pour afficher le contenu du fichier.
Cette technique est très pratique lorsque l'on doit télécharger des fichiers "uniques" mais dans le cas où l'on souhaite télécharger des archives Zip, il va falloir faire autrement.
La déclaration du WebClient ne change pas, hormis le nom du fichier a télécharger:
WebClient clientZip = new WebClient();
clientZip.OpenReadCompleted += new OpenReadCompletedEventHandler(clientZip_OpenReadCompleted);
clientZip.OpenReadAsync(new Uri("../Files/DemoZip.zip", UriKind.Relative));
La méthode clientZip_OpenReadCompleted, elle, est légèrement différente:
void clientZip_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
StreamResourceInfo streamZip = new StreamResourceInfo(e.Result, string.Empty);
var demoZipFile = Application.GetResourceStream(streamZip, new Uri("DemoZip.txt", UriKind.Relative));
StreamReader reader = new StreamReader(demoZipFile.Stream);
this.tbZip.Text = reader.ReadToEnd();
}
Comme dans la précédente version, on utilise un objet de type StreamResourceInfo. Cependant, alors qu'avant nous avions directement accès au contenu du fichier, ici nous allons devoir récupérer, via la méthode Application.GetResourceStream, un flux vers le fichier qui nous intéresse, au sein de l'archive Zip.
A l'exécution, nous récupèrons bien le contenu de nos 2 fichiers: le premier directement depuis le fichier texte et le second depuis le fichier texte contenu dans l'archive Zip:
Vous pourrez trouver, en pièce jointe à ce post, une application de démonstration de cette technique.
A+
Scott Morrison
, le Program Manager du DataGrid de Silverlight 2, a posté, sur son blog, 2 tutoriaux vraiment très complet sur le fonctionnement et l'utilisation de ce composant dans vos applications Silverlight:
Using The Silverlight DataGrid
Defining Columns for a Silverlight DataGrid
Le moins que l'on puisse dire, c'est que ces articles sont des "must-read" pour tous les développeurs d'applications Silverlight
A+
Si vous avez déjà commencé à jouer avec Silverlight 2, vous avez sans doute découvert une chose bien pratique: une application Silverlight 2 est capable de se redimensionner automatiquement lorsqu'elle est en cours d'exécution si sa hauteur/largeur est positionnée sur "Auto" plutôt qu'une valeur fixe
Bien que cela soit très pratique pour les utilisateurs, cela ne s'avère pas très utilisable pour les designers car ceux-ci se retrouve, dans Blend, avec une interface ressemblant à celle-ci:
Afin de corriger cela, et donc de leur permettre de travailler correctement, sachez qu'il est possible de changer la taille du contrôle, en mode design uniquement. Pour cela, rien de plus simple: au niveau de votre élément racine, dans le XAML, ajoutez ce namespace:
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
Puis rajouter les propriétés suivantes:
d:DesignWidth="640" d:DesignHeight="480"
DesignWidth et DesignHeight sont des propriétés utilisées par Expression Blend (et donc non comprises par Visual Studio).
A l'exécution, on obtient bien quelque chose de plus grand:
Voila qui devrait faire plaisir à vos designers !
A+
Je viens tout juste de terminer la lecture du livre "LINQ In Action" de Fabrice Marguerie, Steve Eichert et Jim Wooley
Je dois admettre que je suis très impressionné par ce livre. Non pas par la le niveau technique du livre (je n'en attendais pas moins de la part des auteurs ) mais surtout par la pédagogie employée pour expliquer des concepts qui peuvent, parfois, sembler compliquer/déroutant à des développeurs amateurs ou ne connaissant pas le sujet.
Tout ceux qui ont déjà écrit des livres (ou encore des articles) savent qu'il n'est pas simple d'expliquer et de retranscrire des notions complexes.
Les auteurs de ce livre ont parfaitement réussit ce challenge: il est donc à la fois très technique (n'oubliez pas que LINQ n'est pas une mince affaire) mais très bien expliqué, ce qui le rend d'autant plus intéressant !
Bref, pour tous ceux qui veulent en savoir plus sur les entrailles de LINQ, son fonctionnement, etc... ou bien pour tout ceux qui veulent savoir comment l'utiliser (et bien l'utiliser), alors je ne saurais que trop recommander ce livre !
Bonne lecture à tous
A+
Par mesure de précaution, je préviens qu'il s'agit d'un message à prendre au 36ème degré....
D'après InsideRIA, Microsoft vient d'annoncer une nouvelle intéressante pour tous les développeurs Silverlight.
En effet, la version 2 de Silverlight n'est pas encore sortie en version finale que l'on commence à avoir des informations à propos de la prochaine version, Silverlight 3 (Nom de code: "Silverlight Gold").
Ainsi, il y a fort à parier que cette prochaine version supportera, nativement, la lecture et l'affichage des fichiers SWF (ce format de fichier étant ouvert, il ne devrait pas y avoir de problèmes légaux quand à son utilisation).
Attention, il s'agit d'une information à prendre "avec des pincettes": je n'ai pas encore trouvé la fameuse annonce dont le blog InsideRIA parle. Cependant, si cela s'avérait véridique, il s'agirait d'une nouvelle très très intéressante et très prometteuse....
Si vous avez des informations à ce sujet (confirmation ou infirmation), n'hésitez pas à me laisser un message en commentaire de ce post
A+
Voici une astuce que j'ai découvert en regardant notre designer utiliser Expression Blend. Dans une application WPF, il a utilisé une police personnalisée, c'est-à-dire une police qui n'est pas en standart sur tous les ordinateurs.
Dès lors, Expression Blend lui a généré le code suivant:
<TextBlock FontFamily="Fonts/#graphicpixel" x:Name="tbCustomFont" />
Et dans le projet Visual Studio sur lequel il travaillait, il s'est retrouvé avec un répertoire nommé "Fonts" comprennant la liste des différents fichiers de polices personnalisées qu'il utilise.
En effet, sur les contrôles d'affichage de texte, il est possible de spécifier la police à utiliser. Dès lors où celle-ci n'est pas présent sur la machine, le plus simple est de déployer la police en même tems que l'application. Pour utiliser cette police, il vous faudra utiliser la syntaxe ci-dessus, c'est-à-dire:
NomDuRépertoireDesPolices/#NomDeLaPolice
Ainsi, à l'exécution, le code XAML suivant:
<Viewbox>
<StackPanel Orientation="Vertical">
<TextBlock x:Name="tbNormalFont" />
<TextBlock FontFamily="Fonts/#graphicpixel" x:Name="tbCustomFont" />
</StackPanel>
</Viewbox>
Associé à ce code-behind:
private void Window_Loaded(object sender, RoutedEventArgs e)
{
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = new TimeSpan(0, 0, 1);
timer.Tick += (senderTick, argTick) =>
{
this.tbCustomFont.Text = this.tbNormalFont.Text = string.Concat(DateTime.Now.Hour.ToString(), ":", DateTime.Now.Minute.ToString(), ":", DateTime.Now.Second.ToString());
};
timer.IsEnabled = true;
}
Nous permettent d'obtenir le résultat ci-dessous:
A+
Voila une question très intéressante En effet, tout le monde connait les possibilités de WPF en terme de design et l'on sait parfaitement que le rendu est vectoriel donc la qualité est vraiment nickel.
A ce titre, il serait dommage de ne pas profiter des capacités de WPF directement au sein de votre application, afin d'offrir une meilleure expérience utilisateur. Ainsi, pourquoi (et comment) ne pas faire comme Expression Blend ou Family.Show et proposer une fonctionnalité de zoom sur l'interface du logiciel ?
Avec WPF, cette technique peut être mise en place très rapidement: en effet, il vous suffit de jouer sur la transformation de type ScaleTranform de votre élément racine:
<Grid>
<ScrollViewer HorizontalScrollBarVisibility="Auto">
<Canvas x:Name="canvas" Background="#FFFFFFFF" Width="300" Height="300">
<Canvas.LayoutTransform>
<ScaleTransform
ScaleX="{Binding Path=Value, ElementName=zoomSlider}"
ScaleY="{Binding Path=Value, ElementName=zoomSlider}"/>
</Canvas.LayoutTransform>
<Button Content="OK" Canvas.Top="100" Canvas.Left="100"/>
</Canvas>
</ScrollViewer>
<Slider x:Name="zoomSlider" Minimum="0.1" Maximum="5" Value="1"/>
</Grid>
Bon développement à tous
A+
La contrôle PasswordBox est sans doute l'un des plus importants disponible avec le Framework .NET.
Non présent dans Silverlight 2, je m'en suis créé un pour les besoins d'un projet. Pour le faire, j'ai simplement hériter de la classe TextBox: on voit donc que le modèle de développement est le même qu'en WPF (Windows Presentation Foundation)
Bien sur, ce contrôle n'est pas parfait, en grande partie à cause du fait que le contrôle TextBox ne donne aucune information sur la position du curseur (Caret): sans doute pour la version finale ?
Quoiqu'il en soit, ce contrôle fonctionne et vous donne une idée de comment tout cela fonctionne.
/// <summary>
/// A control that represent a Password TextBox. As there is no information about the position of the caret,
/// the control is not perfect but all the logic is here.
/// </summary>
public class PasswordBox : TextBox
{
public StringBuilder SecureText { get; private set; }
public PasswordBox()
: base()
{
this.SecureText = new StringBuilder();
this.KeyDown += new KeyEventHandler(PasswordBox_KeyDown);
}
void PasswordBox_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key != Key.Back)
{
this.SecureText.Append(e.Key.ToString().ToLower());
this.Text = string.Empty;
for (int i = 0; i <= this.SecureText.Length - 1; i++)
{
this.Text += "*";
}
}
else
{
this.SecureText.Remove(this.SecureText.Length - 1, 1);
this.Text.Remove(this.Text.Length - 1, 1);
}
e.Handled = true;
}
}
A+
Et oui, après avoir été accessible en avant première aux abonnés MSDN, le Service Pack 1 de Windows Vista est disponible en téléchargement à l'adresse suivante:
http://www.microsoft.com/downloads/details.aspx?displaylang=fr&FamilyID=b0c7136d-5ebb-413b-89c9-cb3d06d12674
On y apprend également que celui-ci est disponible sur Windows Update.
Un conseil: pour avoir installé le SP1 tout de suite après sa mise à disposition sur MSDN, je ne saurais que trop vous conseiller de l'installer car on remarque une nette différence entre avant et après
A+
Si vous souhaitez en savoir plus sur le développement de contrôles et d'applications avec Silverlight 2, il y a un blog à mettre dans vos bookmarks et à visiter souvent: celui de David Anson
Si vous ne voyez pas de qui il s'agit, David est l'auteur de démonstrations assez impressionnantes faîtes avec Silverlight 1.1. Ainsi, l'auteur des démonstrations Silverlight Airlines (celle qui a vraiment commencé à montrer les possibilités de Silverlight et du code managé) et de Surface version Silverligth, c'est lui
David travaille toujours sur Silverlight 2 et son blog est une mine d'or pour ceux qui recherchent des informations sur SL2. Ainsi, il nous explique comment il a fait pour développer les contrôles ListBox et ScrollViewer.
De même, il montre comment faire pour migrer des applications WPF (relativement complexes, il faut le dire) en applications Silverlight, avec les corrections de code qui vont bien. Par exemple, il explique comment il a fait pour migrer l'application de visualisation des planètes, réalisé par Beatriz Costa:
En une application Silverlight:
Donc, si vous voulez en savoir plus, en apprendre plus ou bien tout simplement être impressionné, je vous recommande chaudement son blog: http://blogs.msdn.com/delay/default.aspx
A+
Il n'est jamais simple de se rendre compte à quels points une technologie est importante et ce qu'elle peut nous apporter.
Dans le cas de Silverlight 2, c'est un peu la même chose. Afin de vous aider à y voir plus clair, vous pouvez jeter un oeil à cette démo (le "Silverlight in Financials Demonstrator"), qui simule un environnement financier/banquaire et dont l'interface est entièrement faite en SL 2:
Il faut tout de même admettre que le résultat est vraiment impressionnant. Et pour ceux qui voudrait savoir comment utiliser cette démo, il y a un script qui l'accompagne
Ah oui, cerise sur le gateau: le code source est disponible à cette adresse
Un grand merci à l'équipe d'Infusion Development (http://www.infusion.com/index.aspx) pour ce travail assez spectaculaire, il faut le dire....
Profitez-en bien !
A+
Les 10 derniers blogs postés
-
Virtual PC 2007 SP1 et Virtual Server 2005 R2 SP1 mis à jour : support Windows Server 2008, Vista SP1 et XP SP3 par
CoqBlog le il y a 8 heures et 58 minutes
-
HxD (éditeur hexa freeware) mis à jour par
CoqBlog le il y a 9 heures et 51 minutes
-
[ASP.NET]FileUpload et UpdatePanel par
Team Itelios - Clément, Xavier, Guillaume, Stéphan le il y a 14 heures et 35 minutes
-
SharePoint : Installer le composant de Lookup en Cascade sur WSS V3 par
Blog Technique de Romelard Fabrice le il y a 18 heures et 22 minutes
-
WygDay 2008, Session Silverlight 2 & Expression 2 par
Les technologies RIA le il y a 21 heures et 46 minutes
-
EDM: ComplexType an error for a warning? par
Matthieu MEZIL le 05-16-2008, 01:15
-
Entity cloner par
Matthieu MEZIL le 05-16-2008, 00:17
-
ZUNE : le Tagging des Vidéos extrèmement simple par
Blog Technique de Romelard Fabrice le 05-15-2008, 20:35
-
ZUNE et WMP : Bug sur la gestion des répertoires surveillés par
Blog Technique de Romelard Fabrice le 05-15-2008, 19:20
-
Virtual Earth : L'import de données en masse : Bulk Addition par
Blog technique de Nicolas Boonaert le 05-15-2008, 18:42
