L'obtention de données binaires à l'aide de SqlDataReader

J'ai une table nommé Blob (Id (int), de Données (Image)). J'ai besoin d'utiliser SqlDataReader pour obtenir que des données d'image. Notez que je ne veux pas de Réponse.Binarywrite() les données dans le navigateur. J'ai juste besoin que des données binaires comme byte[] pour utiliser les mêmes pour certaines opérations internes. Seule façon que je peux penser est d'obtenir l'id à l'aide de SqlDataReader et de l'utiliser à nouveau SqlCommand.ExecuteScalar() pour obtenir ce que byte[] pour un identifiant donné. Puis-je utiliser seulement le SqlDataReader (SqlCommand.ExecuteReader) pour obtenir que les données de l'image que byte[]? Ai-je raté quelque chose?

InformationsquelleAutor Ashish Gupta | 2011-03-20
  1. 64

    Vous devriez être en mesure de l'obtenir par le biais de: (byte[])reader["Data"].

    Également de noter que la image type de données est obsolète, et sera supprimée dans une future version de SQL Server; utilisation varbinary(max) à la place.

    • Encore plus court: (byte[])reader["Data"]
    • Je n'ai même pas voir un Items collection sur le SqlDataReader dans .NET 4.0.
    • Est la collection d'Éléments obsolète?
    InformationsquelleAutor Andy Edinborough
  2. 18

    Oui, vous pouvez utiliser SqlDataReader.GetBytes. Probablement, vous voulez passer de null de la mémoire tampon dans le premier appel, pour savoir combien de données il est, et ensuite l'appeler de nouveau avec un tampon de taille appropriée.

    Vous peut simplement être en mesure d'utiliser l'indexeur et convertir le résultat dans un tableau d'octets - je ne suis pas sûr. Vaut le coup d'essayer 🙂

    • ind ndx = rdr.GetOrdinal("<ColumnName>"); if(!rdr.IsDBNull(ndx)) { long taille = rdr.GetBytes(ndx, 0, null, 0, 0); //obtenir la longueur de données byte[] valeurs = new byte[taille]; int bufferSize = 1024; long bytesRead = 0; int curPos = 0; while (bytesRead < taille) { bytesRead += rdr.GetBytes(ndx, curPos, les valeurs, les curPos, bufferSize); curPos += taille de tampon; } }
    • Pourquoi s'embêter avec une autre taille de la mémoire tampon lorsque vous avez déjà un tampon de la bonne taille? Et vous devez l'utiliser bytesRead au lieu de curPos; vous êtes actuellement en supposant toujours qu'il lit un tampon plein montant.
    • SqlDataReader.GetBytes() sonne comme une méthode très efficace car vous pouvez réutiliser le même tableau (si il a la bonne taille). Afin de ne pas créer un nouveau tableau pour chaque colonne (byte[])reader["Data"] ferait.
    InformationsquelleAutor Jon Skeet
  3. 10

    Dans .NET Framework 4.5, vous pouvez utiliser GetStream méthode pour accéder à des données binaires comme des Flux.

    InformationsquelleAutor Axarydax
  4. 7

    De MSDN. Ne sais pas pourquoi je n'arrivais pas à trouver qu'avant.

        SqlConnection pubsConn = new SqlConnection("Data Source=localhost;Integrated Security=SSPI;Initial Catalog=pubs;");
SqlCommand logoCMD = new SqlCommand("SELECT pub_id, logo FROM pub_info", pubsConn);
FileStream fs;                          //Writes the BLOB to a file (*.bmp).
BinaryWriter bw;                        //Streams the BLOB to the FileStream object.
int bufferSize = 100;                   //Size of the BLOB buffer.
byte[] outbyte = new byte[bufferSize];  //The BLOB byte[] buffer to be filled by GetBytes.
long retval;                            //The bytes returned from GetBytes.
long startIndex = 0;                    //The starting position in the BLOB output.
string pub_id = "";                     //The publisher id to use in the file name.
//Open the connection and read data into the DataReader.
pubsConn.Open();
SqlDataReader myReader = logoCMD.ExecuteReader(CommandBehavior.SequentialAccess);
while (myReader.Read())
{
//Get the publisher id, which must occur before getting the logo.
pub_id = myReader.GetString(0);  
//Create a file to hold the output.
fs = new FileStream("logo" + pub_id + ".bmp", FileMode.OpenOrCreate, FileAccess.Write);
bw = new BinaryWriter(fs);
//Reset the starting byte for the new BLOB.
startIndex = 0;
//Read the bytes into outbyte[] and retain the number of bytes returned.
retval = myReader.GetBytes(1, startIndex, outbyte, 0, bufferSize);
//Continue reading and writing while there are bytes beyond the size of the buffer.
while (retval == bufferSize)
{
bw.Write(outbyte);
bw.Flush();
//Reposition the start index to the end of the last buffer and fill the buffer.
startIndex += bufferSize;
retval = myReader.GetBytes(1, startIndex, outbyte, 0, bufferSize);
}
//Write the remaining buffer.
if(retval > 0) //if file size can divide to buffer size
bw.Write(outbyte, 0, (int)retval); //original MSDN source had retval-1, a bug
bw.Flush();
//Close the output file.
bw.Close();
fs.Close();
}
//Close the reader and the connection.
myReader.Close();
pubsConn.Close();
    • Une remarque sur ce point: si vous ne définissez pas CommandBehavior.SequentialAccess sur le ExecuteReader appel (par exemple, obliger le lecteur à partir d'une autre partie d'une couche de données), il va faire des choses horribles à votre mémoire (création d'une goutte de la taille du tableau d'octets pour chaque appel de GetBytes()); Cette solution doit être utilisée UNIQUEMENT avec CommandBehavior.SequentialAccess comme démontré ici.
    • Quelqu'un pourrait-il offrir des commentaires sur la façon dont on décide de la taille de la mémoire tampon? L'exemple utilise 100, mais pourquoi pas 10, et pourquoi pas de 10 000? Quels sont les facteurs que l'on doit prendre en compte?
    InformationsquelleAutor Ashish Gupta
  5. 2

    Utilisez cette fonction pour la sécurité et flexible octets lecture:

        ///<summary>
///Reads all available bytes from reader
///</summary>
///<param name="reader"></param>
///<param name="ordinal"></param>
///<returns></returns>
private byte[] GetBytes(SqliteDataReader reader, int ordinal)
{
byte[] result = null;
if (!reader.IsDBNull(ordinal))
{
long size = reader.GetBytes(ordinal, 0, null, 0, 0); //get the length of data 
result = new byte[size];
int bufferSize = 1024;
long bytesRead = 0;
int curPos = 0;
while (bytesRead < size)
{
bytesRead += reader.GetBytes(ordinal, curPos, result, curPos, bufferSize);
curPos += bufferSize;
}
}
return result;
}
    • Puisque vous avez déjà la bonne taille, mieux vaut ne int bufferSize = size > int.MaxValue ? int.MaxValue : (int)size;
    InformationsquelleAutor Anton Bakulev
  6. 0

    Pas besoin d'utiliser le lecteur. Il suffit d'utiliser un jeu de données pour récupérer les valeurs de la base de données(à l'aide de procédures stockées ou toute autre méthode) et il suffit de taper le jeter avec l'octet(code ci-dessous) et de le stocker dans un tableau d'octets. Votre travail est fait.

    byte[] productImage;
productImage = (byte[])ds.Tables[0].Rows[0]["Image"];
    InformationsquelleAutor