Overblog Suivre ce blog
Editer l'article 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

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;
        }
    }

Partager cet article

Repost 0
Published by Romagny13 - dans C
commenter cet article

commentaires