Il modo più veloce per convertire l'immagine in un array di byte

Sto realizzando un'applicazione di condivisione Desktop remoto in cui acquisisco un'immagine del desktop e la comprimo e la invio al destinatario. Per comprimere l'immagine devo convertirla in un byte [].

Attualmente sto usando questo:

public byte[] imageToByteArray(System.Drawing.Image imageIn)
{
    MemoryStream ms = new MemoryStream();
    imageIn.Save(ms,System.Drawing.Imaging.ImageFormat.Gif);
    return  ms.ToArray();
}

public Image byteArrayToImage(byte[] byteArrayIn)
{
     MemoryStream ms = new MemoryStream(byteArrayIn);
     Image returnImage = Image.FromStream(ms);
     return returnImage;
}

Ma non mi piace perché devo salvarlo in un ImageFormat e questo potrebbe anche utilizzare risorse (Slow Down) oltre a produrre risultati di compressione diversi.Ho letto di usare Marshal.Copy e memcpy ma non sono in grado di farlo capiscili.

Quindi esiste un altro metodo per raggiungere questo obiettivo?

Quindi esiste un altro metodo per raggiungere questo obiettivo?

No. Per convertire un'immagine in un array di byte si deve specificare un formato di immagine - proprio come è necessario specificare una codifica quando si converte il testo in un array di byte.

Se sei preoccupato per gli artefatti di compressione, scegli un formato senza perdita di dati. Se sei preoccupato per le risorse della CPU, scegli un formato che non si preoccupi della compressione, ad esempio solo pixel ARGB non elaborati. Ma ovviamente questo porterà a un array di byte più grande.

Si noti che se si sceglie un formato che fa comprendere la compressione, non c'è alcun punto in poi comprimere la matrice di byte in seguito - è quasi certo di avere alcun effetto benefico.

Esiste una proprietà RawFormat del parametro Image che restituisce il formato file dell'immagine. Potresti provare quanto segue:

// extension method
public static byte[] imageToByteArray(this System.Drawing.Image image)
{
    using(var ms = new MemoryStream())
    {
        image.Save(ms, image.RawFormat);
        return ms.ToArray();
    }
}

Non sono sicuro che otterrai enormi guadagni per i motivi sottolineati da Jon Skeet. Tuttavia, potresti provare a confrontare il metodo TypeConvert.ConvertTo e vedere come si confronta con il tuo metodo corrente.

ImageConverter converter = new ImageConverter();
byte[] imgArray = (byte[])converter.ConvertTo(imageIn, typeof(byte[]));

public static byte[] ReadImageFile(string imageLocation)
    {
        byte[] imageData = null;
        FileInfo fileInfo = new FileInfo(imageLocation);
        long imageFileLength = fileInfo.Length;
        FileStream fs = new FileStream(imageLocation, FileMode.Open, FileAccess.Read);
        BinaryReader br = new BinaryReader(fs);
        imageData = br.ReadBytes((int)imageFileLength);
        return imageData;
    }

public static class HelperExtensions
{
    //Convert Image to byte[] array:
    public static byte[] ToByteArray(this Image imageIn)
    {
        var ms = new MemoryStream();
        imageIn.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
        return ms.ToArray();
    }

    //Convert byte[] array to Image:
    public static Image ToImage(this byte[] byteArrayIn)
    {
        var ms = new MemoryStream(byteArrayIn);
        var returnImage = Image.FromStream(ms);
        return returnImage;
    }
}

Il modo più veloce per scoprirlo è questo:

var myArray = (byte[]) new ImageConverter().ConvertTo(InputImg, typeof(byte[]));

Spero di essere utile