5

C# 9 added the record type, which is a new reference type that uses value-based equality.

C# 10 introduced the record struct syntax to define a value type with similar properties to record (https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record).

It seems unusual to create a value type version of a type that was created to be a reference type that also has value-based equality - that would surely remove most of the benefit of using the type.

Why would you ever want to declare a record struct?

Is there something more that I am missing?

YungDeiza
  • 3,128
  • 1
  • 7
  • 32
  • 2
    Another SO thread might help a bit https://stackoverflow.com/questions/64816714/when-to-use-record-vs-class-vs-struct – N Subedi Dec 22 '22 at 18:22
  • 3
    Check this article: https://nietras.com/2021/06/14/csharp-10-record-struct/ (note also that record struct is not immutable. readonly record struct is) – Evk Dec 22 '22 at 19:00
  • @NirmalSubedi already checked, it doesn't help as I'm talking about a ```record struct``` not a plain ```record``` or ```struct``` – YungDeiza Dec 22 '22 at 19:08
  • 3
    Read the article from Evk, and check the second code snippet. That's alone enough to introduce this. That's a very common code construct, and removing tons of boilerplate code is a plus. But see also [this article](https://anthonygiretti.com/2021/08/03/introducing-c-10-record-struct/) - there are lots of other tiny, seemingly irrelevant, additions, which when gathered together form a very handy tuple-like utility, more handy than the current several tuple types. – quetzalcoatl Dec 22 '22 at 20:08
  • @quetzalcoatl the second code snippet doesn't really justify a meaningful purpose for ```record struct```. Using a new type just to reduce code isn't really sensible- improved syntax would make more sense. Also since tuples exist, shortening code is not really a good reason to use ```record struct```. Will study the rest of the articles to see what else there is. – YungDeiza Dec 24 '22 at 13:16
  • 3
    "Using a new type just to reduce code isn't really sensible- improved syntax would make more sense." But that's exactly what `record` does. It does *not* introduce new types, it introduces a new way to write `class` and `struct` declarations with autogenerated boilerplate. Mere syntax cannot be retrofitted to make existing classes or structs behave this way, that would be far too complicated -- and changing how tuples work, while possible in principle, is a passed station since large amounts of existing code count on their existing behavior. – Jeroen Mostert Dec 24 '22 at 13:18
  • @JeroenMostert false, ```record``` has different properties to ```class``` and ```struct```. It is not just a way of declaring existing types with autogenerated code. Also there are many cases where new syntax and functionality has been added with existing types (usually using keyword to modify behaviour) so I'm not sure what you mean. – YungDeiza Dec 24 '22 at 13:40
  • 2
    Well, I'm not sure what *you* mean. Every `record class` is a `class`. Every `record struct` is a `struct`. (A plain `record` is equivalent to `record class`.) All .NET languages are capable of consuming records, even if they have no explicit support for them, precisely by virtue of the fact that records do not extend the .NET type system. It is possible to write types that behave identically to any given `record` declaration, with the only difference being that your members would not have a `[CompilerGenerated]` attribute. – Jeroen Mostert Dec 24 '22 at 13:45
  • 1
    OK, I guess I need to walk that statement back a *little* bit -- a `with` expression only works with records specifically because it looks for a compiler-generated `Clone` method. Since you can't declare such a method yourself, this is the one aspect where records are distinguishable from non-records on the language level. (Although this argument specifically only applies to `record class`es and does not apply to `record struct`s, since `with` works on all structs.) – Jeroen Mostert Dec 24 '22 at 13:56
  • @JeroenMostert according to the docs ```record``` is a new reference type, ```record class``` is the same plain ```record``` - the syntax just makes it clear that it's reference type. ```record struct``` is a ```record``` that is value type: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/records – YungDeiza Dec 24 '22 at 13:59
  • 2
    *All* structs are value types, so yes, that obviously includes `record struct`s as well. And indeed, `record` is the same thing as `record class` now. Nothing of that invalidates what I said. The docs are misleading to the point of being incorrect when they talk of `record`s as "a new reference type that you can create instead of classes or structs"; records wouldn't be half as useful if they weren't also plain old classes to existing code! Value-based equality and immutability can be implemented on classes manually, it's just tedious. `record` eliminates this tedium. – Jeroen Mostert Dec 24 '22 at 14:04
  • 1
    Correct. Record-struct is a value-type. [ref](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/records) - note how in "C# 9 introduces records, a new reference type that you can create instead of classes or structs. C# 10 adds record structs so that you can define records as value types. Records are distinct from classes in that record types use value-based equality. " the first sentence says RECORD, second RECORD-STRUCT and then third again refers to RECORD (not record struct). Gosh, they could have ordered those sentence a bit better. – quetzalcoatl Dec 25 '22 at 10:37
  • @JeroenMostert having had time to go through the articles, I'm starting to see what you and quetzalcoatl meant. The Microsoft documentation mislead me a bit. Will try to write an answer summarising what you've both explained with some added info from the articles. – YungDeiza Dec 28 '22 at 11:16
  • 1
    @quetzalcoatl beginning to understand you and Jeroen Mostert now and have added an answer. Thanks for you help, both of you. – YungDeiza Dec 28 '22 at 11:53
  • 1
    Related: [When to use record struct instead of struct, and vice versa?](https://stackoverflow.com/questions/74167979/when-to-use-record-struct-instead-of-struct-and-vice-versa) The real question is not *"Why would you ever want to declare a record struct?"*, but more like *"Why wouldn't you always want to declare a record struct?"*, because record structs are seemingly better than structs. – Theodor Zoulias Dec 28 '22 at 12:15

1 Answers1

8

The main benefits of using record struct are as follows:

  1. It allows you to simplify a struct definition to a single line
  2. It provides overloads for the == and != operators, so these can be used for comparisons with no extra code to define the operator overloads. With struct, you can only do comparisons using the Equals() method by default.
  3. It provides a more comprehensive default ToString() method than struct. The record struct ToString() method will produce the record struct name, the names of its properties and their values. The struct default ToString() method only produces the struct name.
  4. It provides performance benefits over struct (up to 20 times faster - https://anthonygiretti.com/2021/08/03/introducing-c-10-record-struct/)

In some ways, record is similar to a value tuples which provide default operator overloads and have a ToString() method that is closer to record struct (value tuples' ToString() method produces the values of all of their properties).

However, value tuples are only used on the fly, whereas record struct can be used to define type that will be repeatedly used.

Note

record / record class is immutable by default but record struct is not, so if you want an immutable record struct, you must use readonly record struct.

Final Remark

Considering the benefits of using record struct over struct, it's probably best to always prefer record struct unless there is some very specific reason not to.

It seems that record struct is an enhancement of struct, leaving the old type so that existing behaviour/functionality of struct is not removed.

YungDeiza
  • 3,128
  • 1
  • 7
  • 32
  • 2
    FYI, for those that stumbled upon this post like I did: The performance increase is only apparent if you DON'T implement IEquatable and GetHashCode on your struct. This is even mentioned in the benchmark. Also, you may get a very, very, slight performance improvement if you implement things on struct yourself. The actual page for the benchmark is here: https://nietras.com/2021/06/14/csharp-10-record-struct/ So, my recommendation is to use whatever is most convenient for you and your needs (e.g. performance/control, use a struct, otherwise use a record) – Mike Jul 26 '23 at 04:49
  • @Mike my aim was not to encourage its use but more to find reasons for its existence and state them. As always , one should weight up their needs and choose what's best instead of automatically trying to optimise everything they can possibly think of – YungDeiza Jul 26 '23 at 16:36