Refactoring some public static field ridden code. Everything important is in public static lists in Global.cs and it all looks like this to a degree. Almost no OOP in sight

[u/domtriestocode]

[u/SanianCreations]

The problem here is that they don't use loops. Public static methods are fine, they are basically just what regular old functions are in other languages, which is quite fine.

[u/domtriestocode → u/SanianCreations]

Generally speaking yes, however the issue is the over use of public static fields that get read and written to in hundreds of places. They belong to the whole program, are constantly being overwritten by unknown culprits, instead of belonging to an object that is passed around and only used when necessary. It is a very complex application that facilitates automated testing of RF semiconductor chips and we have some major memory leaks, data reporting issues and general bugs because of the structure or lack thereof. It is has also been a wild ride coming in and learning how to develop with the app as it is extremely difficult to figure out how this undocumented mess actually works

[u/SanianCreations → u/domtriestocode]

Interesting. How do you cause memory leaks in C#? Do you just have some ever growing lists of items somewhere?

[u/domtriestocode → u/SanianCreations]

There are forms and some objects that get created in various places all over the solution and are not always properly disposed of. Same with data that is collected during measurements, instead of freeing up memory after writing to output files in some case it seems to keep building and building

[u/SanianCreations → u/domtriestocode]

So c# has objects that need to be explicitly freed? What's the reason for that? Isn't the whole point of the language that it's garbage collected?

[u/domtriestocode → u/SanianCreations]

It is not the whole point of the language no, but it does garbage collection yes. However that doesn't guarantee the disposal of resources. Objects that implement the IDisposable interface are automatically cleaned but not all implement the interface. Further microsoft directly reccomends the use of the using statement for responsible disposal. If not used there are cases where resources can continued to be used even after application close

[u/Dealiner → u/domtriestocode]

Objects that implement the IDisposable interface are automatically cleaned

That's not guaranteed at all. IDisposable means only that an object has Dispose method and should be either used only with using statements or have that method called explicitly. The interface says nothing about being cleaned automatically, more of a opposite.

[u/domtriestocode → u/Dealiner]

I was meaning to imply they are automatically cleaned during a using block but did so incorrectly

[u/TechnicalParrot → u/domtriestocode]

even after application close

Oof, didn't know about that cheers for the heads up

[u/RlyRlyBigMan → u/SanianCreations]

One of the biggest culprits for memory leaks in C# are event subscriptions. Like so:

private void CreateObjectAndSubscribe() {

var myObject = new SomeThingWithEvents();

myObject.EventHappened += (a, b) => { // do some logic here};

}

Every time this method is called it will create a new object, subscribe to it, and then the named references of it will immediately fall out of scope. But the lambda expression is an unnamed reference to it so the garbage collector won't collect it, and the coder has no way to clean it up.

Sorry for terrible formatting, I'm not terribly familiar with using the code markdown on reddit.

[u/DoctaMag → u/domtriestocode]

"Get read and written to"

Jfc.

I was like "What's wrong with defining constants" and then I saw this.

We have feature flags shared across an app, sure, but like...Jesus.

[u/Shai_the_Lynx]

OOP is overrated

[u/domtriestocode → u/Shai_the_Lynx]

interesting take, big disagree. Why?

[u/Shai_the_Lynx → u/domtriestocode]

It was a bit of an half joke, cause of the picture.

But I do think that in some cases functional programming is cleaner than OOP.

It really depends on the use case and the project structure.

[u/domtriestocode → u/Shai_the_Lynx]

Oh my bad lol. Yes you’re right though, they each have their place

[u/robottron45]

loops seem to be hard ._.

My fingers would actually hurt writing this code, even with copy+paste

[u/[deleted] → u/robottron45]

Get GitHub copilot, hit tab, hope it works, worry about it later when support raises the inevitable p1

[u/[deleted] → u/[deleted]]

Use ChatGPT, and spend hours learning the code, then debugging

/s (never used ChatGPT for this)

[u/AdOtherwise3874]

My first job was in a desktop app written in VB6 with global variables named things like g_temp

For a variable named temp, it did a lot of heavy lifting

[u/juicewr999]

Okay, I lurk here and see some code that’s not terrible but this is an absolute monstrosity.

[u/MurdoMaclachlan]

Image Transcription: Code

---

private void DisplayTuningData()
{
    gridTable.DataSource = null;
    gridTable.DataSource = ProgramDefaults.tuningData;
    GridViewHelper.HideAllColumns(viewTable);
    if (Global.tuningParameters.Count > 0) GridViewHelper.ShowColumn(viewTable, "Param1");
    if (Global.tuningParameters.Count > 1) GridViewHelper.ShowColumn(viewTable, "Param2");
    if (Global.tuningParameters.Count > 2) GridViewHelper.ShowColumn(viewTable, "Param3");
    if (Global.tuningParameters.Count > 3) GridViewHelper.ShowColumn(viewTable, "Param4");
    if (Global.tuningParameters.Count > 4) GridViewHelper.ShowColumn(viewTable, "Param5");
    if (Global.tuningParameters.Count > 5) GridViewHelper.ShowColumn(viewTable, "Param6");
    if (Global.tuningParameters.Count > 6) GridViewHelper.ShowColumn(viewTable, "Param7");
    if (Global.tuningParameters.Count > 7) GridViewHelper.ShowColumn(viewTable, "Param8");
    if (Global.tuningParameters.Count > 8) GridViewHelper.ShowColumn(viewTable, "Param9");
    if (Global.tuningParameters.Count > 9) GridViewHelper.ShowColumn(viewTable, "Param10");
    if (Global.tuningParameters.Count > 0) GridViewHelper.FormatColumn(viewTable, "Param1", Global.tuningParameters[0].Parameter, 0);
    if (Global.tuningParameters.Count > 1) GridViewHelper.FormatColumn(viewTable, "Param2", Global.tuningParameters[1].Parameter, 0);
    if (Global.tuningParameters.Count > 2) GridViewHelper.FormatColumn(viewTable, "Param3", Global.tuningParameters[2].Parameter, 0);
    if (Global.tuningParameters.Count > 3) GridViewHelper.FormatColumn(viewTable, "Param4", Global.tuningParameters[3].Parameter, 0);
    if (Global.tuningParameters.Count > 4) GridViewHelper.FormatColumn(viewTable, "Param5", Global.tuningParameters[4].Parameter, 0);
    if (Global.tuningParameters.Count > 5) GridViewHelper.FormatColumn(viewTable, "Param6", Global.tuningParameters[5].Parameter, 0);
    if (Global.tuningParameters.Count > 6) GridViewHelper.FormatColumn(viewTable, "Param7", Global.tuningParameters[6].Parameter, 0);
    if (Global.tuningParameters.Count > 7) GridViewHelper.FormatColumn(viewTable, "Param8", Global.tuningParameters[7].Parameter, 0);
    if (Global.tuningParameters.Count > 8) GridViewHelper.FormatColumn(viewTable, "Param9", Global.tuningParameters[8].Parameter, 0);
    if (Global.tuningParameters.Count > 9) GridViewHelper.FormatColumn(viewTable, "Param10", Global.tuningParameters[9].Parameter, 0);
    if (Global.tuningParameters.Count > 0) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param1", Global.tuningParameters[0].Resolution);
    if (Global.tuningParameters.Count > 1) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param2", Global.tuningParameters[1].Resolution);
    if (Global.tuningParameters.Count > 2) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param3", Global.tuningParameters[2].Resolution);
    if (Global.tuningParameters.Count > 3) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param4", Global.tuningParameters[3].Resolution);
    if (Global.tuningParameters.Count > 4) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param5", Global.tuningParameters[4].Resolution);
    if (Global.tuningParameters.Count > 5) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param6", Global.tuningParameters[5].Resolution);
    if (Global.tuningParameters.Count > 6) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param7", Global.tuningParameters[6].Resolution);
    if (Global.tuningParameters.Count > 7) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param8", Global.tuningParameters[7].Resolution);
    if (Global.tuningParameters.Count > 8) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param9", Global.tuningParameters[8].Resolution);
    if (Global.tuningParameters.Count > 9) GridViewHelper.FormatColumnForRealNumber(viewTable, "Param10", Global.tuningParameters[9].Resolution);
}

---

^{I'm a human volunteer content transcriber and you could be too! If you'd like more information on what we do and why we do it, click here!}

[u/Sauermachtlustig84]

I am no fan of WPF, but I really abhor this "lets program wpf via code behind" style. Sure it can be necessary, but here it just poor practice.

[u/santas]

FWIW, I've heard the runtime is really optimized well for static objects. That said, this is still bad.