Registrazione logaritmica 1, 10, 100, 1000, ecc.

Question

Esiste un modo più efficiente di fare quanto segue, qualcosa ci sembra semplicemente sbagliato? Sto cercando il modo più efficiente di logging logaritmico.

public bool Read() 
    { 
     long count = Interlocked.Increment(ref _count); 
     switch (count) 
     { 
      case 1L: 
      case 10L: 
      case 100L: 
      case 1000L: 
      case 10000L: 
      case 100000L: 
      case 1000000L: 
      case 10000000L: 
      case 100000000L: 
      case 1000000000L: 
      case 10000000000L: 
      case 100000000000L: 
      case 1000000000000L: 
      case 10000000000000L: 
      case 100000000000000L: 
      case 10000000000000000L: 
      case 100000000000000000L: 
      case 1000000000000000000L: 
       _logger.LogFormattable(LogLevel.Debug, $"{count} Rows Read"); 
       break; 
     } 

     return _reader.Read(); 
    } 

Aggiornamento:

Qui sono i miei test di benchmark micro.

• Method1: il modo di Übercoder con tenere il passo con lo stato
• Method2: Il mio modo con il grande istruzione switch
• method3: modo di Markus Weninger con la bella funzione matematica

Dal momento che per me 100.000.000 i record letti senza registrazione impiegano circa 20 minuti, mentre altri 4 secondi non sono nulla. Vado con il bellissimo modo di fare la matematica. Mathod3 vince nel mio scenario.

Run time for 100,000,000 iterations averaged over 100 attempts 

Method1 Max: 00:00:00.3253789 
Method1 Min: 00:00:00.2261253 
Method1 Avg: 00:00:00.2417223 

Method2 Max: 00:00:00.5295368 
Method2 Min: 00:00:00.3618406 
Method2 Avg: 00:00:00.3904475 

Method3 Max: 00:00:04.0637217 
Method3 Min: 00:00:03.2023237 
Method3 Avg: 00:00:03.3979303 

Answer 1

Se le prestazioni non è un grosso problema, vorrei utilizzare i seguenti

if(Math.Log10(count) % 1 == 0) 
    _logger.LogFormattable(LogLevel.Debug, $"{count} Rows Read"); 

This question afferma quanto segue:

Per i numeri in virgola mobile, n% 1 == 0 è tipicamente il modo per verificare se c'è qualcosa oltre il punto decimale.

---

Modifica: Per completare la mia risposta, è anche possibile tenere traccia del successivo valore di registrazione, come @ Übercoder pubblicato nella sua risposta.

long nextLoggingValueForLogX = 1; 
if (count == nextLoggingValueForLogX) 
{ 
    nextLoggingValueForLogX *= 10; // Increase it by your needs, e.g., logarithmically by multiplying with 10 
    _logger.LogFormattable(LogLevel.Debug, $"{count} Rows Read"); 
} 

Tuttavia, questo metodo genererà una nuova variabile per ogni registro che non dovrebbe essere eseguita ogni volta. Questo introdurrà un codice extra e anche un lavoro extra se deve essere reso thread-safe.

Answer 2

static long logTrigger = 1; 


if (count == logTrigger) 
{ 
    logTrigger *= 10; 
    // do your logging 
}