Le moyen le plus rapide de convertir une image en tableau d'octets

Je crée une application de partage de bureau à distance dans laquelle je capture une image du bureau, je la compresse et je l'envoie au récepteur. Pour compresser l'image, je dois la convertir en octet [].

Actuellement j'utilise ceci:

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;
}

Mais je ne l'aime pas car je dois l'enregistrer dans un ImageFormat et cela peut également utiliser des ressources (ralentir) et produire des résultats de compression différents.J'ai lu sur l'utilisation de Marshal.Copy et memcpy mais je suis incapable de les comprendre.

Existe-t-il donc une autre méthode pour atteindre cet objectif?

Existe-t-il donc une autre méthode pour atteindre cet objectif?

Non. Pour convertir une image en tableau d'octets, vous devez spécifier un format d'image - tout comme vous devez spécifier un encodage lorsque vous convertissez du texte en tableau d'octets.

Si vous vous inquiétez des artefacts de compression, choisissez un format sans perte. Si vous êtes préoccupé par les ressources du processeur, choisissez un format qui ne gêne pas la compression - uniquement des pixels ARVB bruts, par exemple. Mais bien sûr, cela conduira à un plus grand tableau d'octets.

Notez que si vous choisissez un format qui ne comprend la compression, il n'y a pas de point dans la compression puis le tableau d'octets après - il est presque certain d'avoir aucun effet bénéfique.

Il existe une propriété RawFormat du paramètre Image qui renvoie le format de fichier de l'image. Vous pouvez essayer ce qui suit:

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

Je ne sais pas si vous allez obtenir des gains énormes pour les raisons évoquées par Jon Skeet. Cependant, vous pouvez essayer de comparer la méthode TypeConvert.ConvertTo et voir comment elle se compare à l'utilisation de votre méthode actuelle.

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;
    }
}

Le moyen le plus rapide pour le savoir est le suivant:

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

J'espère être utile