Quelqu'un peut-il m'aider avec simple algo?

Question

Je veux analyser tous les octets téléchargés par la requête http si ils sont> 100kb, s'ils ne le sont pas, pour les concaténer dans un tampon et quand le tampon récupère> 100kb pour les analyser à nouveau et annuler l'uffer. Mais ne pas analyser toutes les données du fichier et dans le morceau final pour obtenir ex: 2kb. Il faut vérifier le morceau suivant et s'il est final de le concaténer (ex: final_chunk.Length + 2kb)

Le point est que j'ai besoin d'analyser au moins 100kb morceaux à chaque fois, rien de moins.

Answer 1

Comme PoweRoy a dit que vous avez déjà obtenu l'algorithme que vous avez juste besoin de le coder ... Laissez-moi le mettre étape par étape.

1. Déclarer objet tampon local
2. Faire Async/requête synchrone HTTP (je préfère Async appel)
3. Enregistrer à tampon
4. Vérifiez la taille de la mémoire tampon (si elle est> 100kb)
5. Si le tampon size not> 100kb Ajoute les données au tampon
6. s'il> 100kb lit le tampon et l'efface.
7. Aller à l'étape 2

Answer 2

Je suppose que ça va faire l'affaire. Je dois juste le réécrire avec des tableaux d'octets. Trouvez-vous des bugs?

 class SmartChunk { 

     private int ChunkSize; 
     private int DataSize; 
     private int pos; 
     private int len; 
     private string buff = ""; 

     public SmartChunk(int InitChunkSize, int DataLen) { 
      pos = 0; 
      len = DataLen; 
      ChunkSize = InitChunkSize; 
     } 

     public string Append(string s) { 
      if (pos + ChunkSize * 2 > len) ChunkSize = len - pos; 

      if (s.Length >= ChunkSize) { 
       return s; 
      } 
      else { 
       buff += s; 
       if (buff.Length >= ChunkSize) { 
        pos += buff.Length; 
        string b = buff; 
        buff = ""; 
        return b; 
       } 
      } 

      return null; 
     } 
    } 

Answer 3

Et ici, il est avec la liste des tableaux d'octets:

class SmartChunk { 
     private int ChunkSize; 
     private int DataSize; 
     private int pos; 
     private int len; 
     private List<byte[]> buff; 

     public SmartChunk(int InitChunkSize, int DataLen) { 
      buff = new List<byte[]>(); 
      pos = 0; 
      len = DataLen; 
      ChunkSize = InitChunkSize; 
     } 

     public List<byte[]> Append(byte[] b) { 
      if (pos + ChunkSize * 2 > len) ChunkSize = len - pos; 

      if (b.Length >= ChunkSize) { 
       List<byte[]> priv = new List<byte[]>(); 
       priv.Add(b); 
       return priv; 
      } 
      else { 
       buff.Add(b); 
       int total_size = 0; 
       foreach(byte[] inner in buff){ 
        total_size += inner.Length; 
       } 

       if (total_size >= ChunkSize) { 
        pos += total_size; 

        List<byte[]> temp = new List<byte[]>(buff); 
        //foreach (byte[] tmp in buff) temp.Add(tmp); 
        buff.Clear(); 
        return temp; 
       } 
      } 

      return null; 
     } 
    }