Logging logarithmisch 1, 10, 100, 1000, etc

Question

Gibt es eine effizientere Art und Weise die folgende, etwas zu tun, fühlt sich einfach falsch daran? Ich bin auf der Suche nach der zeitsparendsten Art logarithmisch zu loggen.

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(); 
    } 

Update:

Hier mein Mikro-Benchmark-Tests sind.

• Method1: Übercoder Weg mit Zustand hält mit
• Method2: Mein Weg mit der großen switch-Anweisung
• Method3: Markus Weninger Weg mit der netten Math Funktion

Da für mich 100.000.000 Aufzeichnungen, die ohne Protokollierung gelesen werden, dauern ungefähr 20 Minuten, dann sind zusätzliche 4 Sekunden nichts. Ich gehe mit der schönen mathematischen Art, Dinge zu tun. Mathod3 gewinnt in meinem Szenario.

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

Wenn die Leistung kein großes Problem ist, würde ich die folgenden

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

This question besagt Folgendes:

Für Gleitkommazahlen, n% 1 == 0 ist typischerweise die Möglichkeit, zu überprüfen, ob etwas über den Dezimalpunkt hinausgeht.

---

Edit: meine Antwort zu vervollständigen, ist es auch möglich, den Überblick über die nächsten Protokollierung Wert zu halten, wie @ Übercoder in seiner Antwort geschrieben.

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"); 
} 

Doch diese Methode wird für jedes Protokoll mit einer neuen Variablen kommen, die nicht jedes Mal ausgeführt werden sollen. Dies führt zu zusätzlichen Code und zusätzlichen Arbeiten, wenn es threadsicher gemacht werden muss.

Answer 2

static long logTrigger = 1; 


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