Why My Student Project’s Code Is a Nightmare—and How to Fix It

I'm a second‑year graduate student about to graduate, leading a small team on a data‑mining project. To avoid being blocked from graduating, I started teaching design patterns and coding style from day one.

However, after reviewing the SVN code, I discovered numerous issues:

Bad naming : Variables like a1, a2, and even Chinese pinyin such as "JuleiMethod" are used; class names are unclear.

Huge classes : A single MainWindow class contains about 5,000 lines, 100 fields and 50 methods, violating the single‑responsibility principle.

Code duplication : Similar classes repeat the same methods many times instead of using inheritance.

Excessive constructors : Many parameters are forced into constructors instead of using default values or property accessors.

Overuse of singletons and static members : Leads to memory‑leak concerns and poor extensibility.

Unnecessary Java‑style getters/setters in C# : Adding getXXX/setXXX methods despite C# properties.

Comment overload : Source files contain far more comment lines than code, including obsolete test code.

Improper element removal in collections : Using foreach to remove items causes runtime errors; a custom RemoveElements extension method is shown.

Repeated array usage : Creating new arrays inside tight loops instead of using lazy IEnumerable or LINQ.

Hard‑coded console output : Using Console.WriteLine everywhere instead of a proper logging framework.

Copy‑paste code : Repeating similar code blocks instead of writing a simple for‑loop.

Event handling in WPF : Directly wiring button events leads to tight coupling; recommends using data binding and MVVM.

Debugging dumps : Dumping huge text files for debugging and committing them to SVN.

Below is the extension method that safely removes elements from an IList based on a filter and optional action:

public static void RemoveElements(this IList source, Func filter, Action method)
{
    var indexs = (from d in source where filter(d) select source.IndexOf(d)).ToList();
    indexs.Sort();
    for (var i = indexs.Count - 1; i >= 0; i--)
    {
        method?.Invoke(source[indexs[i]]);
        source.RemoveAt(indexs[i]);
    }
}

By applying meaningful identifiers, the single‑responsibility principle, LINQ, proper logging, and MVVM, the code can become far more maintainable and extensible.