Overblog Suivre ce blog
Administration Créer mon blog

Présentation

  • : Romagny13 - Du .NET,du pur .NET
  • Romagny13 - Du .NET,du pur .NET
  • : Cycle de progression Faire (quelque chose qui marche) -> comprendre ce que l’on fait/comment cela marche -> pousser plus loin les notions
  • Contact

Recherche

Articles Récents

6 avril 2014 7 06 /04 /avril /2014 23:56

    1-Styles

    a-Un Style peut être défini :  

  • Dans le contrôle lui-même 
<TextBox HorizontalAlignment="Left" Height="50" TextWrapping="Wrap" Text="TextBox" VerticalAlignment="Top" Width="200">           
                 <TextBox.Style>           
                <Style TargetType="TextBox">
                    <Setter Property="Foreground" Value="Yellow" />
                </Style>
            </TextBox.Style>
  </TextBox>           
 
  • En ressource d’un conteneur/ de la page/fenêtre/etc.
<Grid.Resources>
            <Style TargetType="TextBox">
                <Setter Property="Foreground" Value="Yellow" />
           </Style>
</Grid.Resources>

 

  • Dans un dictionnaire de ressources (pour toute l’application).
Exemple : on ajoute un dossier « Ressources » puis un dictionnaire de ressources « Styles.xaml »    

App.xaml

<Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="/Ressources/Styles.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Application.Resources>

 

b- Styles nommés, implicites, BasedOn
  • Style accessible par sa clé
<Style x:Key="TextBoxStyle" TargetType="TextBox">
                <Setter Property="FontSize" Value="20" />
                <Setter Property="Foreground" Value="Violet"/>
</Style>

 

  • Style s’appliquant à tous les contrôles d’un type
<Style TargetType="TextBox">
                <Setter Property="FontSize" Value="20" />
                <Setter Property="Foreground" Value="Violet"/>
</Style>
   
  • BasedOn Héritage de Style(par nom ou implicite)
Exemple : ici toutes les TextBox auront une police bleue de taille 20
<Style x:Key="BaseTextBoxStyle" TargetType="TextBox">
                <Setter Property="FontSize" Value="20" />
                <Setter Property="Foreground" Value="Violet"/>
</Style>
<Style TargetType="TextBox">
                <Setter Property="Foreground" Value="Red"/>
</Style>
 
<Style TargetType="TextBox" BasedOn="{StaticResource BaseTextBoxStyle}">
                <Setter Property="Foreground" Value="Blue"/>
</Style>

 

2 – Templates

a – Un Template peut être défini
  • Dans le contrôle lui-même
<Button x:Name="btOK"  Width="150" Height="50" Content="OK" Foreground="White">
            <Button.Template>
                <ControlTemplate TargetType="Button">
                    <Border Height="{TemplateBinding Height}"
                                 Width="{TemplateBinding Width}"
                                 CornerRadius="5" Background="Black">
                        <ContentPresenter VerticalAlignment="Center" HorizontalAlignment="Center"/>
                    </Border>
                </ControlTemplate>
            </Button.Template>
        </Button>
   
  • En Ressource d’un conteneur/de la page/fenêtre/etc.
<Window.Resources>
        <ControlTemplate x:Key="ButtonControlTemplate" TargetType="{x:Type Button}">
            <Border Height="{TemplateBinding Height}"
                         Width="{TemplateBinding Width}"
                         CornerRadius="5" Background="Black">
                <ContentPresenter VerticalAlignment="Center" HorizontalAlignment="Center"/>
            </Border>
        </ControlTemplate>
    </Window.Resources>

 

  •                Dans un dictionnaire de ressources, exemple on crée « DataTemplates.xaml » dans le dossier Ressources 

 

A noter que Visual Studio offre des facilités pour définir son Template depuis la fenêtre « Structure du document »

 

sil1.png

 

 

 

On distingue les « ControlTemplate » et les « DataTemplate » (pour les contrôles affichant des listes)
Exemple d’un DataTemplate
<ListBox ItemsSource="{Binding Products}" Width="300" Height="300">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Horizontal">
                                      <Image Source="{Binding Photo}" Width="50" />
                        <TextBlock Text="{Binding ProductName}" Width="Auto"/>
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>

  

3-TemplateBinding

Sans TemplateBinding … la taille du Template ne s’adapte pas
sil2.png

 

… Avec TemplateBinding la taille s’adapte
<Button Width="100" Height="50" Content="OK" Foreground="White">
            <Button.Template>
                <ControlTemplate TargetType="Button">
                    <Border Height="{TemplateBinding Height}"
                                 Width="{TemplateBinding Width}"
                                 CornerRadius="5" Background="Black">
                    </Border>
                </ControlTemplate>
            </Button.Template>
        </Button>

 

sil3.png

 

4-ContentPresenter

Dans un Template, affiche le contenu du contrôle.

Exemple : Ajoute le « OK »  
<Button Width="100" Height="50" Content="OK" Foreground="White">
            <Button.Template>
                <ControlTemplate TargetType="Button">
                    <Border Height="{TemplateBinding Height}"
                                 Width="{TemplateBinding Width}"
                                 CornerRadius="5" Background="Black">
                        <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
                    </Border>
                </ControlTemplate>
            </Button.Template>
        </Button>

 

5-ItemsPresenter

Pour les contrôles affichant des listes
<ListBox Width="300" Height="300">
            <ListBox.Template>
                <ControlTemplate>
                    <Border CornerRadius="20,20,20,20"
                            BorderThickness="5 5 5 5" BorderBrush="#FFFF957C"
                            Padding="5,5,5,5">
                        
                        <ItemsPresenter />
                    </Border>
                </ControlTemplate>
            </ListBox.Template>
            <ListBoxItem>Item 1</ListBoxItem>
            <ListBoxItem>Item 2</ListBoxItem>
        </ListBox>
Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
5 avril 2014 6 05 /04 /avril /2014 15:29

(Suites de contrôles)

 

WPF Toolkit http://wpf.codeplex.com/

Silverlight Toolkit http://silverlight.codeplex.com/

Windows Phone Toolkit http://phone.codeplex.com/

 

Ou directement depuis Visual Studio avec les Packages NuGet 

Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
2 avril 2014 3 02 /04 /avril /2014 00:31

1-Définition des « VisualState »
Le squelette se présente ainsi

   <VisualStateManager.VisualStateGroups>
            <VisualStateGroup>
                <VisualState x:Name="Normal" />
                     
                <VisualState x:Name="Loading">
                    <Storyboard>
                        <!-- Animations -->
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>

 

2-Trigger ou Code-behind

Ajouter un référence à System.Windows.Interactivity et Microsoft.Expression.Interactions
Puis les namespaces :
xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity" 
xmlns:ei=http://schemas.microsoft.com/expression/2010/interactions
Exemple :
Je suis bindé à CurrentState , une simple propriété de mon ViewModel .Il y a un état pour la valeur « Normal » du CurrentState et un état « Loading » (correspondant  au chargement) .
  public class ArticleMasterDetailsViewModel :ListViewModelBase<ArticleViewModel>
  {
        private string _currentState;

 

        public string CurrentState
        {
            get { return _currentState; }
            set
            {
                _currentState = value;
                RaisePropertyChanged<string>(() => CurrentState);
            }
        }
    // etc.
}

 

On peut changer la valeur de ce CurrentState à chaque chargement .Intéressant si on charge des données de manière asynchrone.

 

L’EventTrigger ayant EventName= »Loaded » s’exécute automatiquement au chargement du usercontrol/Window
<i:Interaction.Triggers>
            <ei:DataTrigger Binding="{Binding CurrentState}" Value="Normal">
                <ei:GoToStateAction StateName="Normal"/>
            </ei:DataTrigger>
            <ei:DataTrigger Binding="{Binding CurrentState}" Value="Loading">
                <ei:GoToStateAction StateName="Loading"/>
            </ei:DataTrigger>
            <i:EventTrigger EventName="Loaded">
                <ei:GoToStateAction StateName="Loading"/>
            </i:EventTrigger>
        </i:Interaction.Triggers>



Il est possible aussi de Changer l’état visuel depuis le code – behind
Si c’est un UserControl on utilisera GoToState
VisualStateManager.GoToState(control1, "Loading", true)
Sinon (LayoutRoot correspondant au nom de mon Grid principal)
VisualStateManager.GoToElementState(this.LayoutRoot as FrameworkElement, "Loading", true);

 

3-Un exemple
Un exemple qui se contente de cacher une grille pour afficher une autre avec un message « Chargement » .
Blend est tout indiqué pour définir des animations.

 

  <Grid x:Name="LayoutRoot" >
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup>
                <VisualState x:Name="Normal" />
                                         
                <VisualState x:Name="Loading">
                    <Storyboard>
                        <!-- Cache mainGrid -->
                        <ObjectAnimationUsingKeyFrames Storyboard.TargetProperty="(UIElement.Visibility)" Storyboard.TargetName="mainGrid">
                            <DiscreteObjectKeyFrame KeyTime="0">
                                <DiscreteObjectKeyFrame.Value>
                                    <Visibility>Collapsed</Visibility>
                                </DiscreteObjectKeyFrame.Value>
                            </DiscreteObjectKeyFrame>
                        </ObjectAnimationUsingKeyFrames>
                        <!-- Affiche loadingGrid -->
                        <ObjectAnimationUsingKeyFrames Storyboard.TargetProperty="(UIElement.Visibility)" Storyboard.TargetName="loadingGrid">
                            <DiscreteObjectKeyFrame KeyTime="0">
                                <DiscreteObjectKeyFrame.Value>
                                    <Visibility>Visible</Visibility>
                                </DiscreteObjectKeyFrame.Value>
                            </DiscreteObjectKeyFrame>
                        </ObjectAnimationUsingKeyFrames>
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
 
        <Grid x:Name="loadingGrid" Opacity="1"  Visibility="Collapsed"  Background="Black">
            <Label Content="Chargement ..." FontSize="25" Foreground="White" VerticalAlignment="Bottom" HorizontalAlignment="Center" />
        </Grid>
       
        <Grid x:Name="mainGrid">
<!-- contrôles de la page(textbox,boutons,etc.) -->
        </Grid>
     
    </Grid>

 

Après libre d’utiliser Trigger + binding sur propriété ou VisualStateManager dans le code-behind,ajouter des animations/Transformations
async1.png
Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
28 mars 2014 5 28 /03 /mars /2014 01:34

TargetNullValue est pratique par exemple pour les formulaires afin d’éviter les champs vides.

 

A - On peut soit définir directement
<TextBox Text="{Binding CurrentArticle.Description,TargetNullValue='Entrez la description'}" />
B - Ou dans un dictionnaire de ressources (ou dans les ressources de la page/conteneur)
    <sys:String x:Key="targetNullName">Entrez le nom de l'article</sys:String>         
On ajoute le namespace xmlns:sys="clr-namespace:System;assembly=mscorlib"
On peut ainsi accéder facilement à la ressource depuis l’application et contourner le problème des apostrophes
(code simplifié pour la clarté de l’exemple)
<TextBox Text="{Binding CurrentArticle.ArticleName,TargetNullValue={StaticResource targetNullName} }"/>    
Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
27 mars 2014 4 27 /03 /mars /2014 20:13

Exemple : la ComboBox affiche une liste de catégories, la catégorie sélectionnée correspond à celle de l’article

 

1-Une ComboBox « classique »
que l’on pourrait retouver dans une vue détails .
  • ItemsSource : ce  doit être un énumérable (exemple une observableCollection AllCategories)
  • DisplayMemberPath : la valeur affichée(exemple : CategoryName de AllCategories)
  • SelectedValuePath : la valeur « cachée » dans la source (exemple CategoryID de AllCategories)
  • SelectedValue : la valeur à sélectionner de l’objet (exemple CategoryID de CurrentArticle)
  • SelectedItem : l’objet qui sera mis à jour en cas de modification à partir de l’UI ou par code) (important, exemple si la source est une ObservableCollection<Category> ,alors il faut donner un SelectedItem de type « Category »)
      <ComboBox    ItemsSource="{Binding AllCategories}"
                   SelectedValuePath="CategoryID"
                   DisplayMemberPath="CategoryName"
                   SelectedValue="{Binding CurrentArticle.Category.CategoryID}"
                   SelectedItem="{Binding CurrentArticle.Category}"
                   />

 

2-Une ComboBox dans un Datagrid définie avec un Template
(ici Avec DataGridTemplateColumn)  
   <DataGrid      ItemsSource="{Binding Articles}"
                  SelectedItem="{Binding CurrentArticle,Converter={StaticResource ignoreNewItemPlaceHolderConverter}}"
                  AutoGenerateColumns="False">
 
            <DataGrid.Resources>
                <DataTemplate x:Key="combo" >
                    <Border>
                        <ComboBox       ItemsSource="{Binding RelativeSource={RelativeSource AncestorType=Window},Path=DataContext.AllCategories}"
                                        SelectedValuePath="CategoryID"
                                        DisplayMemberPath="CategoryName"
                                        SelectedValue="{Binding Category.CategoryID}"
                                        SelectedItem="{Binding Category,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"
                                        SelectionChanged="ComboBox_SelectionChanged"
                                        />
                    </Border>
                </DataTemplate>
            </DataGrid.Resources>
 
            <DataGrid.Columns>
                <!— colonnes classiques -->
                <DataGridTextColumn Header="Nom"  Binding="{Binding ArticleName,UpdateSourceTrigger=PropertyChanged}" Width="SizeToCells" />
                <DataGridTextColumn Header="Description"  Binding="{Binding Description,UpdateSourceTrigger=PropertyChanged}" Width="SizeToCells"/>
                <DataGridTextColumn Header="Prix"  Binding="{Binding UnitPrice, StringFormat=\{0:C\},UpdateSourceTrigger=PropertyChanged}" Width="SizeToCells"/>
                <!— Utilisation DataGridTemplateColumn -->
                <DataGridTemplateColumn CellTemplate="{StaticResource combo}" />
            </DataGrid.Columns>
        </DataGrid>

 

    Il est également possible de récupérer dans le code-behind l’élément sélectionné(SelectedItem)  
        private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            // Définir la catégorie de l'élément par code au changement dans le datagrid
            Category category = ((ComboBox)sender).SelectedItem as Category;                         
                  context.CurrentArticle.Category = category;
 
        }

 

3-DataGridComboBoxColum
On définit la source de données pour l’état « en édition » et l’état normal
Important car sinon tout simplement vous vous retrouverez avec une liste vide.
<DataGrid         ItemsSource="{Binding Articles}"
                  SelectedItem="{Binding CurrentArticle}"
                  AutoGenerateColumns="False">
 
                <DataGridComboBoxColumn Header="Catégorie"
                                        SelectedValuePath="CategoryID"
                                        DisplayMemberPath="CategoryName"
                                        SelectedValueBinding="{Binding Category.CategoryID}"
                                        SelectedItemBinding="{Binding Category,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"
                                        Width="SizeToCells">
 
                    <DataGridComboBoxColumn.ElementStyle>
                        <Style TargetType="ComboBox">
                            <Setter Property="ItemsSource" Value="{Binding RelativeSource={RelativeSource AncestorType=Window},Path=DataContext.AllCategories}" />
                        </Style>
                    </DataGridComboBoxColumn.ElementStyle>
 
                    <DataGridComboBoxColumn.EditingElementStyle>
                        <Style TargetType="ComboBox">
                            <Setter Property="ItemsSource" Value="{Binding RelativeSource={RelativeSource AncestorType=Window},Path=DataContext.AllCategories}" />
                        </Style>
                    </DataGridComboBoxColumn.EditingElementStyle>
                </DataGridComboBoxColumn>
            </DataGrid.Columns>
        </DataGrid>

 

 
Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
18 mars 2014 2 18 /03 /mars /2014 21:19

Exemple avec un treeView je récupère le schéma d’une base de données Sql Server .

J’affiche le nom des tables et en nœuds enfants les noms de colonnes .Le "level2" correspond aux noeuds enfants.  
<TreeView ItemsSource="{Binding Database.Tables}" >
                    <TreeView.Resources>
                        <DataTemplate x:Key="level2">
                            <TextBlock Text="{Binding ColumnName}" />
                        </DataTemplate>
                    </TreeView.Resources>
 
                    <TreeView.ItemTemplate>
                        <HierarchicalDataTemplate ItemsSource="{Binding Columns}" ItemTemplate="{StaticResource level2}" >
                            <TextBlock Text="{Binding TableName}" />
                        </HierarchicalDataTemplate>
                    </TreeView.ItemTemplate>
</TreeView>

 

 

 

Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
1 mars 2014 6 01 /03 /mars /2014 12:34

1 – Ajout d’un dictionnaire de  ressources (Styles,DataTemplates,Brushes,Converters,Fonts,etc.)Exemple : Styles.xaml (ajouté dans un répertoire Ressources)



2 – Ajout d’un style
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 
    <Style x:Key="TextBoxInError"  TargetType="{x:Type TextBox}">
        <Style.Triggers>
            <Trigger Property="Validation.HasError" Value="true">
                <Setter Property="ToolTip" Value="{Binding (Validation.Errors)[0].ErrorContent, RelativeSource={RelativeSource Self}}"/>
            </Trigger>
        </Style.Triggers>
    </Style>
 
</ResourceDictionary>

 

Remarque : si je n’ajoute pas de clé au Style celui-ci sera automatiquement appliqué à toutes les textBox de l’application
  
3- App.xaml
<Application x:Class="MVVMMediatorDemo.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             StartupUri="MainWindow.xaml">
    <Application.Resources>
       
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="/DataTemplates/DataTemplates.xaml" />
                 <ResourceDictionary Source="/Ressources/Styles.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
       
    </Application.Resources>
</Application>

 

4- Utilisation du style
<TextBox Text="{Binding CurrentClient.Name, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" Style="{DynamicResource TextBoxInError}"/>

 

5- Plus loin          

 On peut aussi définir les ViewModels par exemple (App.xaml)

<Application x:Class="MVVMMediatorDemo.App"          
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             StartupUri="MainWindow.xaml"
             xmlns:vm="clr-namespace:MVVMMediatorDemo.ViewModels"
             >
    <Application.Resources>
       
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="/DataTemplates/DataTemplates.xaml" />
                <ResourceDictionary Source="/Ressources/Styles.xaml" />
            </ResourceDictionary.MergedDictionaries>
           
            <vm:ClientListViewModel x:Key="clientListViewModel"/>
           
        </ResourceDictionary>
    </Application.Resources> 
</Application>                    

 

 Puis définir le DataContext
<Window x:Class="MVVMMediatorDemo.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Views="clr-namespace:MVVMMediatorDemo.Views"
        Title="MainWindow" Height="300" Width="500">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="180"/>
            <ColumnDefinition />
        </Grid.ColumnDefinitions>
        <Views:ClientListView Grid.Column="0" DataContext="{DynamicResource clientListViewModel}" />
        <Views:ClientDetailsView  Grid.Column="1" />
    </Grid>
</Window>

 

Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
13 février 2014 4 13 /02 /février /2014 19:15

Xaml  


-          local correspond au namespace du projet (xmlns:local="clr-namespace:WpfDemoBinding")

Ressource (peut être définie pour la page, un conteneur ,un control)

  <Window.Resources>
        <local:Clients x:Key="clients"/>
    </Window.Resources>


Control

   <ListBox x:Name="lstClients" ItemsSource="{Binding Source={StaticResource clients}}"  >
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Horizontal">                       
                        <TextBlock Text="{Binding Name}" />
                        <TextBlock Text="{Binding Email}"  />
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>

 

C#
On créé une classe collection qui se charge depuis son constructeur
On pourrait tout aussi bien la charger depuis une base de données ou un fichier Xml
Pour bien faire il faudrait que la classe Client implémente INotifyPropertyChanged
public class Client
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public DateTime Birth { get; set; }
    }
    public class Clients : ObservableCollection<Client>
    {
        public Clients()
        {
            Add(new Client() { Name = "Bellin Marie", Email = "bellinmarie@live.com", Birth = new DateTime(1992,02,27) });
            Add(new Client() { Name = "Dupond Paul", Email = "dupondp123@yahoo.fr", Birth = new DateTime(1987, 01, 10) });
        }
    }

Cette manière de procéder permet de n’avoir aucun code behind dans la page.

Converter
Implémente IValueConverter
Value : valeur à convertir
[ValueConversion(typeof(DateTime), typeof(String))]
    public class DateConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return ((DateTime)value).ToShortDateString();
        }
 
        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            DateTime result;
            if (DateTime.TryParse(value.ToString(), out result))
                return result;
            return DependencyProperty.UnsetValue;
        }
    }

Xaml
On rajoute une ressource
<Window.Resources>
...
        <local:DateConverter x:Key="dateConverter"/>
    </Window.Resources>

On rajoute un textBlock à la listBox
<TextBlock Text="{Binding Path=Birth, Converter={StaticResource dateConverter}}"/>

 
Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
12 février 2014 3 12 /02 /février /2014 22:46

L’éditeur d’expressions personnalisées peut être une bonne aide pour définir ses liaisons de données facilement.

Exemple je vais définir l’ItemsSource de ma listBox avec l’éditeur

 

    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
 
            Cities = new List<string>() { "Londres", "Munich", "Berlin", "Rome" };
        }
        public List<string> Cities { get; set; }    
    }

 

Dans le panneau propriétés de ma listBox

 

 
 
 
 
Le Xaml est mis à jour

<ListBox x:Name="lstCities" ItemsSource="{Binding Cities, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type local:MainWindow}}}" />

 
Repost 0
Published by Romagny13 - dans Xaml
commenter cet article
4 février 2014 2 04 /02 /février /2014 15:51

1-Accéder à une ressource Xaml depuis le code C#

  <Window.Resources>

        <CollectionViewSource x:Key="citiesViewSource" />

    </Window.Resources>

    <Grid>

        <ListBox HorizontalAlignment="Left" Height="319" VerticalAlignment="Top" Width="517" ItemsSource="{Binding Source={StaticResource citiesViewSource}}"/>

    </Grid>

 

List<string> cities = new List<string>() { "Londres", "Berlin", "Lyon", "Dijon", "Madrid" };

 

CollectionViewSource citiesSource = (CollectionViewSource)this.FindResource("citiesViewSource");

citiesSource.Source = cities.ToList();

 

2-Trier    

Ne pas oublier d’ajouter à la page le namespace xmlns:scm="clr-namespace:System.ComponentModel;assembly=WindowsBase"    

<Window.Resources>

        <CollectionViewSource x:Key="citiesViewSource">

            <CollectionViewSource.SortDescriptions>

                <scm:SortDescription Direction="Ascending"/>

            </CollectionViewSource.SortDescriptions>

        </CollectionViewSource>

</Window.Resources>

    

Il est possible de spécifier sur quelle priopriété trier avec PropertyName  

Exemple : je trie un dictionnaire selon la valeur    

<scm:SortDescription PropertyName="Value" Direction="Ascending"/>

 

Repost 0
Published by Romagny13 - dans Xaml
commenter cet article