Ich habe kürzlich mit einem DateTimeObjekt gearbeitet und so etwas geschrieben:

DateTime dt = DateTime.Now;
dt.AddDays(1);
return dt; // still today's date! WTF?

Die IntelliSense - Dokumentation AddDays()sagt , dass es einen Tag zum Zeitpunkt hinzufügt, die es nicht - es tatsächlich gibt ein Datum mit einem Tag hinzugefügt, so dass Sie schreiben müssen , um es wie:

DateTime dt = DateTime.Now;
dt = dt.AddDays(1);
return dt; // tomorrow's date

Dieser hat mich schon einige Male gebissen, daher dachte ich, es wäre nützlich, die schlimmsten C # -Gotchas zu katalogisieren.

private int myVar;
public int MyVar
{
    get { return MyVar; }
}

Blammo. Ihre App stürzt ohne Stack-Trace ab. Es passiert die ganze Zeit.

(Beachten Sie im Getter Großbuchstaben MyVaranstelle von Kleinbuchstaben myVar.)

Type.GetType

Der, den ich viele Leute beißen gesehen habe, ist Type.GetType(string). Sie fragen sich, warum es für Typen in ihrer eigenen Baugruppe funktioniert, und einige Typen mögen System.String, aber nicht System.Windows.Forms.Form. Die Antwort ist, dass es nur in der aktuellen Assembly und in aussieht mscorlib.

Anonyme Methoden

C # 2.0 führte anonyme Methoden ein, die zu bösen Situationen wie diesen führten:

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        for (int i=0; i < 10; i++)
        {
            ThreadStart ts = delegate { Console.WriteLine(i); };
            new Thread(ts).Start();
        }
    }
}

Was wird das ausdrucken? Nun, es hängt ganz von der Planung ab. Es werden 10 Zahlen gedruckt, aber wahrscheinlich nicht 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, was Sie vielleicht erwarten. Das Problem ist, dass die iVariable erfasst wurde und nicht ihr Wert zum Zeitpunkt der Erstellung des Delegaten. Dies kann leicht mit einer zusätzlichen lokalen Variablen des richtigen Bereichs gelöst werden:

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        for (int i=0; i < 10; i++)
        {
            int copy = i;
            ThreadStart ts = delegate { Console.WriteLine(copy); };
            new Thread(ts).Start();
        }
    }
}

Verzögerte Ausführung von Iteratorblöcken

Dieser "Unit Test für arme Männer" besteht nicht - warum nicht?

using System;
using System.Collections.Generic;
using System.Diagnostics;

class Test
{
    static IEnumerable<char> CapitalLetters(string input)
    {
        if (input == null)
        {
            throw new ArgumentNullException(input);
        }
        foreach (char c in input)
        {
            yield return char.ToUpper(c);
        }
    }

    static void Main()
    {
        // Test that null input is handled correctly
        try
        {
            CapitalLetters(null);
            Console.WriteLine("An exception should have been thrown!");
        }
        catch (ArgumentNullException)
        {
            // Expected
        }
    }
}

Die Antwort ist, dass der Code in der Quelle des CapitalLettersCodes erst ausgeführt wird, wenn die MoveNext()Methode des Iterators zum ersten Mal aufgerufen wird.

Ich habe einige andere Kuriositäten auf meiner Brainteaser-Seite .

Ausnahmen erneut auslösen

Ein Gotcha, das viele neue Entwickler bekommt, ist die Re-Throw-Ausnahmesemantik.

Viel Zeit sehe ich Code wie den folgenden

catch(Exception e) 
{
   // Do stuff 
   throw e; 
}

Das Problem besteht darin, dass der Stack-Trace gelöscht wird und die Diagnose von Problemen erheblich erschwert wird, da Sie nicht nachverfolgen können, woher die Ausnahme stammt.

Der richtige Code ist entweder die throw-Anweisung ohne Argumente:

catch(Exception)
{
    throw;
}

Oder wickeln Sie die Ausnahme in eine andere ein und verwenden Sie die innere Ausnahme, um die ursprüngliche Stapelverfolgung abzurufen:

catch(Exception e) 
{
   // Do stuff 
   throw new MySpecialException(e); 
}

Das Heisenberg-Uhrenfenster

Dies kann Sie schwer beißen, wenn Sie Load-on-Demand-Aufgaben ausführen, wie folgt:

private MyClass _myObj;
public MyClass MyObj {
  get {
    if (_myObj == null)
      _myObj = CreateMyObj(); // some other code to create my object
    return _myObj;
  }
}

Angenommen, Sie haben an anderer Stelle Code, der Folgendes verwendet:

// blah
// blah
MyObj.DoStuff(); // Line 3
// blah

Jetzt möchten Sie Ihre CreateMyObj()Methode debuggen . Sie setzen also einen Haltepunkt in Zeile 3 oben, um in den Code einzusteigen. Nur für ein gutes Maß setzen Sie auch einen Haltepunkt in die Zeile darüber _myObj = CreateMyObj();und sogar einen Haltepunkt in CreateMyObj()sich.

Der Code trifft Ihren Haltepunkt in Zeile 3. Sie betreten den Code. Sie erwarten, den bedingten Code einzugeben, da dieser _myObjoffensichtlich null ist, oder? Äh ... also ... warum hat es die Bedingung übersprungen und ist direkt zu return _myObj?! Sie bewegen Ihre Maus über _myObj ... und tatsächlich hat es einen Wert! Wie ist das passiert?!

Die Antwort ist, dass Ihre IDE einen Wert erhalten hat, weil Sie ein "Überwachungs" -Fenster geöffnet haben - insbesondere das Überwachungsfenster "Autos", in dem die Werte aller Variablen / Eigenschaften angezeigt werden, die für die aktuelle oder vorherige Ausführungszeile relevant sind. Wenn Sie Ihren Haltepunkt auf der Linie 3, entschied das Ãœberwachungsfenster , dass Sie daran interessiert wäre , den Wert zu kennen MyObj- so hinter den Kulissen, ignoriert alle Ihre Haltepunkte , es ging und den Wert berechnet MyObjfür Sie - einschließlich der Anruf , CreateMyObj()dass setzt den Wert von _myObj!

Deshalb nenne ich das das Heisenberg-Uhrfenster - man kann den Wert nicht beobachten, ohne ihn zu beeinflussen ... :)

ERWISCHT!

Bearbeiten - Ich bin der Meinung, dass der Kommentar von @ ChristianHayter die Aufnahme in die Hauptantwort verdient, da er eine effektive Problemumgehung für dieses Problem darstellt. Also, wann immer Sie eine faul geladene Eigenschaft haben ...

Dekorieren Sie Ihre Immobilie mit [DebuggerBrowsable (DebuggerBrowsableState.Never)] oder [DebuggerDisplay ("<bei Bedarf geladen>")]. - Christian Hayter

Hier ist eine andere Zeit, die mich erwischt:

static void PrintHowLong(DateTime a, DateTime b)
{
    TimeSpan span = a - b;
    Console.WriteLine(span.Seconds);        // WRONG!
    Console.WriteLine(span.TotalSeconds);   // RIGHT!
}

TimeSpan.Seconds ist der Sekundenanteil der Zeitspanne (2 Minuten und 0 Sekunden haben einen Sekundenwert von 0).

TimeSpan.TotalSeconds ist die gesamte in Sekunden gemessene Zeitspanne (2 Minuten haben einen Gesamtsekundenwert von 120).

Speicherverlust, weil Sie keine Ereignisse aufgehoben haben.

Dies hat sogar einige leitende Entwickler, die ich kenne, erwischt.

Stellen Sie sich ein WPF-Formular mit vielen Dingen vor, und irgendwo dort abonnieren Sie eine Veranstaltung. Wenn Sie sich nicht abmelden, bleibt das gesamte Formular nach dem Schließen und De-Referenzieren im Speicher.

Ich glaube, das Problem, das ich gesehen habe, war das Erstellen eines DispatchTimers im WPF-Formular und das Abonnieren des Tick-Ereignisses, wenn Sie auf dem Timer kein - = ausführen, verliert Ihr Formular Speicher!

In diesem Beispiel sollte Ihr Teardown-Code haben

timer.Tick -= TimerTickEventHandler;

Dies ist besonders schwierig, da Sie die Instanz des DispatchTimers im WPF-Formular erstellt haben. Sie würden also denken, dass es sich um eine interne Referenz handelt, die vom Garbage Collection-Prozess verarbeitet wird. Leider verwendet der DispatchTimer eine statische interne Liste von Abonnements und Diensten Anforderungen im UI-Thread, sodass die Referenz der statischen Klasse gehört.

Vielleicht nicht wirklich ein Gotcha, weil das Verhalten klar in MSDN geschrieben ist, aber mir einmal den Hals gebrochen hat, weil ich es eher kontraintuitiv fand:

Image image = System.Drawing.Image.FromFile("nice.pic");

Dieser Typ verlässt die "nice.pic" Datei gesperrt, bis das Bild entsorgt ist. Zu der Zeit, als ich damit konfrontiert wurde, dachte ich, es wäre schön, Symbole im laufenden Betrieb zu laden, und merkte (zunächst) nicht, dass ich Dutzende offener und gesperrter Dateien hatte! Das Bild verfolgt, woher die Datei geladen wurde ...

Wie kann man das lösen? Ich dachte, ein Einzeiler würde den Job machen. Ich erwartete einen zusätzlichen Parameter für FromFile(), hatte aber keinen, also schrieb ich diesen ...

using (Stream fs = new FileStream("nice.pic", FileMode.Open, FileAccess.Read))
{
    image = System.Drawing.Image.FromStream(fs);
}

Wenn Sie ASP.NET zählen, würde ich sagen, dass der Lebenszyklus von Webformularen für mich ein ziemlich großes Problem darstellt. Ich habe unzählige Stunden damit verbracht, schlecht geschriebenen Webforms-Code zu debuggen, nur weil viele Entwickler nicht wirklich verstehen, wann sie welchen Event-Handler verwenden sollen (ich eingeschlossen, leider).

überladen == Operatoren und untypisierte Container (Arraylisten, Datensätze usw.):

string my = "my ";
Debug.Assert(my+"string" == "my string"); //true

var a = new ArrayList();
a.Add(my+"string");
a.Add("my string");

// uses ==(object) instead of ==(string)
Debug.Assert(a[1] == "my string"); // true, due to interning magic
Debug.Assert(a[0] == "my string"); // false

Lösungen?

• Verwenden string.Equals(a, b)Sie diese Option immer, wenn Sie Zeichenfolgentypen vergleichen

• Verwenden Sie Generika, List<string>um sicherzustellen, dass beide Operanden Zeichenfolgen sind.

[Serializable]
class Hello
{
    readonly object accountsLock = new object();
}

//Do stuff to deserialize Hello with BinaryFormatter
//and now... accountsLock == null ;)

Moral der Geschichte: Feldinitialisierer werden beim Deserialisieren eines Objekts nicht ausgeführt

DateTime.ToString ("TT / MM / JJJJ") ; Dies gibt Ihnen nicht immer TT / MM / JJJJ, sondern berücksichtigt die regionalen Einstellungen und ersetzt Ihr Datumstrennzeichen, je nachdem, wo Sie sich befinden. Sie könnten also TT-MM-JJJJ oder ähnliches bekommen.

Der richtige Weg, dies zu tun, ist die Verwendung von DateTime.ToString ("TT '/' MM '/' JJJJ");

DateTime.ToString ("r") soll in RFC1123 konvertieren, das GMT verwendet. GMT ist innerhalb von Sekundenbruchteilen von UTC entfernt, und dennoch wird der Formatbezeichner "r" nicht in UTC konvertiert , selbst wenn die betreffende DateTime als Local angegeben ist.

Dies führt zu folgendem Problem (hängt davon ab, wie weit Ihre Ortszeit von UTC entfernt ist):

DateTime.Parse("Tue, 06 Sep 2011 16:35:12 GMT").ToString("r")
>              "Tue, 06 Sep 2011 17:35:12 GMT"

Hoppla!

Ich habe gesehen, dass dieses Buch neulich veröffentlicht wurde, und ich denke, es ist ziemlich dunkel und schmerzhaft für diejenigen, die es nicht wissen

int x = 0;
x = x++;
return x;

Da dies 0 zurückgibt und nicht 1, wie die meisten erwarten würden

Ich bin etwas spät zu dieser Party, aber ich habe zwei Fallstricke, die mich beide kürzlich gebissen haben:

DateTime-Auflösung

Die Ticks-Eigenschaft misst die Zeit in 10-Millionstelsekunden (100 Nanosekundenblöcke). Die Auflösung beträgt jedoch nicht 100 Nanosekunden, sondern etwa 15 ms.

Dieser Code:

long now = DateTime.Now.Ticks;
for (int i = 0; i < 10; i++)
{
    System.Threading.Thread.Sleep(1);
    Console.WriteLine(DateTime.Now.Ticks - now);
}

gibt Ihnen eine Ausgabe von (zum Beispiel):

0
0
0
0
0
0
0
156254
156254
156254

Wenn Sie sich DateTime.Now.Millisecond ansehen, erhalten Sie ebenfalls Werte in gerundeten Blöcken von 15,625 ms: 15, 31, 46 usw.

Dieses spezielle Verhalten ist von System zu System unterschiedlich , es gibt jedoch auch andere auflösungsbezogene Fallstricke in dieser Datums- / Zeit-API.

Path.Combine

Eine großartige Möglichkeit, Dateipfade zu kombinieren, aber sie verhält sich nicht immer so, wie Sie es erwarten würden.

Wenn der zweite Parameter mit einem \Zeichen beginnt , erhalten Sie keinen vollständigen Pfad:

Dieser Code:

string prefix1 = "C:\\MyFolder\\MySubFolder";
string prefix2 = "C:\\MyFolder\\MySubFolder\\";
string suffix1 = "log\\";
string suffix2 = "\\log\\";

Console.WriteLine(Path.Combine(prefix1, suffix1));
Console.WriteLine(Path.Combine(prefix1, suffix2));
Console.WriteLine(Path.Combine(prefix2, suffix1));
Console.WriteLine(Path.Combine(prefix2, suffix2));

Gibt Ihnen diese Ausgabe:

C:\MyFolder\MySubFolder\log\
\log\
C:\MyFolder\MySubFolder\log\
\log\

Wenn Sie einen Prozess starten (mithilfe von System.Diagnostics), der in die Konsole schreibt, den Console.Out-Stream jedoch nie liest, scheint Ihre App nach einer bestimmten Ausgabemenge hängen zu bleiben.

Keine Operatorverknüpfungen in Linq-To-Sql

Siehe hier .

Kurz gesagt, innerhalb der Bedingungsklausel einer Linq-To-Sql-Abfrage können Sie keine bedingten Verknüpfungen wie ||und verwenden &&, um Nullreferenzausnahmen zu vermeiden. Linq-To-Sql wertet beide Seiten des ODER- oder UND-Operators aus, auch wenn die erste Bedingung die Bewertung der zweiten Bedingung überflüssig macht!

Verwenden von Standardparametern mit virtuellen Methoden

abstract class Base
{
    public virtual void foo(string s = "base") { Console.WriteLine("base " + s); }
}

class Derived : Base
{
    public override void foo(string s = "derived") { Console.WriteLine("derived " + s); }
}

...

Base b = new Derived();
b.foo();

Ausgabe:
abgeleitete Basis

Wertobjekte in veränderlichen Sammlungen

struct Point { ... }
List<Point> mypoints = ...;

mypoints[i].x = 10;

hat keine Wirkung.

mypoints[i] gibt eine Kopie von a zurück Point Wertobjekts zurück. Mit C # können Sie gerne ein Feld der Kopie ändern. Im Stillen nichts tun.

Update: Dies scheint in C # 3.0 behoben zu sein:

Cannot modify the return value of 'System.Collections.Generic.List<Foo>.this[int]' because it is not a variable

Vielleicht nicht das Schlimmste, aber einige Teile des .net-Frameworks verwenden Grad, während andere Bogenmaß verwenden (und die Dokumentation, die mit Intellisense angezeigt wird, sagt Ihnen nie, welche, Sie müssen MSDN besuchen, um dies herauszufinden).

All dies hätte vermieden werden können, indem Anglestattdessen eine Klasse abgehalten worden wäre ...

Für C / C ++ - Programmierer ist der Übergang zu C # ein natürlicher. Das größte Problem, dem ich persönlich begegnet bin (und bei anderen den gleichen Übergang gesehen habe), ist jedoch, den Unterschied zwischen Klassen und Strukturen in C # nicht vollständig zu verstehen.

In C ++ sind Klassen und Strukturen identisch. Sie unterscheiden sich nur in der Standardsichtbarkeit, wobei Klassen standardmäßig die private Sichtbarkeit und Strukturen standardmäßig die öffentliche Sichtbarkeit verwenden. In C ++ diese Klassendefinition

    class A
    {
    public:
        int i;
    };

ist funktional äquivalent zu dieser Strukturdefinition.

    struct A
    {
        int i;
    };

In C # sind Klassen jedoch Referenztypen, während Strukturen Werttypen sind. Das macht a GROSSE Unterschied bei (1) der Entscheidung, wann eine übereinander verwendet werden soll, (2) dem Testen der Objektgleichheit, (3) der Leistung (z. B. Boxen / Unboxen) usw.

Es gibt alle Arten von Informationen im Web, die sich auf die Unterschiede zwischen den beiden beziehen (z . B. hier ). Ich würde jedem, der den Übergang zu C # vollzieht, dringend empfehlen, zumindest über die Unterschiede und ihre Auswirkungen Bescheid zu wissen.

Speicherbereinigung und Entsorgung (). Obwohl Sie nichts tun müssen, um Speicher freizugeben , müssen Sie dennoch Ressourcen über Dispose () freigeben. Dies ist sehr leicht zu vergessen, wenn Sie WinForms verwenden oder Objekte auf irgendeine Weise verfolgen.

Arrays implementieren IList

Aber implementieren Sie es nicht. Wenn Sie Add aufrufen, wird angezeigt, dass dies nicht funktioniert. Warum implementiert eine Klasse eine Schnittstelle, wenn sie diese nicht unterstützen kann?

Kompiliert, funktioniert aber nicht:

IList<int> myList = new int[] { 1, 2, 4 };
myList.Add(5);

Wir haben dieses Problem häufig, da der Serializer (WCF) alle ILists in Arrays umwandelt und Laufzeitfehler auftreten.

foreach Schleifen Variablenbereich!

var l = new List<Func<string>>();
var strings = new[] { "Lorem" , "ipsum", "dolor", "sit", "amet" };
foreach (var s in strings)
{
    l.Add(() => s);
}

foreach (var a in l)
    Console.WriteLine(a());

druckt fünf "amet", während das folgende Beispiel gut funktioniert

var l = new List<Func<string>>();
var strings = new[] { "Lorem" , "ipsum", "dolor", "sit", "amet" };
foreach (var s in strings)
{
    var t = s;
    l.Add(() => t);
}

foreach (var a in l)
    Console.WriteLine(a());

MS SQL Server kann keine Daten vor 1753 verarbeiten. Bezeichnenderweise stimmt dies nicht mit der .NET- DateTime.MinDateKonstante überein, die 1/1/1 beträgt. Wenn Sie also versuchen, ein Mindate, ein falsches Datum (wie es mir kürzlich bei einem Datenimport passiert ist) oder einfach das Geburtsdatum von William the Conqueror zu retten, werden Sie in Schwierigkeiten geraten. Hierfür gibt es keine integrierte Problemumgehung. Wenn Sie wahrscheinlich mit Daten vor 1753 arbeiten müssen, müssen Sie Ihre eigene Problemumgehung schreiben.

Das böse Linq Caching Gotcha

Siehe meine Frage , die zu dieser Entdeckung geführt hat, und den Blogger , der das Problem entdeckt hat.

Kurz gesagt, der DataContext speichert einen Cache aller Linq-to-Sql-Objekte, die Sie jemals geladen haben. Wenn jemand anderes Änderungen an einem zuvor geladenen Datensatz vornimmt, können Sie die neuesten Daten nicht abrufen, selbst wenn Sie den Datensatz explizit neu laden!

Dies liegt an einer Eigenschaft, ObjectTrackingEnableddie im DataContext aufgerufen wird und standardmäßig true ist. Wenn Sie diese Eigenschaft auf false setzen, wird der Datensatz jedes Mal neu geladen ... ABER ... Sie können mit SubmitChanges () keine Änderungen an diesem Datensatz beibehalten.

ERWISCHT!

Der Vertrag auf Stream.Read ist etwas, das ich bei vielen Leuten gesehen habe:

// Read 8 bytes and turn them into a ulong
byte[] data = new byte[8];
stream.Read(data, 0, 8); // <-- WRONG!
ulong data = BitConverter.ToUInt64(data);

Der Grund dafür ist, dass höchstens die angegebene Anzahl von Bytes Stream.Readgelesen wird , aber völlig frei ist nur 1 Byte zu lesen, auch wenn weitere 7 Bytes vor dem Ende des Stromes zur Verfügung steht.

Es hilft nicht , dass das sieht so ähnlich wie Stream.Write, das ist die Bytes alle geschrieben haben garantiert , wenn es ohne Ausnahme zurückgibt. Es hilft auch nicht, dass der obige Code fast immer funktioniert . Und natürlich hilft es nicht, dass es keine vorgefertigte und bequeme Methode gibt, um genau N Bytes richtig zu lesen.

Um das Loch zu schließen und das Bewusstsein dafür zu schärfen, finden Sie hier ein Beispiel für einen korrekten Weg, dies zu tun:

    /// <summary>
    /// Attempts to fill the buffer with the specified number of bytes from the
    /// stream. If there are fewer bytes left in the stream than requested then
    /// all available bytes will be read into the buffer.
    /// </summary>
    /// <param name="stream">Stream to read from.</param>
    /// <param name="buffer">Buffer to write the bytes to.</param>
    /// <param name="offset">Offset at which to write the first byte read from
    ///                      the stream.</param>
    /// <param name="length">Number of bytes to read from the stream.</param>
    /// <returns>Number of bytes read from the stream into buffer. This may be
    ///          less than requested, but only if the stream ended before the
    ///          required number of bytes were read.</returns>
    public static int FillBuffer(this Stream stream,
                                 byte[] buffer, int offset, int length)
    {
        int totalRead = 0;
        while (length > 0)
        {
            var read = stream.Read(buffer, offset, length);
            if (read == 0)
                return totalRead;
            offset += read;
            length -= read;
            totalRead += read;
        }
        return totalRead;
    }

    /// <summary>
    /// Attempts to read the specified number of bytes from the stream. If
    /// there are fewer bytes left before the end of the stream, a shorter
    /// (possibly empty) array is returned.
    /// </summary>
    /// <param name="stream">Stream to read from.</param>
    /// <param name="length">Number of bytes to read from the stream.</param>
    public static byte[] Read(this Stream stream, int length)
    {
        byte[] buf = new byte[length];
        int read = stream.FillBuffer(buf, 0, length);
        if (read < length)
            Array.Resize(ref buf, read);
        return buf;
    }

Veranstaltungen

Ich habe nie verstanden, warum Ereignisse ein Sprachmerkmal sind. Sie sind kompliziert zu bedienen: Sie müssen vor dem Anruf auf Null prüfen, Sie müssen sich abmelden, Sie können nicht herausfinden, wer registriert ist (z. B. habe ich mich registriert?). Warum ist eine Veranstaltung nicht nur eine Klasse in der Bibliothek? Grundsätzlich ein Spezialist List<delegate>?

Heute habe ich einen Fehler behoben, der sich lange Zeit entzogen hat. Der Fehler befand sich in einer generischen Klasse, die in einem Multithread-Szenario verwendet wurde, und ein statisches int-Feld wurde verwendet, um eine sperrfreie Synchronisation mit Interlocked bereitzustellen. Der Fehler wurde verursacht, weil jede Instanziierung der generischen Klasse für einen Typ eine eigene statische Aufladung hat. Jeder Thread hat also ein eigenes statisches Feld und es wurde nicht wie vorgesehen eine Sperre verwendet.

class SomeGeneric<T>
{
    public static int i = 0;
}

class Test
{
    public static void main(string[] args)
    {
        SomeGeneric<int>.i = 5;
        SomeGeneric<string>.i = 10;
        Console.WriteLine(SomeGeneric<int>.i);
        Console.WriteLine(SomeGeneric<string>.i);
        Console.WriteLine(SomeGeneric<int>.i);
    }
}

Dies druckt 5 10 5

Aufzählungen können mehrmals ausgewertet werden

Es wird Sie beißen, wenn Sie eine träge aufgezählte Aufzählung haben und Sie zweimal darüber iterieren und unterschiedliche Ergebnisse erhalten. (oder Sie erhalten die gleichen Ergebnisse, aber es wird zweimal unnötig ausgeführt)

Zum Beispiel brauchte ich beim Schreiben eines bestimmten Tests einige temporäre Dateien, um die Logik zu testen:

var files = Enumerable.Range(0, 5)
    .Select(i => Path.GetTempFileName());

foreach (var file in files)
    File.WriteAllText(file, "HELLO WORLD!");

/* ... many lines of codes later ... */

foreach (var file in files)
    File.Delete(file);

Stellen Sie sich meine Überraschung beim File.Delete(file)Werfen vor FileNotFound!!

Was hier passiert, ist, dass die filesAufzählung zweimal wiederholt wurde (die Ergebnisse der ersten Iteration werden einfach nicht gespeichert) und bei jeder neuen Iteration, die Sie erneut aufrufen würden, Path.GetTempFilename()sodass Sie einen anderen Satz temporärer Dateinamen erhalten.

Die Lösung besteht natürlich darin, den Wert mit ToArray()oder aufzulisten ToList():

var files = Enumerable.Range(0, 5)
    .Select(i => Path.GetTempFileName())
    .ToArray();

Dies ist noch beängstigender, wenn Sie etwas mit mehreren Threads ausführen, wie:

foreach (var file in files)
    content = content + File.ReadAllText(file);

und du findest heraus, dass content.Lengthnach all den Schreibvorgängen immer noch 0 ist !! Sie beginnen dann rigoros zu überprüfen, ob Sie keine Rennbedingung haben, wenn ... nach einer verschwendeten Stunde ... Sie herausgefunden haben, dass es nur das winzige kleine Enumerable-Gotcha-Ding ist, das Sie vergessen haben ...

Ich habe gerade eine seltsame gefunden, bei der ich eine Weile im Debug stecken geblieben bin:

Sie können null für ein nullfähiges int erhöhen, ohne eine Ausnahme auszulösen, und der Wert bleibt null.

int? i = null;
i++; // I would have expected an exception but runs fine and stays as null

TextInfo textInfo = Thread.CurrentThread.CurrentCulture.TextInfo;

textInfo.ToTitleCase("hello world!"); //Returns "Hello World!"
textInfo.ToTitleCase("hElLo WoRld!"); //Returns "Hello World!"
textInfo.ToTitleCase("Hello World!"); //Returns "Hello World!"
textInfo.ToTitleCase("HELLO WORLD!"); //Returns "HELLO WORLD!"

Ja, dieses Verhalten ist dokumentiert, aber das macht es sicherlich nicht richtig.