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

11 avril 2014 5 11 /04 /avril /2014 17:11

http://json.codeplex.com/

 

http://james.newtonking.com/json/help/index.html

 

 

Avec JSon.NET

  public void SerializeJSonClient(Client client)

        {

            JsonSerializer serializer = new JsonSerializer();

            serializer.NullValueHandling = NullValueHandling.Ignore;

 

            using (StreamWriter streamWriter = new StreamWriter("json.txt"))

            {

                using (JsonWriter jsonWriter = new JsonTextWriter(streamWriter))

                {

                    serializer.Serialize(jsonWriter, client);

                }

            }

        }

        public Client DeserializeJSonClient(string path)

        {

            using (StreamReader streamReader = new StreamReader(path))

            {

                string value =  streamReader.ReadToEnd();

                return JsonConvert.DeserializeObject<Client>(value);

            }

        }

Classe générique avec  DataContractJsonSerializer

public class JsonGenericSerializer<TEntity> where TEntity : class,new()

    {

        public static void WriteFile(TEntity entity,string path)

        {

            using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))

            {

                DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(TEntity));

                serializer.WriteObject(stream, entity);

            }

        }

        public static TEntity ReadFile(string path)

        {

            using (FileStream stream = new FileStream(path, FileMode.Open))

            {

                DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(TEntity));

                StreamReader streamReader = new StreamReader(stream);

                return (TEntity)serializer.ReadObject(stream);

            }

        }

    }

La classe de l’exemple (les paramètres permettent de redéfinir notamment les noms)

  [DataContract(Name="Client")]

    public class Client 

    {

        [DataMember(Name="Id")]

        public int ClientID { get; set; }

        [DataMember(Name = "FirstName")]

        public string ClientFirstName { get; set; }

        [DataMember(Name = "LastName")]

        public string ClientLastName { get; set; }

        [DataMember(Name = "Email")]

        public string Email { get; set; }

    }

Utilisation

Client client=new Client(){ClientID=1,ClientFirstName="Marie",ClientLastName="Bellin",Email="bellinmarie@live.com"};

//   SerializeJSonClient(client);

JsonGenericSerializer<Client>.WriteFile(client,"demo.txt");

 

 

// Client result = DeserializeJSonClient("json.txt");

Client result = JsonGenericSerializer<Client>.ReadFile("demo.txt");

 

 

Le fichier généré

{"Email":"bellinmarie@live.com","FirstName":"Marie","Id":1,"LastName":"Bellin"}

Repost 0
Published by Romagny13 - dans C
commenter cet article
11 avril 2014 5 11 /04 /avril /2014 17:11

Il est conseillé de préférer l’utilisation des méthodes asynchrones pour des UI réactives.

Une tâche ne renvoyant pas de résultat : on emploie juste le mot « Task »
Pour une tâche renvoyant un résultat : on emploie « Task<T> » (T étant le type de retour , par exemple string)
Exemple de tâche ne renvoyant pas de résultat (écrit un fichier de manière asynchrone)
public async Task CreateAndWriteAsyncToFile()
        {
            using (FileStream stream = new FileStream("test.dat", FileMode.Create,
                FileAccess.Write, FileShare.None, 4096, true))
            {
                byte[] data = new byte[100000];
                new Random().NextBytes(data);
                await stream.WriteAsync(data, 0, data.Length);
            }
        }
Utilisation
  private async void button1_Click(object sender, EventArgs e)
        {
          await CreateAndWriteAsyncToFile ();
        } 
Exemple de tâche renvoyant un résultat
        private async void btWriteFile_Click(object sender, EventArgs e)
        {
          string response = await GetHttpClientStringAsync("http://www.microsoft.com");
        }
        public async Task<string> GetHttpClientStringAsync(string path)
        {
            HttpClient client = new HttpClient();
            return await client.GetStringAsync(path);
        }
Gestion Erreur + annulation de la tâche
  public static void Main()
        {
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            CancellationToken token = cancellationTokenSource.Token;
            Task task = Task.Run(() =>
            {
                while (!token.IsCancellationRequested)
                {
                    Console.Write("*");
                    Thread.Sleep(1000);
                }
                // simule une erreur 
                //token.ThrowIfCancellationRequested();  
            }, token);
            try 
            {
                Console.WriteLine("Press enter to stop the task");
                Console.ReadLine();
                cancellationTokenSource.Cancel();
                task.Wait();
            }
            catch (AggregateException e)
            {
                Console.WriteLine(e.InnerExceptions[0].Message);
            }
            Console.WriteLine("Press enter to end the application");
            Console.ReadLine();
        }
Tâches multiples
public async Task ExecuteMultipleRequests()
        {
            HttpClient client = new HttpClient();
            string microsoft = await client.GetStringAsync("http://www.microsoft.com");
            string msdn = await client.GetStringAsync("http://msdn.microsoft.com");
            string blogs = await client.GetStringAsync("http://blogs.msdn.com/");
            //On pourrait afficher le résultat par exemple : rtb.AppendText(microsoft); 
        }
 L’inconvénient ici est qu’il va falloir attendre que les 3 tâches soient exécutées .En exécutant ces tâches de façon parallèle (avec WhenAll) il n’y a qu’à attendre que la plus longue des tâches soit finie
Parallèle
  public async Task ExecuteMultipleRequestsInParallel()
        {
            HttpClient client = new HttpClient();
            Task microsoft = client.GetStringAsync("http://www.microsoft.com");
            Task msdn = client.GetStringAsync("http://msdn.microsoft.com");
            Task blogs = client.GetStringAsync("http://blogs.msdn.com/");
            await Task.WhenAll(microsoft, msdn, blogs);
        }
Données – Lecture et mise à jour asynchrones
    private async void btReadData_Click(object sender, EventArgs e)
        {
            List<Client> clients = await GetAllClientsAsync();
            dataGridView1.DataSource = clients;
            // mise à jour 
            int result = await DeleteClientAsync(1978);
        }
      
        public async Task<List<Client>> GetAllClientsAsync()
        {
            List<Client> result = new List<Client>();
            using (DbConnection connection = GetConnection())
            {
                using (DbCommand command = connection.CreateCommand())
                {
                    command.CommandText = "SELECT [Id],[Name],[Email] FROM [dbo].[Client]";
                    await connection.OpenAsync();
                    using (DbDataReader reader = await command.ExecuteReaderAsync())
                    {
                        while (await reader.ReadAsync())
                        {
                            Client client = new Client();
                            client.ClientID = reader["Id"] == DBNull.Value ? default(int) : int.Parse(reader["Id"].ToString());
                            client.ClientName = reader["Name"] == DBNull.Value ? default(string) : reader["Name"].ToString();
                            client.Email = reader["Email"] == DBNull.Value ? default(string) : reader["Email"].ToString();
                            result.Add(client);
                        }
                    }
                }
            }
            return result;
        }
        public async Task<int> DeleteClientAsync(int id)
        {
            int result = 0;
            using (DbConnection connection = GetConnection())
            {
                using (DbCommand command = connection.CreateCommand())
                {
                    command.CommandText = "Delete from [dbo].[Client] where id=@id";
                    command.Parameters.Add(CreateParameter(command, "@id",id));
                    await connection.OpenAsync();
                    result = await command.ExecuteNonQueryAsync();
                }
            }
            return result;
        }
        // Méthodes d'aide 
        public DbConnection GetConnection()
        {
            ConnectionStringSettings csSection = ConfigurationManager.ConnectionStrings["defaultConnectionString"];
            DbConnection connection = DbProviderFactories.GetFactory(csSection.ProviderName).CreateConnection();
            connection.ConnectionString = csSection.ConnectionString;
            return connection;
        }
        public DbParameter CreateParameter(DbCommand command, string parameterName, object value)
        {
            DbParameter parameter = command.CreateParameter();
            parameter.ParameterName = parameterName;
            parameter.Value = value;
            return parameter;
        }
A noter que je pourrais aussi créer des méthodes d’extension .Exemple
public static class DbCommandExtensions 
    {
        public static DbParameter CreateParameter(this DbCommand command, string parameterName, object value)
        {
            DbParameter parameter = command.CreateParameter();
            parameter.ParameterName = parameterName;
            parameter.Value = value;
            return parameter;
        }
    }
Repost 0
Published by Romagny13 - dans C
commenter cet article
9 avril 2014 3 09 /04 /avril /2014 02:04

Gestionnaire de configurations > plateforme > x86 (ou x64)

 

Puis dans le gestionnaire de paquets NuGet :

  • chercher  SQLite for Windows Runtime
  •   puis SQLite.net

 

 

On peut créer la base et les tables en mode « Code First » un peu de la même manière qu’avec Entity Framework

(SQLite ne prend pas en charge les clés étrangères)


using SQLite ;


La classe métier qui sert de « schéma » pour la table .J’implémente INotifyPropertyChanged pour le binding


Les attributs appartiennent à l’espace de noms SQLite .Les attributs disponibles sont : 

  • TableAttribute 
  • ColumnAttribute 
  • PrimaryKeyAttribute 
  • AutoIncrementAttribute : colonne de clé primaire auto incrémentée. 
  • IndexedAttribute : colonne avec un index 
  • IgnoreAttribute : colonne ignorée lors de la création de la table 
  • UniqueAttribute : colonne avec valeurs uniques 
  • MaxLengthAttribute : taille maximale de la donnée d’une colonne 
  • CollationAttribute

 

Model

[Table("Client")]

    public class Client : ObservedBase

    {

 

        private int _clientID;

 

        [PrimaryKey]

        [AutoIncrement]

        [Column("ClientID")]

        public int ClientID

        {

            get { return _clientID; }

            set

            {

                _clientID = value;

                RaisePropertyChanged<int>(() => ClientID);

            }

        }

 

        private string _clientFullName;

 

        [MaxLength(100)]

        [Column("ClientFullName")]

        public string ClientFullName

        {

            get { return _clientFullName; }

            set

            {

                _clientFullName = value;

                RaisePropertyChanged<string>(() => ClientFullName);

            }

        }

 

        private string _email;

 

        [Column("Email")]

        public string Email

        {

            get { return _email; }

            set

            {

                _email = value;

                RaisePropertyChanged<string>(() => Email);

            }

        }

    }

 

ObservedBase

  public class ObservedBase :

        INotifyPropertyChanged

    {

        public ObservedBase() { }

 

        #region INotifyPropertyChanged Members

 

        public event PropertyChangedEventHandler PropertyChanged;

 

        protected void RaisePropertyChanged<T>(Expression<Func<T>> expression)

        {

 

            var memberExpression = expression.Body as MemberExpression;

            if (memberExpression != null)

            {

                string propertyName = memberExpression.Member.Name;

                RaisePropertyChanged(propertyName);

            }

        }

 

        private void RaisePropertyChanged(String propertyName)

        {

            PropertyChangedEventHandler handler = PropertyChanged;

            if (handler != null)

                handler(this, new PropertyChangedEventArgs(propertyName));

 

        }

 

        #endregion

    }

 

 

Dans Une classe ClientService implémentant une interface IClientService pour structurer un minimum son code .

Créer une base :la base est automatiquement crée dans le répertoire cible si elle n’existe pas .Il est conseillé d’appeler cette méthode le plus tôt possible (dès OnLaunched dans App.xaml.cs)

       private SQLiteAsyncConnection connection;

 

        public void GetConnection()

        {

            string path = Path.Combine(ApplicationData.Current.LocalFolder.Path, "dbDemo.sqlite");

            connection = new SQLiteAsyncConnection(path);

        }

 

Créer une table : on utilise la méthode CreateTableAsync<T>()  .Il existe également une méthode CreateTablesAsync() (pour supprimer une table on peut utiliser DropTableAsync<T>())

        public async Task CreateTableAsync()

        {

            await connection.CreateTableAsync<Client>();

        }

 

Récupérer les lignes

        public async Task<IList<Client>> GetAll()

        {

            return await connection.Table<Client>().ToListAsync();

        }

 

Récupérer un élément

public async Task<Client> GetOne()

        {

            GetConnection();

            return await connection.Table<Client>().FirstOrDefaultAsync();

        }

 

Insérer un ou plusieurs éléments

        public async Task AddClientsAsync()

        {

            List<Client> clients = new List<Client>(){ new Client(){ClientFullName="Bellin, Marie",Email="bellinmarie@live.com"},

                                                       new Client(){ClientFullName="Adams, Terry",Email="adams156@live.com"}

            };

 

            // await connexion.InsertAsync(client); // pour insérer un élément

            await connection.InsertAllAsync(clients); // pour insérer une collection

        }

 

Modifier un élément (il existe aussi UpdateAllAsync)

  public async Task<int> Remove(Client client)

        {

            GetConnection();

            return await connection.UpdateAsync(client);

        }

 

Supprimer un élément

        public async Task<int> Remove(Client client)

        {

            GetConnection();

            return await connection.DeleteAsync(client);

        }

 

 

Le code du ViewModel

public class ClientListViewModel :ObservedBase

    {

        private ObservableCollection<Client> _clients;

 

        public ObservableCollection<Client> Clients

        {

            get { return _clients; }

            set

            {

                _clients = value;

                RaisePropertyChanged<ObservableCollection<Client>>(() => Clients);

            }

        }

 

        private IClientService clientService;

 

        public ClientListViewModel()

        {

            clientService = new ClientService();

            GetItems();

        }

 

        public async void GetItems()

        {

            Clients = new ObservableCollection<Client>(await clientService.GetAll());

        } 

    }

 

Et MainPage

  <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> 

        <GridView ItemsSource="{Binding Clients}" HorizontalAlignment="Stretch" VerticalAlignment="Stretch">

            <GridView.ItemTemplate>

                <DataTemplate>

                    <StackPanel Orientation="Horizontal">

                        <TextBlock Text="{Binding ClientID}" Width="100"/>

                        <TextBox Text="{Binding ClientFullName}" Width="150"/>

                        <TextBox Text="{Binding Email}" Width="200" />

                    </StackPanel>

                </DataTemplate>

            </GridView.ItemTemplate>

        </GridView>

    </Grid>

 

Dans le code behind simplement

this.DataContext = new ClientListViewModel();


 

sqliws1

Repost 0
Published by Romagny13 - dans WinRT
commenter cet article
8 avril 2014 2 08 /04 /avril /2014 01:17

SQLite Admin

http://sqliteadmin.orbmu2k.de/

SQLite Browser

http://sourceforge.net/projects/sqlitebrowser/

SQLite est un SGBR embarqué « léger » (ne supporte pas les clés étrangères).

Pour WinRT rechercher SQLite for Windows Runtime  sinon seulement SQLite dans les packagesNuGet

  

Il est possible de créer ses bases et tables un peu comme EDM en « code first » également

Exemple : crée la base si elle n’existe pas

SQLiteConnection connection = new SQLiteConnection(@"Data Source=C:\dbDemo.sqlite;");

connection.Open();

Il est possible de passer par DbConnection,DbCommand,etc. 

Avec WinRT On utilisera  SQLiteAsyncConnection et la méthode CreateTableAsync<T>() de la connexion .

Repost 0
Published by Romagny13 - dans WinRT
commenter cet article
7 avril 2014 1 07 /04 /avril /2014 18:10

Facebook

  • Créer une application (Menu « Applications » > « Créer une application »)
  • Donner un nom à l’application (Display Name), le Namespace est optionnel
  • Il faut ensuite aller dans les paramètres « Ajouter une plateforme », entrer l’url de son site web (ou mobile)
  • Penser à relever  l’identifiant de l’application et la clé secrète qui seront à fournir dans le code.

 

 AuthConfig (dossier App_Start) méthode RegisterAuth()  

 OAuthWebSecurity.RegisterFacebookClient(appId: "1405131279758787", appSecret: "29d241112484c2fe570b154b2680a206");  

 

Twitter
 https://dev.twitter.com/ 
Marche de la même manière que Facebook

 

Google
Rien de particulier à faire ici à part dans AuthConfig retirer les commentaires
OAuthWebSecurity.RegisterGoogleClient();

 

 

Yahoo
OAuthWebSecurity.RegisterYahooClient();

 

 
 
 
Repost 0
Published by Romagny13 - dans ASP.NET MVC
commenter cet article
7 avril 2014 1 07 /04 /avril /2014 14:52

  
Je définis un UserControl simple pour lequel j’ai une propriété texte (d’un TextBlock)  avec laquelle je veux pouvoir intéragir depuis la page principale.

 

Le userControl Silverlight nommé « bubble.xaml »
<Grid x:Name="LayoutRoot" >
        <Ellipse HorizontalAlignment="Left" VerticalAlignment="Top" 
                 Height="150" Width="150"
                 Fill="SkyBlue" Stroke="White" StrokeLineJoin="Round"  />
        <TextBlock x:Name="tb" Foreground="White"  HorizontalAlignment="Center" VerticalAlignment="Center"  />
    </Grid>

 

Dans le code behind du userControl
Le Dependency est déclaré Readonly et static . On définit :
Le nom de la propriété de dépendance à inscrire (ici SetText)
Le type de cette propriété (ici string)
Le type du propriétaire qui inscrit la propriété de dépendance (ici le userControl « Bubble »)
Metadata, pouvant contenir un PropertyChangedCallback (qui pointe ici sur SetNewText,  static avec en premier argument le DependencyObject, en second argument le DependencyPropertyChangedEventArgs)
public partial class Bubble : UserControl
    {
        public Bubble()
        {
            InitializeComponent();
        }
 
        public static readonly DependencyProperty SetTextBoxProperty =
            DependencyProperty.Register("SetText", typeof(string), typeof(Bubble),
            new PropertyMetadata(new PropertyChangedCallback(SetNewText)));
       
        // property accessible
        public string SetText
        {
            get { return (string)GetValue(SetTextBoxProperty); }
            set { SetValue(SetTextBoxProperty, value); }
        }
 
        private static void SetNewText(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            (d as Bubble).tb.Text = e.NewValue.ToString();
        }
    }

 

MainPage.xaml 
J’ai accès à ma propriété SetText dans le Xaml
  <Grid x:Name="LayoutRoot" Background="White">
        <View:Bubble x:Name="bubble1" SetText="Coucou !" HorizontalAlignment="Left" Margin="155,22,0,0" VerticalAlignment="Top"/>
 
    </Grid>

 

      En C# dans le code behind  

   bubble1.SetText = "Coucou !";
Repost 0
Published by Romagny13 - dans Silverlight
commenter cet article
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
4 avril 2014 5 04 /04 /avril /2014 22:18

13 Ressources :
a-Créer une nouvelle ressource
Sélectionner l’élément à transformer en ressource > Panneau « Propriétés » Convertir en nouvelle  ressource …

Note : On peut créer un dossier « Ressources » puis un dictionnaire de ressources (panneau « Projets ») si on veut mieux organiser son code .


    blend32b.png

(Le dictionnaire de ressources et le code de la page sont mis à jour)

b-Utiliser une ressource
Panneau « Propriétés » > Ressource Locale


c-Accéder/Modifier aux ressources

Panneau « Ressources »

14-Style

a-Créer un style
Modifier le Style > Créer un élément vide …

Définir le style de l’élément

 

b-Utiliser un Style
Sur un control auquel le style peut être appliqué …

 

 

C – Accèder/Modifier un Style

Depuis le panneau ressources  
 

15- Template

 
1 Définir le Template
sur l'élément ...Modifier le modèle > Créer un élément vide
 
2 les VisualState pour les diffirents états(Panneau « Etats »)
Exemple pour un bouton on redéfinit son template (border avec coins arrondis,...)qui correspond en fait à l’état Normal,puis on défnit l’apparence pour les états MouseOver,Pressed

 

 

16-Exemple de Données avec Blend

Ajouter une source de données
Il est possible de définir le type de données (nombre,chaine,booléen,etc.) ,le format(Nom,adresse électronique,etc.)

 

 
On peut vérifier le résultat avec des exemples de valeurs

 
(Les fichiers sont générés)
     blend32.png 
Il suffit ensuite de créer une liaison de données à partir du contrôle

Exemple sur un Datagrid > clic droit >  Créer une liaison de données pour l’ItemsSource .

Il est possible de définir précisément les éléments à Binder
Repost 0
Published by Romagny13 - dans Blend
commenter cet article
4 avril 2014 5 04 /04 /avril /2014 22:17

9-Transformations
blend5.png

Déplacer selon X et Y
Rotation selon un angle
Redimensionner selon X et Y
Incliner selon X et Y
Symétrie
RenderTransform et LayoutTransform(conteneur parent)
 
Dans le code ...
RotateTransform Rotation par un angle
ScaleTransform  Redimensionnement d’un objet selon ScaleX et ScaleY  
SkewTransform Transformation « oblique » selon AngleX et AngleY
TranslateTransform déplacement d’un point à un autre selon X  et Y
 

 

10- Animations

On crée un « StoryBoard »  (afin d’avoir une timeline)
Panneau « Objets et Chronologie » (menu « Fenêtres »)
blend6.png
 
 
 
 Il suffit ensuite de définir son animation/transformations sur la timeline
  
blend7.png
  
Propriétés du StoryBoard

blend10.png

F5 pour exécuter l’application ou simplement bouton « lecture » avec la timeline .

11 – Comportements/Behaviors

On crée d’abord une animation/un état que l’on déclenche ensuite grâce à un behavior
 
CallMethodAction
ChangePropertyAction Change une propriété
ControlStoryboardAction Contrôle le StoryBoard
GoToStateAction Change d'état
HyperlinkAction Navigation vers un site au clic sur le lien
InvokeCommandAction invocation d'une commande
PlaySoundAction
RemoveElementAction supprime un élément
  • ControlStoryBoardAction
Glisser /Déposer le comportement
blend8.png

 

Je montre des exemples de code (sachant que tout peut se faire de manière transparente grâce aux différents panneaux) .
Exemple au chargement de l'application
les namespaces
xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
 xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions" 
       <i:Interaction.Triggers>
                    <i:EventTrigger EventName="Loaded">
                           <ei:ControlStoryboardAction Storyboard="{StaticResource Storyboard1}"/>
                    </i:EventTrigger>
             </i:Interaction.Triggers>

 

Il est possible de changer les propriétés du Trigger grâce à Blend

blend9.png
Exemple lorsqu’on change pour que l’animation se déclenche à MouseEnter sur une image désirée
<i:Interaction.Triggers>
                    <i:EventTrigger EventName="MouseEnter" SourceName="image">
                           <ei:ControlStoryboardAction Storyboard="{StaticResource Storyboard1}"/>
                    </i:EventTrigger>
             </i:Interaction.Triggers>

 

On peut aussi ajouter un Trigger pour arrêter l’animation
<i:Interaction.Triggers>
                    <i:EventTrigger EventName="MouseEnter" SourceName="image">
                           <ei:ControlStoryboardAction Storyboard="{StaticResource Storyboard1}"/>
                    </i:EventTrigger>
                    <i:EventTrigger EventName="MouseLeave" SourceName="image">
                           <ei:ControlStoryboardAction ControlStoryboardOption="Stop" Storyboard="{StaticResource Storyboard1}"/>
                    </i:EventTrigger>
             </i:Interaction.Triggers>

 

 

 

  • ChangePropertyAction
Exemple : je change la taille d'une image (propriété Height) au clic gauche de la souris dessus
En code cela donne
       <i:EventTrigger EventName="MouseLeftButtonDown" SourceName="image">
                           <ei:ChangePropertyAction TargetName="image" PropertyName="Height" Value="200"/>
                    </i:EventTrigger>
             </i:Interaction.Triggers>

 

12-VisualState

  • On ajoute les états et définit ceux ci
  • Puis on fait glisser un behavior GoToStateAction
  • enfin on définit les propriétés du behavior

 

Ajouter des états .Panneau « Etats »
blend11.png
Exemple simple:
Je crée un état normal et un état ou le background est noir + un bouton qui permet de passer à l’état « black » au clic .
Cela donne en code
<Window
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
       xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity" xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions"
       x:Class="ButtonWithStates.Window3"
       x:Name="Window"
       Title="Window3"
       Width="640" Height="480">
 
       <Grid x:Name="LayoutRoot">
             <VisualStateManager.VisualStateGroups>
                    <VisualStateGroup x:Name="VisualStateGroup">
                           <VisualState x:Name="Normal"/>
                           <VisualState x:Name="Black">
                                  <Storyboard>
                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetProperty="(Panel.Background)" Storyboard.TargetName="LayoutRoot">
                                               <DiscreteObjectKeyFrame KeyTime="0">
                                                      <DiscreteObjectKeyFrame.Value>
                                                            <SolidColorBrush Color="Black"/>
                                                      </DiscreteObjectKeyFrame.Value>
                                               </DiscreteObjectKeyFrame>
                                        </ObjectAnimationUsingKeyFrames>
                                  </Storyboard>
                           </VisualState>
                    </VisualStateGroup>
             </VisualStateManager.VisualStateGroups>
             <i:Interaction.Triggers>
                    <i:EventTrigger EventName="Click" SourceName="btGoToBlackState">
                           <ei:GoToStateAction StateName="Black"/>
                    </i:EventTrigger>
             </i:Interaction.Triggers>
             <Button x:Name="btGoToBlackState" Content="button" HorizontalAlignment="Left" Height="75" Margin="20,40,0,0" VerticalAlignment="Top" Width="115"/>
       </Grid>
</Window>
Repost 0
Published by Romagny13 - dans Blend
commenter cet article