Discussion :

[Yogy]

Bonjour,
je cherche à mettre le resultat d'une requete LinQ dans un dataset, je suppose que c'est possible, peut etre avec un dataadapter mais je ne vois pas..
C'est pourquoi je viens ici chercher de l'aide

[Thomas Lebrun]

Ben, c'est pas vraiment fait pour.... Tu veux faire quoi exactement ?

[Yogy]

bah en fait je suis sur un mini projet en c# pour faire une appli donc en architecture n-tiers. Je voulais tester linq dans le cadre de ce projet.
A l'origine je transfert les données reccueillies par ma couche DAL avec des dataset vers la couche metier.
Mais avec linq je ne sais pas trop comment faire. Mes requetes retournent des données du type string,int,etc.. (NB: je me suis créé mon fichier Datacontext généré par VS2008).
De plus je m'étais fait une couche DAL en m'inspirant de ton tutoriel sur le développement en couche mais j'ai l'inpression qu'avec linq ça ne va pas me servir à grand chose?


De plus j'ai une question subsidiaire concernant ce projet. Comment acceder depuis ma couche métier aux infos fournie par mon interface. Par des parametres ?

[binoo]

Pour répondre à ta première question il y a bien une possibilité, mais j'avoue Linq perd un peu son sens.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
IDbCommand command = db.GetCommand(queryLinq);
command.Connection = monDataContext.Connection;
command.Connection.Open();
IDataReader reader = command.ExecuteReader(CommandBehavior.CloseConnection);

Tu obtient alors un DataReader

Mais encore une fois, et d'après ce que tu as dis, tu dois pouvoir t'en passer. Cette fois ci tu ne retourneras plus des DataSet mais un IEnumerable ou IQueryable.

Je pense que ta couche DAL, n'est pas superflue

[Yogy]

oui mais dans ma DAL il y a une phase de connexion, qui est gérée/générée par l'outil de VS non ?
Et comment on établi la datasource d'un datagridview avec un Enumerable ou IQueryable ?

[Yogy]

un pti up pour mon soucis car j'aimerais vraiment savoir/comprendre comment faire.. !

[binoo]

oui mais dans ma DAL il y a une phase de connexion, qui est gérée/générée par l'outil de VS non ?

En fait tu as fait ton mapping (manuellement ou par VS), ensuite il te reste à faire comme avant :

Pour reprendre le tutoriel sur le développement en couche "à la manière Linq", ça pourrait donner qqc ressemblant à ça (à confirmer par l'auteur du doc ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Data.Common;
using System.Data.Linq;
 
 
namespace MonProjet.DAL {
 
  public class SqlFactory {
 
    #region Paramètres
 
    // Paramètre pour la connexion à une base de données.
    private DbConnection m_SqlCnx = null;
    private DataContext m_SqlDataContext = null;
 
 
    private static object s_InstanceLocker = new object();
 
    private static SqlFactory m_SqlF;
    public static SqlFactory SqlF {
      get {
        lock( s_InstanceLocker ) {
          if( m_SqlF == null ) {
            m_SqlF = new SqlFactory();
          }
 
          return m_SqlF;
        }
      }
    }
 
    private ConnectionStringSettings m_CnxStringSettings;
    /// <summary>
    /// Obtient ou définit une chaîne de connexion dans le ficher de configuration
    /// </summary>
    public ConnectionStringSettings CnxStringSettings {
      get { return m_CnxStringSettings; }
      set { m_CnxStringSettings = value; }
    }
 
    #endregion
 
    #region GetSqlConnection()
 
    /// <summary>
    /// Fonction qui crée et ouvre une connexion en récupérant dans le fichier de configuration les 
    /// informations de la ConnectionString.
    /// </summary>
    /// <returns>Retourne le DataContext.</returns>
    public DataContext GetSqlConnection() {
      DbProviderFactory factory = DbProviderFactories.GetFactory( CnxStringSettings.ProviderName );
 
      if( m_SqlCnx == null ) {
        m_SqlCnx = factory.CreateConnection();
        m_SqlCnx.ConnectionString = CnxStringSettings.ConnectionString;
      }
 
      m_SqlDataContext = new DataClasses1DataContext( m_SqlCnx );
 
      if( m_SqlDataContext.Connection.State == System.Data.ConnectionState.Closed ) {
        m_SqlDataContext.Connection.Open();
      }
 
      return m_SqlDataContext;
    }
 
    #endregion
 
    #region CloseConnection()
 
    /// <summary>
    /// Fonction qui permet de fermer la connexion existante.
    /// </summary>
    public void CloseConnection() {
      if( this.m_SqlDataContext != null ) {
        if( this.m_SqlDataContext.Connection.State != System.Data.ConnectionState.Closed ) {
          this.m_SqlDataContext.Connection.Close();
        }
      }
    }
 
    #endregion
 
  }
 
}

Est-ce la manière la plus propre de faire (j'attends confirmation en fait )

comment on établi la datasource d'un datagridview avec un Enumerable ou IQueryable ?

Pour ma part je ne sais pas (sans parler de la méthode que j'ai cité auparavant qui le permet).

[gonnetsamuel]

Bonjour,

En fait j'ai ce besoin d'obtenir un dataset à partir de requêtes LINQ parce que je souhaite transmettre ce dataset comme source de données à un état Crystal Reports.
J'ai besoin d'un état qui se base sur trois tables différentes dont l'une est sur un datacontext différent de celui des deux autres tables (bases de données sur un même serveur mais sur deux bases différentes).
Dans les exemples que je trouve sur différentes sources, je ne vois jamais passer plusieurs requêtes Linq (ou Ienumerables) comme source de données pour un état. Un dataset fortement typé, par contre, ça passe bien.
Existe-t-il une solution pour transformer des requêtes provenant de Linq to SQL en Datatables pour les intégrer dans un dataset ?
Merci.

[nachtigal]

Bonjour,
Je vois que je ne suis pas seul à avoir séché sur le sujet, aussi je t'apporte un peu d'eau à ton moulin :
1. Disons que tu sais avoir un résultat avec LINQ sous forme d'un IEnumerable
2. Ajoute cette portion de code dans ta classe DAL en veillant au namespace ; je rappelle que cette classe n'est pas de moi et je ne me rappelle plus où je l'ai trouvée en hantant ce site :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
public static class ListExtensions
    {
        public static DataTable ToDataTable<T>(this IEnumerable<T> lst)
        {
            DataTable table = new DataTable();
 
            Type type = typeof(T);
 
            // Récupération des propriétés
            var properties = from p in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                             where p.GetIndexParameters().Length == 0 // pour exclure les indexeurs
                             && p.GetGetMethod() != null // pour exclure les propriétés write-only
                             select p;
 
            // Création des colonnes
            foreach (PropertyInfo prop in properties)
            {
                DataColumn column = new DataColumn(prop.Name, prop.PropertyType);
                column.ReadOnly = (prop.GetSetMethod() == null);
                table.Columns.Add(column);
            }
 
            // Copie des données
            foreach (T item in lst)
            {
                DataRow row = table.NewRow();
                foreach (PropertyInfo prop in properties)
                {
                    row[prop.Name] = prop.GetValue(item, null);
                }
                table.Rows.Add(row);
            }
 
            return table;
        }
 
        //usage:
        //List<Foo> list = new List<Foo>();
        //DataTable table = list.ToDataTable();
        //Vu que le paramètre est de type IEnumerable<T>, ça devrait aussi marcher pour 
        //n'importe quel type de collection, pas seulement List<T>
    }

Tu as donc maintenant la possibilité de générer et renvoyer un DataTable directement depuis ta requête LINQ.
3. Tu créés un DataSet vide et tu y ajoute ton ou tes DataTable.

Il est donc mieux de créer un DataSet 'à la main' qui servira à générer ton état Crystal Reports, tu y crée les différents DataTable dont tu auras besoin ; de l'autre coté ton DAL va collecter les données dans différents DataTable que tu mets dans un unique DataSet à passer à ton état. Il faut juste faire attention à avoir les mêmes noms et types de données partout !
Tes données pourraient provenir de MySQL pour certaines, d'autres de ORACLE, etc, tu assembles tout cela dans un DataSet et Crystal n'y trouveras rien à redire. En clair le DataSet qui alimente ton état n'est pas connecté à une source de données, mais reçoit ses données en run-time par ton DataSet de structure similaire, créé et gavé par toi.
En espérant d'avoir un peu aidé.
nachtigal.