I hate recent C# versions!

[PIEBALDconsult]

Yeah, still just trying to attract VB developers.

[Graeme_Grant]

PIEBALDconsult wrote:

Yeah, still just trying to attract VB developers.

I am seeing a lot of very old VB features creeping in. Probably for the Python crowd.

Graeme

---

"I fear not the man who has practiced ten thousand kicks one time, but I fear the man that has practiced one kick ten thousand times!" - Bruce Lee

[Chris Maunder]

No one is forcing you to use those new features unless you're working on a codebase that uses those new features. Things like

public readonly double Distance => Math.Sqrt(X * X + Y * Y);

are, for me, a matter of taste. Things like

public static bool IsLetterOrSeparator(this char c) =>
c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z') or '.' or ',';

give me stomach acid. A dev has saved a few keystrokes at the expense of structure. This

static Quadrant GetQuadrant(Point point) => point switch
{
(0, 0) => Quadrant.Origin,
var (x, y) when x > 0 && y > 0 => Quadrant.One,
var (x, y) when x < 0 && y > 0 => Quadrant.Two,
var (x, y) when x < 0 && y < 0 => Quadrant.Three,
var (x, y) when x > 0 && y < 0 => Quadrant.Four,
var (_, _) => Quadrant.OnBorder,
_ => Quadrant.Unknown
};

is meant to provide neat, compact code but I worry that for someone new to C# it becomes a stumbling block. My feeling is that it should be easy to switch between languages. Truly I wish there were only one language, but us humans are tribal and so that will never happen (and of course situations where a language needs to have specifics for the platform, hardware, compiler or programming methodology). Even so, making a language simpler is better, and adding syntactic sugar for the sake of it simply diverges the language. In many instances adding new features can converge languages. Javascript gaining the coalesce operator, C# getting the null-check. This is All Good. But like good art, they should add what they need and no more.

cheers Chris Maunder

[Richard Deeming]

Chris Maunder wrote:

public readonly double Distance => Math.Sqrt(X * X + Y * Y);

That would give you a CS0106 compiler error. :) You would need either:

public readonly double Distance = Math.Sqrt(X * X + Y * Y);

or:

public double Distance => Math.Sqrt(X * X + Y * Y);
Wrong: See William's post below.

Chris Maunder wrote:

c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z')

Well, of course, anyone serious about performance would write that as:

(uint)((c | 0x20) - 'a') <= 'z' - 'a'

:laugh: Source: Performance Improvements in .NET 7 - .NET Blog[^])

---

"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer

[Chris Maunder]

Richard Deeming wrote:

That would give you a CS0106 compiler error

That was copy and pasted from [What's new in C# 8.0 - C# Guide | Microsoft Docs](https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8) :-D

cheers Chris Maunder

[simpelman]

What about the ternary operator? You could argue that it doesn't make code more readable and not use it, but I guess you got somehow accustomed to it. (By the way: what is not to like about optional arguments or naming arguments?)

[NiL]

And what is a with statement

[Steve Naidamast]

Though I know C# very well, I stick with VB.NET simply because Microsoft is no longer updating the language with all the screwy constructs they keep adding to C#. Both languages are highly mature and no longer really need any new additions and have been that way for quite some time. However, Microsoft can't seem to let anything be even if it doesn't require MS engineers mucking about with it...

Steve Naidamast Sr. Software Engineer Black Falcon Software, Inc. blackfalconsoftware@outlook.com

[simpelman]

Yes! One language to rule them all

[Samuel Estrella C]

Hello, it’s true.

[Bruce Greene]

Agreed. C# is such an elegant language and well written C# code is understandable at a glance. Much of this new stuff is just WTF??

[William Rummler]

Richard Deeming wrote:

That would give you a CS0106 compiler error. :)

Not on a struct. :rose: Some C# features are intended mostly or solely to try to help produce more readable code. But some (like the readonly modifier on structs and their members) exist because they allow increased performance and/or compiler-enforced constraints against unintended usages of objects and their members. All that said, I have definitely seen (fine, I'll admit it, sometimes even written :~) code that goes overboard with the more concision-focused syntax that OP mentions. Doesn't help that VS is constantly underlining anything that can be converted to a ternary or expression-bodied member. X| Don't get me wrong, these two things have their place, and the corresponding auto-fixes should be right there in the editor context menu, but their possibility shouldn't trigger the code underlining... :java:

[Andre_Prellwitz]

There is often a trade-off between succinctness and clarity. It's not always about "saving a few keystrokes"; sometimes it's about removing nonessential details, or better expressing intent, or allowing a developer to (literally) see the whole picture, or increase speed of understanding. Other times we see features added that have proved valuable in other languages or platforms.

[jochance]

First, they came for the types (var) and noone said anything... Haha. I disagree on the named/optional and the discards, mostly on the point of "unreadable". These both make code more legible as opposed to maybe more succinct like your other examples.

[David On Life]

Actually, I like and use many of the new enhancements. Some of them are real time savers, for example: ``` int x = foo?.bar?.index?[y] ?? 0; ``` versus: ``` int x = 0; if (foo != null && foo.bar != null && foo.bar.index != null && foo.bar.index[y] != null { x = foo.bar.index[y]; } ``` Not only was the new style code shorter and easier to write, but I would assume that it compiles down to a more efficient form because it doesn't have to keep re-evaluating the entire list of object references / pointers and only assigns a value to `x` once. Of course, I could write the second version to use a bunch of temporary variables and theoretically get close to the same performance, but then it would grow to be many more lines long... and still contain a bunch of redundant assignments to `x` that would be hard to eliminate unless I turned it into a local function (that's a lot of extra code authoring versus the nice simple, efficient, single line). I also think the first version is easier to read. I like the simplicity of a single `?` for a null check and the double `??` for a default value. I've also used the is/as construct as a time saver and really like some of the new switch statement options and scoping, and some of the new code shortcuts (like using `get => x;` instead of `get { return x; }` I particularly like putting them together for properties, for example writing `public int count { get => mylist?.Count ?? 0; }` is a lot easier (and clearer) than having to write out the null check. And while it might take a little bit to get used to, it's fairly intuitive (if I'd never seen it before, I'm pretty sure I'd still be able to figure out what it means just by the context). I can't say I'm a fan of every change, and I tend to lag (if only because I don't like to depend on the latest compiler when I'm working on a team, I try to give everyone time to get on the new compiler). However, the compiler hints do often push me toward the new options when it suggests them as ways to 'improve' my code... (sometimes I like that, and sometimes I don't...)

[Dave B 2022]

As you learn more languages, you start to see where the C# developers copy all of their "innovations" from. They do it if it fits or not and if it makes sense or not. Sometimes they adopt the concept, but need to tweak the implementation in such a way, it loses a significant bit of the value it had in the original language. Global usings predefined by project type are my current favorite example. It seems like a matter of pride that C# has practically every feature they have seen in another language that they could make "work". The "magic" they add to the language allows someone to write far more logic in fewer strokes and a reader of the code has to understand exponentially more about the project type, all referenced libraries, and the code in every file if it looks relevant or not. With "global using" statements and extension methods, reading C# code snippets on line or even complete files can be somewhat meaningless without significant additional documentation describing the code.

[PIEBALDconsult]

Something C# doesn't have. And which I find useless in lesser languages.

[jochance]

Yeah, I think the global usings as well as ditching some of the boilerplate for a shorter "Hello World!" probably falls under the Geneva Convention or some kind of human rights UN charter but I haven't figured out how to bring a case yet. Some noob trying to learn: "args[]? what args[]? wth is args[]? is that a keyword? a variable?! but where...? huh? who thought this was ok?"

[ShawnVN]

I'm ok with some of the simple quality-of-life things like null coalescing, and switch expressions. But a lot of it (compiler and runtime lib) has all gone a bit too far in the direction of high-level / functional programming. The beauty of C# was that it had much of the speed and efficiency of a low-level lang, with high-level niceties like GC, immutable strings and bounds-checked arrays (all of which happen to be important for security). But now code is riddled with anonymous function callbacks and linq expressions which can be 30x slower and consume more heap, than equivalent old school C#. And harder to read, sometimes, yes. I think it's a generational rotation, from devs whose first language was C/C++, to devs whose first programming language was javascript.

[Member_5893260]

I like some of it. It's useful to be able to say something like

string x = Person?.Name ?? "";

and for me, that's quite easy to read. There are other bits which are sort of ghastly, though. Basically, I don't like anything which, to me, isn't totally context-insensitive, or where I can't tell what the compiler's quite going to do with it (which is why I hate Linq). It's all quite interesting, though. As a language, C# is becoming so laden with syntactic sugar that at this point, it's actually idiomatic, which is fascinating for a programming language: until now, I'd always considered idiom as something restricted to spoken, human languages.