Différence entre plusieurs BinaryReader.Read() et BinaryReader.ReadBytes (int i)

Question

Je cherchais une fonction BinaryReader.Skip, alors que je suis tombé sur ce feature request on msdn. Il a dit que vous pouvez fournir votre propre fonction BinaryReader.Skip(), en l'utilisant.

recherche seulement à ce code, je me demande pourquoi il a choisi cette façon de sauter une certaine quantité d'octets:

for (int i = 0, i < count; i++) { 
     reader.ReadByte(); 
    } 

Y at-il une différence entre cela et:

reader.ReadBytes(count); 

Même si c'est juste une petite optimalisation, je voudrais me défaire. Parce que maintenant cela n'a pas de sens pour moi pourquoi vous utiliseriez la boucle for.

public void Skip(this BinaryReader reader, int count) { 
    if (reader.BaseStream.CanSeek) { 
     reader.BaseStream.Seek(count, SeekOffset.Current); 
    } 
    else { 
     for (int i = 0, i < count; i++) { 
      reader.ReadByte(); 
     } 
    } 
} 

Answer 1

Non, il n'y a aucune différence. EDIT: En supposant que le flux a assez byes

La méthode ReadByte simplement en avant la méthode ReadByte du flux sous-jacent.

La méthode ReadBytes appelle le Read du flux sous-jacent jusqu'à ce qu'il lise le nombre d'octets requis.
Il est défini comme ceci:

public virtual byte[] ReadBytes(int count) { 
    if (count < 0) throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); 
    Contract.Ensures(Contract.Result<byte[]>() != null); 
    Contract.Ensures(Contract.Result<byte[]>().Length <= Contract.OldValue(count)); 
    Contract.EndContractBlock(); 
    if (m_stream==null) __Error.FileNotOpen(); 

    byte[] result = new byte[count]; 

    int numRead = 0; 
    do { 
     int n = m_stream.Read(result, numRead, count); 
     if (n == 0) 
      break; 
     numRead += n; 
     count -= n; 
    } while (count > 0); 

    if (numRead != result.Length) { 
     // Trim array. This should happen on EOF & possibly net streams. 
     byte[] copy = new byte[numRead]; 
     Buffer.InternalBlockCopy(result, 0, copy, 0, numRead); 
     result = copy; 
    } 

    return result; 
} 

Pour la plupart des cours d'eau, ReadBytes sera probablement plus rapide.

Answer 2

ReadByte lancera une exception EndOfStreamException si la fin du flux est atteinte, alors que ReadBytes ne le fera pas. Cela dépend si vous voulez que Ignorer jette s'il ne peut pas ignorer le nombre d'octets demandé sans atteindre la fin du flux.

Answer 3

Sa très petite optimisation qui de temps en temps passer octets (plutôt que de les lire dans ReadByte) Considérez cette façon

if(vowel) 
{ 
    println(vowel); 
} 
else 
{ 
nextLetter(); 
} 

Si vous pouvez empêcher cette fonction supplémentaire que vous STOCKER un peu de temps au

Answer 4

ReadBytes est plus rapide que plusieurs appels ReadByte.