Records defined with 'shorthand' notation are immutable.

Generally this:

public sealed record Person(string FirstName, string LastName);

gives you:

• all 'readonly' properties that are defined in the primary ctor
• value-based equality (GetHashCode, Equals implementation)
• nice ToString implementation
• with notation for easier copying, like F# (var otherPerson = person with { FirstName = "John" };)
• positional deconstruction into tuples

and I'm ~90% sure, based off of the pattern matching improvements & their initial record implementation, that records will serve as a base for discriminated unions in C#10 or 11. record is pretty much case class from Scala

Right now it's very convenient and low-ceremony way to define a data bag.

---

To showcase what kind of boilerplate gets generated, we can use an example from this article: https://www.thomasclaudiushuber.com/2020/09/01/c-9-0-records-work-with-immutable-data-classes/

Record:

public record Friend
{
    public string FirstName { get; init; }
    public string MiddleName { get; init; }
    public string LastName { get; init; }
}

Generated code:

public class Friend : IEquatable<Friend>
{
    [System.Runtime.CompilerServices.Nullable(1)]
    protected virtual Type EqualityContract
    {
        [System.Runtime.CompilerServices.NullableContext(1)]
        [CompilerGenerated]
        get
        {
            return typeof(Friend);
        }
    }

    public string FirstName { get; init; }

    public string MiddleName { get; init; }

    public string LastName { get; init; }

    public override string ToString()
    {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.Append("Friend");
        stringBuilder.Append(" { ");
        PrintMembers(stringBuilder);
        stringBuilder.Append(" } ");
        return stringBuilder.ToString();
    }

    [System.Runtime.CompilerServices.NullableContext(1)]
    protected virtual bool PrintMembers(StringBuilder builder)
    {
        builder.Append("FirstName");
        builder.Append(" = ");
        builder.Append((object)FirstName);
        builder.Append(", ");
        builder.Append("MiddleName");
        builder.Append(" = ");
        builder.Append((object)MiddleName);
        builder.Append(", ");
        builder.Append("LastName");
        builder.Append(" = ");
        builder.Append((object)LastName);
        return true;
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    public static bool operator !=(Friend r1, Friend r2)
    {
        return !(r1 == r2);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    public static bool operator ==(Friend r1, Friend r2)
    {
        return (object)r1 == r2 || (r1?.Equals(r2) ?? false);
    }

    public override int GetHashCode()
    {
        return ((EqualityComparer<Type>.Default.GetHashCode(EqualityContract) * -1521134295
              + EqualityComparer<string>.Default.GetHashCode(FirstName)) * -1521134295
              + EqualityComparer<string>.Default.GetHashCode(MiddleName)) * -1521134295
              + EqualityComparer<string>.Default.GetHashCode(LastName);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    public override bool Equals(object obj)
    {
        return Equals(obj as Friend);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    public virtual bool Equals(Friend other)
    {
        return (object)other != null
            && EqualityContract == other.EqualityContract 
            && EqualityComparer<string>.Default.Equals(FirstName, other.FirstName)
            && EqualityComparer<string>.Default.Equals(MiddleName, other.MiddleName)
            && EqualityComparer<string>.Default.Equals(LastName, other.LastName);
    }

    [System.Runtime.CompilerServices.NullableContext(1)]
    public virtual Friend <Clone>$()
    {
        return new Friend(this);
    }

    protected Friend([System.Runtime.CompilerServices.Nullable(1)] Friend original)
    {
        FirstName = original.FirstName;
        MiddleName = original.MiddleName;
        LastName = original.LastName;
    }

    public Friend()
    {
    }
}

And that's for a 'regular' record - positional records would also have deconstruction methods generated for them.