C# jeu de données sql questions

Question

Ce que j'ai en cours est une liste d'ID (nc.txt) et une liste de colonnes (listbox1). J'essaie d'exporter à partir de SQL toutes les données de la liste des ID qui correspondent à la liste des colonnes. Je suis sûr que je n'ai pas l'ensemble de données correct. Toute aide aprpiquée.

mise à jour: chaîne de contenu = File.ReadAllText (textBox3.Text);

  string id = id = Regex.Match(contents, @"CoreDBCaseID=(?<id>\d+)").Groups["id"].Value; 
      string server = server = Regex.Match(contents, @"Server=(?<Server>[^;]+)").Groups["Server"].Value; 
      string security = security = Regex.Match(contents, "Security=(?<Security>[^;]+)").Groups["Security"].Value; 
      string database = database = Regex.Match(contents, "Database=(?<Database>[^\r]+)").Groups["Database"].Value; 

      string[] data = new string[] { 
        string.Format("Table={0}", id), 
        string.Format("Server={0}", server), 
        string.Format("Security={0}", security), 
        string.Format("Database={0}", database), 
       }; 
        string sqltable = ("dbo.SLTDS_C" + id + "_Stdtable"); 
        string ids = File.ReadAllLines(@"C:\nc.txt").Aggregate((f, s) => f + "," + s); 
        String cols = String.Join(",", listBox1.Items.Cast<String>().ToArray()); 
        string sql = "select " + cols + " from sqltable where ([id] in (" + ids + "))"; 
      { 
       SqlConnection con = new SqlConnection("Data Source=" + server + ";Initial Catalog=" + database + ";Integrated Security=" + security); 
       con.Open(); 
       SqlDataAdapter tabadapter = new SqlDataAdapter(sql, con); 
       DataSet dataset = new DataSet("dataset"); 
       tabadapter.FillSchema(dataset, SchemaType.Source,cols); 
       DataTable tbltarget; 
       tbltarget = dataset.Tables[cols]; 
       string headers = dataset.Tables[0].Columns.Aggregate((f, s) => f.Name + "," + s.Name); 
       string sqldata = dataset.Tables[0].Rows.Aggregate((f, s) => f.Value + "," + s.Value); 
       string output_text = tbltarget.Columns.Cast<DataColumn>().Select(col => col.ColumnName).Aggregate((current, next) => current + "|" + next) + "\r\n" 
       + tbltarget.Rows.Cast<DataRow>().Select(row => row.ItemArray.Aggregate((current, next) => current.ToString() + "|" + next.ToString())).Cast<string>().Aggregate((current, next) => current + "\r\n" + next); 
       { 
        File.WriteAllText(@"C:\outputtest.txt", output_text); 
       } 
       con.Close(); 
      } 
     } 
    } 
} 

Erreur 1 « System.Data.DataColumnCollection » ne contient pas pu être trouvée une définition pour « agrégat » et aucune méthode d'extension « agrégats » d'accepter un premier argument de type « System.Data.DataColumnCollection » (sont Une instruction using ou une référence d'assembly est manquante?)
Erreur 2 'System.Data.DataRowCollection' ne contient pas de définition pour 'Aggregate' et aucune méthode d'extension 'Aggregate' acceptant un premier argument de type 'System.Data.DataRowCollection 'pourrait être trouvé (manque-t-il une directive d'utilisation ou une référence d'assemblage?)

Answer 1

Corrigez bien ceci:

result_table.FillSchema(database, SchemaType.Source,cols); 

On dirait que vous avez voulu cela, datase variable au lieu de la base de données:

result_table.FillSchema(datase, SchemaType.Source,cols); 

Answer 2

DataTable.Columns et DataTable.Rows ne sont pas des collections génériques. Ils sont de type DataColumnCollection et DataRowCollection, respectivement. Ce sont des types de collection antérieurs à .NET 2.0; Avant les génériques dans .NET 2.0, vous deviez créer une classe spécifique pour toute collection fortement typée.

Pour obtenir quelque chose compatible avec les méthodes LINQ, effectuez l'une de ces:

dataset.Tables[0].Columns.OfType<DataColumn>()

dataset.Tables[0].Columns.Cast<DataColumn>()

La différence est que OfType ne recevra que les éléments qui peuvent être exprimées à ce type, et ignorez le reste, tandis que Cast s'attendra à ce que la collection contienne seulement éléments qui peuvent être castés à ce type, et lancera une exception si elle en rencontre une qui ne peut pas l'être.