Liest Daten aus SqlDataReader

using(SqlDataReader rdr = cmd.ExecuteReader())
{
    while (rdr.Read())
    {
        var myString = rdr.GetString(0); //The 0 stands for "the 0'th column", so the first column of the result.
        // Do somthing with this rows string, for example to put them in to a list
        listDeclaredElsewhere.Add(myString);
    }
}

string col1Value = rdr["ColumnOneName"].ToString();

oder

string col1Value = rdr[0].ToString();

Dies sind objects, also müssen Sie sie entweder umwandeln oder .ToString().

Geben Sie den Namen der Spalte begin an, die von der Datenbank zurückgegeben wird, in der "ColumnName" steht. Wenn es sich um eine Zeichenfolge handelt, können Sie .ToString() verwenden. Wenn es sich um einen anderen Typ handelt, müssen Sie ihn mit System.Convert konvertieren.

SqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
    string column = rdr["ColumnName"].ToString();
    int columnValue = Convert.ToInt32(rdr["ColumnName"]);
}

while(rdr.Read())
{
   string col=rdr["colName"].ToString();
}

es wird klappen

Für ein einzelnes Ergebnis:

if (reader.Read())
{
    Response.Write(reader[0].ToString());
    Response.Write(reader[1].ToString());
}

Für mehrere Ergebnisse:

while (reader.Read())
{
    Response.Write(reader[0].ToString());
    Response.Write(reader[1].ToString());
}

Ich habe gedacht, meine Helfer-Methode für diejenigen, die sie verwenden können, zu teilen:

public static class Sql
{
    public static T Read<T>(DbDataReader DataReader, string FieldName)
    {
        int FieldIndex;
        try { FieldIndex = DataReader.GetOrdinal(FieldName); }
        catch { return default(T); }

        if (DataReader.IsDBNull(FieldIndex))
        {
            return default(T);
        }
        else
        {
            object readData = DataReader.GetValue(FieldIndex);
            if (readData is T)
            {
                return (T)readData;
            }
            else
            {
                try
                {
                    return (T)Convert.ChangeType(readData, typeof(T));
                }
                catch (InvalidCastException)
                {
                    return default(T);
                }
            }
        }
    }
}

Verwendungszweck:

cmd.CommandText = @"SELECT DISTINCT [SoftwareCode00], [MachineID] 
                    FROM [CM_S01].[dbo].[INSTALLED_SOFTWARE_DATA]";
using (SqlDataReader data = cmd.ExecuteReader())
{
    while (data.Read())
    {
        usedBy.Add(
            Sql.Read<String>(data, "SoftwareCode00"), 
            Sql.Read<Int32>(data, "MachineID"));
    }
}

Die Hilfsmethode wird in einen beliebigen Wert umgewandelt. Wenn sie nicht umgewandelt werden kann oder der Datenbankwert NULL ist, ist das Ergebnis null.

Eigentlich habe ich selbst herausgefunden, dass ich das machen könnte:

while (rdr.read())
{  
  string str = rdr.GetValue().ToString().Trim();  
}

In den einfachsten Ausdrücken, wenn Ihre Abfrage column_name zurückgibt und eine Zeichenfolge enthält:

while (rdr.Read())
{
    string yourString = rdr.getString("column_name")
}

Ich weiß, dass dies ziemlich alt ist, aber wenn Sie den Inhalt eines SqlDataReader in eine Klasse einlesen, ist dies sehr praktisch. Die Spaltennamen von Leser und Klasse sollten identisch sein

public static List<T> Fill<T>(this SqlDataReader reader) where T : new()
        {
            List<T> res = new List<T>();
            while (reader.Read())
            {
                T t = new T();
                for (int inc = 0; inc < reader.FieldCount; inc++)
                {
                    Type type = t.GetType();
                    string name = reader.GetName(inc);
                    PropertyInfo prop = type.GetProperty(name);
                    if (prop != null)
                    {
                        if (name == prop.Name)
                        {
                            var value = reader.GetValue(inc);
                            if (value != DBNull.Value)
                            { 
                                prop.SetValue(t, Convert.ChangeType(value, prop.PropertyType), null);
                            }
                            //prop.SetValue(t, value, null);

                        }
                    }
                }
                res.Add(t);
            }
            reader.Close();

            return res;
        }

Ich habe eine Helferfunktion wie:

  public static string GetString(object o)
    {
        if (o == DBNull.Value)
            return "";

        return o.ToString();
    }

dann extrahiere ich die Zeichenfolge:

 tbUserName.Text = GetString(reader["UserName"]);

Ich würde gegen mit SqlDataReader hier argumentieren; ADO.NET hat Lots von Edge-Fällen und -Komplikationen, und meiner Erfahrung nach ist der meist manuell geschriebene ADO.NET-Code in mindestens einer Richtung (meist subtil und kontextabhängig) defekt.

Es gibt Werkzeuge, um dies zu vermeiden. In diesem Fall möchten Sie beispielsweise eine Spalte mit Strings lesen. Dapper macht das völlig schmerzlos:

var region = ... // some filter
var vals = connection.Query<string>(
    "select Name from Table where [email protected]", // query
    new { region } // parameters
).AsList();

Dapper beschäftigt sich hier mit der gesamten Parametrisierung, Ausführung und Zeilenverarbeitung - und vielen anderen grungy Details von ADO.NET. Der <string> kann durch <SomeType> ersetzt werden, um ganze Zeilen zu Objekten zu materialisieren.

Ich lese Daten normalerweise auf diese Weise. Ich habe gerade ein kleines Beispiel hinzugefügt.

string connectionString = "Data Source=DESKTOP-2EV7CF4;Initial Catalog=TestDB;User ID=sa;Password=tintin11#";
string queryString = "Select * from EMP";

using (SqlConnection connection = new SqlConnection(connectionString))
using (SqlCommand command = new SqlCommand(queryString, connection))
            {
                connection.Open();

                using (SqlDataReader reader = command.ExecuteReader())
                {
                    if (reader.HasRows)
                    {
                        while (reader.Read())
                        {
                            Console.WriteLine(String.Format("{0}, {1}", reader[0], reader[1]));
                        }
                    }
                    reader.Close();
                }
            }