C#: Wie kann man sicherstellen, dass die Klasse die Arbeit beendet hat, ohne auf Abhängige angewiesen zu sein?

Question

Ich habe eine Klasse, die eine Zeichenfolge sammelt. Es gibt eine Methode Commit, die die Zeichenfolge in eine Zieldatei schreibt.

Wenn eine Zeichenfolge erfasst wird, die Festschreibung jedoch nie aufgerufen wird, möchte ich einen Fehler in einer Protokolldatei melden.

IDisposable wird das Problem nicht lösen, weil Abhängige vergessen werden, es aufzurufen.
implementiert ich einen Finalizer, bekam aber Compiler-Fehler:

The class has a finalizer implemented in it.
Consider deriving from IDisposable, CriticalFinalizerObject or SafeHandle, instead.

Ich kann nicht Compiler-Einstellungen in meinem Unternehmen ändern. Und die vorgeschlagenen Optionen scheinen zu kompliziert zu sein. Irgendwelche Ideen, wie ich Validierung für Commit implementiere?

Answer 1

Aus Ihrer Frage klingt es mir so etwas wie diese:

Haftungsausschluss ist diese nur schlecht geschriebener Code in Notepad, nicht getestet.

class CollectAndCommit : IDisposable 
{ 
    private Dictionary<string, bool> collectedStrings { get; set; } 

    public CollectAndCommit() 
    { 
     collectedStrings = new Dictionary<string, bool>(); 
    } 

    public void Collect(string collectedString) 
    { 
     collectedStrings.Add(collectedString, false); 
    } 

    public void CommitAllUncommitedStrings() 
    { 
     foreach (var uncommitedString in collectedStrings.Where(c => c.Value == false)) 
     { 
      collectedStrings[uncommitedString.Key] = Commit(uncommitedString.Key); 
     } 
    } 

    public bool HasUncommitedStrings() 
    { 
     return collectedStrings.Count(c => c.Value == false) > 0; 
    } 

    private bool Commit(string str) 
    { 
     try 
     { 
      string path = @"c:\temp\MyTest.txt"; 
      if (!File.Exists(path)) 
      { 
       File.Create(path); 
      } 

      using (StreamWriter sw = File.AppendText(path)) 
      { 
       sw.WriteLine(str); 
      } 
      return true; 
     } 
     catch 
     { 
      return false; 
     } 
    } 

    public void Dispose() 
    { 
     if (HasUncommitedStrings()) 
     { 
      throw new Exception("Uncommited Strings!"); 
     } 
    } 
} 

Answer 2

I have a class that collects a string. There is a method Commit, that writes the string to a target file.

Soweit ich das Problem zu verstehen, sind Sie mit zu langen Zeichenfolge Lesen stucked, w/o Aufruf Commit (string s) - es könnte viele Gründe, wie kleine Speicher sein (so bei Belastung nicht ganz Reihe in Speicher passt) oder Sie sind von einem Stream gelesen werden, die kontinuierlich ist ...

Jetzt kommt es, wo das Programm

nicht

es wirft Exception? >Verwenden Sie den try-catch/re-throw-Fehler.

Liest es ohne zu stoppen? >Geben Sie es Zeit für das Lesen, einmal überschritten, Fehler oder einfach zurück mit dem, was Sie haben & commit, dass.

public class MyClass 
{ 

    StringBuilder SB; 

    public string ObtainString() 
    { 
     // This is executed, but takes lot of time/times out 
     // Possible solution below 

     SB = new StringBuilder(); 
     DateTime dt = DateTime.Now; 
     bool isRead = false; 

     while(DateTime.Now.Add(20) > dt) && !isRead) 
     { 
      string helpVar = ReadPartOfFileOrBuffer(); 
      SB.Append(helpVar); 

      isRead = checkIfFileOrBufferIsRead(); 
     }; 

     if(!isRead) throw new Exception("Read timed out"); 

     return SB.ToString(); 
    } 

    public voic Commit(string s) 
    { 
     //This is not being executed! 
    } 

    public void Do() 
    { 
     string result = ObtainString(); 
     Commit(result); 
    }