Aujourd'hui je devais créer un programme qui envoie des fichier "large" sur un webService WebAPI.

Par défaut un site web ASP.Net MVC n'accepte pas de requête de plus 4 megas, or mes fichiers pouvaient être beaucoup plus grands (jusqu'a 2 gigas). Je ne voulais pas désactiver cette sécurité (de taille de 4megas par requête max) de peur d'ouvrir la porte à des attaques DDOS.

Je me suis donc tourné vers l'envoi d'un fichier en plusieur partie sur ma WebAPI.

Méthode divisant un tableau d'octet en plusieurs tableaux d'octets de même taille :

        private static List<byte[]> SplitArray(this byte[] bytes, int chunkSize)
        {
            List<byte[]> result = new List<byte[]>();
            int pos = 0;
            int remaining;

            while ((remaining = bytes.Length - pos) > 0)
            {
                byte[] block = new byte[Math.Min(remaining, chunkSize)];

                Array.Copy(bytes, pos, block, 0, block.Length);
                result.Add(block);
                pos += block.Length;
            }

            return result;
        }

Une fois le fichier divisé en plusieurs tableaux de bytes je l'envoie au serveur de la façon suivante :
 - Envoie d'un post pour récupérer l'identifiant de fichier
- Et envoie un à un des tableaux d'octect

Coté WebAPI je crée deux méthodes :

1. Une méthode qui retournera au client un Id de fichier
2. Une méthode permettant d'envoyer au serveur un tableau d'octet associé à un fichier

Crée une entrée dans le dictionaire contenant tout les fichiers en cours de chargement :

        [HttpPost]
        [Route("addFile")]
        public async Task<int> AddFileAsync()
        {

                var id =  await GENERE_UN_ID_UNIQUE;

                // Ajoute cet ID dans le tableau de fichier en cour de chargement.
                HttpRuntime.Cache[idArchive.ToString()]
                
                return id;

        }

Permet d'envoyer des parties de fichiers au serveur :

        [HttpPost]
        [Route("addchunk")]
        public async Task AddChunkAsync([FromUri] bool isLast, 
            [FromUri] int idArchive, [FromBody] byte[] data)
        {

                var datas = HttpRuntime.Cache[idArchive.ToString()] as List<byte[]>;
              
                if (datas.ContainsKey(idArchive))
                {
                    // Ajoute la partie de fichier dans la liste de byte array
                    datas[idArchive].Add(data);

                    if (isLast)
                    {
                        datas.Remove(idArchive);
                        var datas = _datas[idArchive];

                        // Fusionne les tableaux de bytes en un seul.
                        var array = MergeArrays(datas);
                        await SAUVEGARDE_LE_FICHIER_RECONTRUIT

                    }
                }
                else
                {
                    throw new Exception("Id of archive not found");
                }

        }

Fusionne plusieurs tableaux de bytes en un seul :

        /// <summary>
        /// Merges the arrays.
        /// </summary>
        /// <param name="arrays">The arrays.</param>
        /// <returns>merge arrays</returns>
        private byte[] MergeArrays(List<byte[]> arrays)
        {
            var bytes = new byte[arrays.Sum(a => a.Length)];
            var offset = 0;
            foreach (var array in arrays)
            {
                Buffer.BlockCopy(array, 0, bytes, offset, array.Length);
                offset += array.Length;
            }

            return bytes;
        }

Happy coding :)