Comment faire pour remplir le Dataset avec plusieurs tables?

Je suis en train de remplir un DataSet qui contient 2 tables avec un à plusieurs " de la relation.
Je suis l'aide de l'objet DataReader pour y parvenir :

    public DataSet SelectOne(int id)
    {
        DataSet result = new DataSet();
        using (DbCommand command = Connection.CreateCommand())
        {
            command.CommandText = "select * from table1";

            var param = ParametersBuilder.CreateByKey(command, "ID", id, null);
            command.Parameters.Add(param);

            Connection.Open();
            using (DbDataReader reader = command.ExecuteReader())
            {
                result.MainTable.Load(reader);
            }
            Connection.Close();
        }
        return result;
    }

Mais j'ai seulement un tableau rempli. Comment puis-je atteindre mon objectif - remplir les deux tableaux?

Je voudrais utiliser l'objet DataReader au lieu DataAdapter, si, c'est possible.

Pourquoi vous vous attendriez à ce que les deux tables sont remplies? Votre commande ne contient qu'un seul select énoncé qui renvoie un tableau unique.
Pourquoi ne pas utiliser un SqlDataAdapter et ses Fill(...) méthode au lieu de la DbCommand?
Anusev - je le sais, je suis juste en demandant à tout type de suggestion
preformanse. DataReader est rapide, DataAdapter est plus lent. Ce qui est essentiel dans mon cas
Le DataAdapter utilise également un DataReader sous le capot. stackoverflow.com/a/334667/284240 Le seul avantage d'un lecteur vous permet de lire les enregistrements un à un moment au lieu de charger tous en mémoire.

OriginalL'auteur Andriy Zak | 2012-07-05

ado.net c#datareader dataset sql

Si vous émettez une commande unique avec plusieurs instructions select, vous pouvez utiliser NextResult méthode pour atteindre le prochain jeu de résultats dans le datareader: http://msdn.microsoft.com/en-us/library/system.data.idatareader.nextresult.aspx

Je montre comment il pourrait ressembler à ci-dessous:

public DataSet SelectOne(int id)
{
    DataSet result = new DataSet();
    using (DbCommand command = Connection.CreateCommand())
    {
        command.CommandText = @"
select * from table1
select * from table2
        ";

        var param = ParametersBuilder.CreateByKey(command, "ID", id, null);
        command.Parameters.Add(param);

        Connection.Open();
        using (DbDataReader reader = command.ExecuteReader())
        {
            result.MainTable.Load(reader);
            reader.NextResult();
            result.SecondTable.Load(reader);
            //...
        }
        Connection.Close();
    }
    return result;
}

Il vous suffit de faire result.Load(reader). Le Load méthode permettra de gérer de multiples résultats.
vrai, mais dont le tableau à remplir avec qui jeu de résultats ne peut pas être spécifié avec un jeu de données.De la charge, il va se casser si vous définissez des tables dans un autre ordre. Vous devez aussi état d'autres paramètres.
vous m'avez fait sourire aujourd'hui.

OriginalL'auteur smoothdeveloper

25

Le remplissage d'un jeu de données avec plusieurs tables peut être fait par l'envoi de plusieurs requêtes à la base de données, ou de manière plus rapide: SÉLECTIONNEZ Plusieurs états peuvent être envoyées vers le serveur de base de données en une seule requête. Le problème ici est que les tables générées à partir des requêtes automatiques noms de Table et de Table1. Cependant, à la génération de noms de table, peuvent être mappées à des noms qui devraient être utilisés dans le jeu de données.
```
SqlDataAdapter adapter = new SqlDataAdapter(
      "SELECT * FROM Customers; SELECT * FROM Orders", connection);
adapter.TableMappings.Add("Table", "Customer");
adapter.TableMappings.Add("Table1", "Order");

adapter.Fill(ds);
```
Merci pour la réponse, mais d'après ma tâche - je besoin pour utiliser l'objet DataReader au lieu DataAdapter : qui a été décrit dans ma question
avec l'ajout de TableMappings.Ajouter n'est pas neccassarry

OriginalL'auteur Mohsen Safari

C'est un vieux sujet, mais pour certaines personnes, il pourrait être utile:

        DataSet someDataSet = new DataSet();
        SqlDataAdapter adapt = new SqlDataAdapter();

        using(SqlConnection connection = new SqlConnection(ConnString))
        {
            connection.Open();
            SqlCommand comm1 = new SqlCommand("SELECT * FROM whateverTable", connection);
            SqlCommand comm2g = new SqlCommand("SELECT * FROM whateverTable WHERE condition = @0", connection);
            commProcessing.Parameters.AddWithValue("@0", "value");
            someDataSet.Tables.Add("Table1");
            someDataSet.Tables.Add("Table2");

            adapt.SelectCommand = comm1;
            adapt.Fill(someDataSet.Tables["Table1"]);
            adapt.SelectCommand = comm2;
            adapt.Fill(someDataSet.Tables["Table2"]);
        }

comment gérer cette situation, si sql(magasin de proc) le renvoi de plusieurs tables?
Au lieu de faire adapt.Fill(someDataSet.Tables["Table1"]) vous ne adapt.Fill(someDataSet). Parce que bien sûr, votre procédure stockée retruns les tables, mais seulement si il retourne vraiment des TABLES et non pas un ensemble de COLONNES à partir de plusieurs tables.
Merci pour la réponse, vais essayer ce truc 🙂

OriginalL'auteur CularBytes

3

Ici est très bonne réponse de votre question

voir l'exemple mentionné ci-dessus page MSDN :-

OriginalL'auteur Pranav

protected void Page_Load(object sender, EventArgs e)
{
    SqlConnection con = new SqlConnection("data source=.;uid=sa;pwd=123;database=shop");
    //SqlCommand cmd = new SqlCommand("select * from tblemployees", con);
    //SqlCommand cmd1 = new SqlCommand("select * from tblproducts", con);
    //SqlDataAdapter da = new SqlDataAdapter();

    //DataSet ds = new DataSet();
    //ds.Tables.Add("emp");
    //ds.Tables.Add("products");
    //da.SelectCommand = cmd;
    //da.Fill(ds.Tables["emp"]);
    //da.SelectCommand = cmd1;

    //da.Fill(ds.Tables["products"]);
    SqlDataAdapter da = new SqlDataAdapter("select * from tblemployees", con);
    DataSet ds = new DataSet();
    da.Fill(ds, "em");
    da = new SqlDataAdapter("select * from tblproducts", con);
    da.Fill(ds, "prod");

    GridView1.DataSource = ds.Tables["em"];
    GridView1.DataBind();
    GridView2.DataSource = ds.Tables["prod"];
    GridView2.DataBind();
}

S'il vous plaît, ajouter quelques explications.

OriginalL'auteur user5311866

         string connetionString = null;
SqlConnection connection ;
SqlCommand command ;
SqlDataAdapter adapter = new SqlDataAdapter();
DataSet ds = new DataSet();
int i = 0;
string firstSql = null;
string secondSql = null;
connetionString = "Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserName;Password=Password";
firstSql = "Your First SQL Statement Here";
secondSql = "Your Second SQL Statement Here";
connection = new SqlConnection(connetionString);
try
{
connection.Open();
command = new SqlCommand(firstSql, connection);
adapter.SelectCommand = command;
adapter.Fill(ds, "First Table");
adapter.SelectCommand.CommandText = secondSql;
adapter.Fill(ds, "Second Table");
adapter.Dispose();
command.Dispose();
connection.Close();
//retrieve first table data 
for (i = 0; i <= ds.Tables[0].Rows.Count - 1; i++)
{
MessageBox.Show(ds.Tables[0].Rows[i].ItemArray[0] + " -- " + ds.Tables[0].Rows[i].ItemArray[1]);
}
//retrieve second table data 
for (i = 0; i <= ds.Tables[1].Rows.Count - 1; i++)
{
MessageBox.Show(ds.Tables[1].Rows[i].ItemArray[0] + " -- " + ds.Tables[1].Rows[i].ItemArray[1]);
}
}
catch (Exception ex)
{
MessageBox.Show("Can not open connection ! ");
}

OriginalL'auteur Mitesh Gadhiya

public DataSet GetDataSet()
{
try
{
DataSet dsReturn = new DataSet();
using (SqlConnection myConnection = new SqlConnection(Core.con))
{
string query = "select * from table1;  select* from table2";
SqlCommand cmd = new SqlCommand(query, myConnection);
myConnection.Open();
SqlDataReader reader = cmd.ExecuteReader();
dsReturn.Load(reader, LoadOption.PreserveChanges, new string[] { "tableOne", "tableTwo" });
return dsReturn;
}
}
catch (Exception)
{
throw;
}
}

OriginalL'auteur Kashif Faraz

0

Méthode Load de DataTable exécute NextResult sur le DataReader, de sorte que vous ne devez pas appeler NextResult explicetly lors de l'utilisation de Load, sinon même les tables peuvent être perdues.

Ici est une solution générique pour charger plusieurs tables à l'aide d'un DataReader.
```
//your command initialization code here
//...
DataSet ds = new DataSet();
DataTable t;
using (DbDataReader reader = command.ExecuteReader())
{
while (!reader.IsClosed)
{
t = new DataTable();
t.Load(rs);
ds.Tables.Add(t);
}
}
```
OriginalL'auteur Mario Vázquez

Vous devez vous connecter pour publier un commentaire.