Perché il codice del metodo Marshal.WriteInt64 è così complesso?

Question

Il codice modulo sottostante è stata riflessa Net Framework:

[SecurityCritical] 
public static unsafe void WriteInt64(IntPtr ptr, int ofs, long val){ 
    try{ 
     byte* numPtr = (byte*) (((void*) ptr) + ofs); 
     if ((((int) numPtr) & 7) == 0){ 
      *((long*) numPtr) = val; 
     } 
     else{ 
      byte* numPtr2 = (byte*) &val; 
      numPtr[0] = numPtr2[0]; 
      numPtr[1] = numPtr2[1]; 
      numPtr[2] = numPtr2[2]; 
      numPtr[3] = numPtr2[3]; 
      numPtr[4] = numPtr2[4]; 
      numPtr[6] = numPtr2[6]; 
      numPtr[7] = numPtr2[7]; 
     } 
    } 
    catch (NullReferenceException){ 
     throw new AccessViolationException(); 
    } 
} 

A mio parere, *((long*) numPtr) = val è abbastanza, e molto efficiente.

Perché così complesso?

Answer 1

Sembra piuttosto semplice, anche se ottimizzato.

Si noti l'esterno se - esso controlla se è possibile scrivere l'Int64 in una sola operazione (ciò accade se il puntatore che si tiene il metodo è allineato correttamente - punta all'inizio di un Int64 in memoria - l'indirizzo deve essere un multiplo di 8).

Se non è possibile scrivere in una sola operazione, il codice appena scrive un byte alla volta, saltando il ciclo per risparmiare un po 'di tempo (questo è chiamato 'ciclo di svolgimento')