Since when did they add ragebait to C#, because WHAT IS THIS

[u/Verpa11]

[u/vanteli]

char c = 'A'; string s = $"{c}";

.ToString(); is for weak willed men and communists

[u/jordansrowles → u/vanteli]

String interpolation calls ToString under the hood, cant call yourself strong willed if you add a middleman. Everyone knows real men are explicit

string s = new string(c, 1);

[u/prehensilemullet → u/jordansrowles]

It boggles my mind that someone would decide to capitalize all member names but not all builtin class types 

Edit: apparently string is a builtin keyword alias for System.String.  I never felt the need for such shenanigans in Java

[u/jordansrowles → u/prehensilemullet]

For your edit - its just because C# sits above the runtime, and uses that as its "source of truth", and the language team wanted a shorthand for some of the primitive types. Makes a little more sense when you look at the int (even though theyre structs in the CLR. System.Int32 is int, System.Int64 is long, System.Int16 is short

[u/prehensilemullet → u/jordansrowles]

Java has interchangeable runtimes too, but they didn’t seem to have a problem standardizing java.lang.String so I still don’t really get it

Also, from what I google, strings aren’t actually considered primitive types, since String is a class, not a struct.  Has the string keyword created confusion about what a primitive is?

[u/jordansrowles → u/prehensilemullet]

Its more cosmetic/syntactic sugar rather than anything semantic. Java standardised String because that's the actual class name. There is no split between System.String and string, its the same underlying CLR types. If the same were to exist in Java, these would be interchangeable (and be the same in bytecode)

java str name = "Jordan"; java.lang.String name = "Jordan";

[u/prehensilemullet → u/jordansrowles]

In Java, classes in java.lang are always in scope.  Did they not do this for System in C#?  Maybe that’s the issue…

[u/jordansrowles → u/prehensilemullet]

Before modern .NET we had to do

csharp using System;

If we wanted String (otherwise youd need to write System.String). But using the string keyword has never required us to bring System into scope.

Nowadays we have implicit usings, so pretty much most of the commonly used System.* namespaces are automatically included

[u/prehensilemullet → u/jordansrowles]

Yeah I bet if they had just automatically included it from the beginning of C# they would have never made a string keyword

[u/jordansrowles → u/prehensilemullet]

As for your edit: ìnt is a value type, string or String is indeed a reference type, and isn't what would be called a normal primitive. It's primitive-like, because it's immutable (this was before we had the record type) it's treated like a primitive. The same reason why System.Object/object is considered a primitive-like object. String and Object are the only exceptions, the rest are structs (int, byte, float, double, bool, char) but these also have a CLR type (System.Int, System.Byte, System.Boolean, ...)

[u/prehensilemullet → u/jordansrowles]

In Java I don’t think anyone thinks of String as a primitive, even though it’s immutable.  So if people think of string as a primitive-like thing in C#, I think the use of the keyword has distorted people’s perception in a Sapir-Whorf Hypothesis kind of way

[u/jordansrowles → u/prehensilemullet]

I should have put more emphasis on the primitive-like, because its an immutable built-in type with full language syntax support, not an actual primitive, like char. C# is special in that String (a reference type) is treated (and behaves) like a value type

[u/prehensilemullet → u/jordansrowles]

Behaves like a value type in the sense of == comparing contents or what?

I see that C# supports operator overloading now though, so I guess that’s not unique to strings either

[u/jordansrowles → u/prehensilemullet]

Yeah so for == reference types compare to see if theyre the same object in memory. String by default overrides == (we have operator overloading/overwriting) and Equals() to compare its actual content, which is more value type. The runtime also has string interning which is a pool of string literals for performance. Syntactically its also literal like the primitives

var name = "Jordan"; // no new String()

[u/dominjaniec → u/prehensilemullet]

well... anyone can define class String {}

[u/prehensilemullet → u/dominjaniec]

I had a zero problems with that in my Java days

[u/AlwaysHopelesslyLost → u/prehensilemullet]

It isn't about whether you have had the problem. It is a simple and idiomatic way to be absolutely sure things are working like you expect. Coding is all about using accurate grammar for precise meaning.

[u/moriturus_m → u/jordansrowles]

except that bypasses internalization (iirc?)

[u/SnooOpinions6959 → u/jordansrowles]

This probably also calls .to string() under the hood but I wanted to share it char c = 'c'; string s = "" + c;

[u/Helen83FromVillage → u/vanteli]

You can also do this:

1. Write a C++ function taking a char and returning a string.
2. Call it.

[u/lomberd2 → u/Helen83FromVillage]

You could also use bash or god forbid powershell

[u/BobQuixote → u/lomberd2]

Python > PowerShell > Bash > Batch

[u/lomberd2 → u/BobQuixote]

Python > PowerShell > Bash > Batch > 💩 ?

[u/BobQuixote → u/lomberd2]

Batch: It's better than shit.

[u/YTriom1 → u/BobQuixote]

Bash's superior to PowerShell imho

[u/WildCard65 → u/YTriom1]

I mean PowerShell gives you the full power of C# and dotNET runtime from the scripting side.

[u/BlankMercer → u/BobQuixote]

fish supremacy

[u/duck1123 → u/BobQuixote]

Nushell > Python

[u/Doug2825 → u/Helen83FromVillage]

You can also pass a pointer to a lone char to a function that expects a pointer to a null terminated string

[u/bookaddicta → u/vanteli]

Dang, guess now I’m forced to use .ToString();

[u/LegendarySoda]

Bro you just need new string('s') or "s"

[u/Some-Passenger4219]

I object to that argument.

[u/recursion_is_love]

Weak as in weak-type. vs. Strong as in strong-type.

I better use dynamic type because I don't want to think before I write code.

[u/gameplayer55055]

I still can't understand that.

You can't cast a char to the string

But 1+'1' will happily be compiled to 11 like in the js meme.

I think the truth is that char is 8 bit and string is 16 bits per character. And MS decided to not add implicit cast to avoid byte fuckery errors.

[u/gameplayer55055 → u/gameplayer55055]

UPD: I was wrong.

C# char is secretly ushort (16 bit too). BUT it is a value type while string is a reference type.

1+'1' will be compiled to 50, and 1+"1" is 11 because of some operator overload trickery.

[u/prehensilemullet → u/gameplayer55055]

I was gonna say that would be a world of problems if a char was a byte

[u/WildCard65 → u/gameplayer55055]

Its actually more similar to Windows' wchar_t type which is for UTF-16 strings.

[u/rilimini381]

Just make words with an array of chars

[u/Hot-Employ-3399]

This is called a common sense. Char is not a string. Fuck auto conversion. MLs got it right not allowing even float <-> int implicit casting 

[u/Relative-Bottle-8498]

char c = 'x';
string s = String.Concat(Enumerable.Repeat(c, 1));