Struct Inheritance (No Polymorphism)

[HitalloExiled]

Struct Inheritance in C#

Summary

A proposal to introduce compile-time struct inheritance in C#, allowing structs to inherit fields and methods from other structs through a compile-time expansion mechanism that maintains the flat memory layout and value semantics of structs while reducing code duplication.

Motivation

Currently, C# structs cannot inherit from other structs, only implement interfaces. This restriction simplifies memory layout and runtime behavior, but it creates boilerplate in scenarios where one struct conceptually extends another (e.g., Vector2 → Vector3). Developers often repeat the same fields and methods across related structs. This feature would reduce code duplication while maintaining the performance characteristics of value types.

---

Detailed design

Syntax

struct Vector2 : Vector3
{
    public float X;
    public float Z;
}

struct Vector3 : Vector2
{
    public float Z;
}

Key Characteristics

1. Compile-Time Expansion

   • Derived structs copy fields and methods from the base struct at compile time.
   • No runtime polymorphism is introduced; layout remains flat.

2. Overrides

   • Methods can be overridden.
   • If a derived method calls base.Method(), the compiler can emits a hidden renamed copy of the base method (e.g., <>MethodName) to preserve access or just inline it.
   • Base methods are only emitted if referenced via base. to reduce unnecessary metadata.

3. Operators

   • Operators in the base struct are inherited.

4. Attributes

   • Attributes on base fields or methods propagate to derived structs.

5. Constructors

   • Derived structs must explicitly invoke a base constructor; otherwise, a compile-time error occurs. Follows class constructor rules.

6. Layout Restrictions

   • Base structs with [StructLayout(LayoutKind.Explicit)] cannot be inherited.
   • Derived structs cannot override StructLayout.

7. Explicit Conversion Operator

   • An automatic explicit operator is generated for converting derived structs to their base type.

---

Examples

Simple Vector

struct Vector2
{
   public float X;
   public float Y;
}

struct Vector3 : Vector2
{
   public float Z;
}

// Desugar to

struct Vector3
{
   public float X;
   public float Y;
   public float Z;
}

Method Override

struct Vector2
{
    public float X;
    public float Y;

    public virtual float Length() => MathF.Sqrt(X * X + Y * Y);
}

struct Vector3 : Vector2
{
    public float Z;

    public override float Length() => MathF.Sqrt(X * X + Y * Y + Z * Z);
}

// Desugared to
struct Vector3
{
    public float X;
    public float Y;
    public float Z;

    public float Length() => MathF.Sqrt(X * X + Y * Y + Z * Z);

    public static explicit operator Vector2(Vector3 v) => new Vector2 { X = v.X, Y = v.Y };
}

// Since no `base.` calls exist, hidden base methods are not emitted:

Method Override With Base Call

struct Plane
{
    public float Width;
    public float Height;

    public virtual float GetArea() => Width * Height;
}

struct Box : Plane
{
    public float Depth;

    public override float GetArea() => base.GetArea() * Depth;
}

// Desugared to

struct Box
{
    public float Width;
    public float Height;
    public float Depth;

    private float <>Plane_GetArea() => Width * Height;

    public float GetArea() => <>Plane_GetArea() * Depth;

    public static explicit operator Plane(Box v) => new Plane { Width = v.Width, Height = v.Height };
}

// Hidden base methods are emitted only if referenced.

---

No Polymorphism

This proposal does not introduce polymorphism. Struct inheritance here is strictly a compile-time code reuse feature—derived structs are not subtypes of their base structs, and there is no runtime substitutability or dynamic dispatch.

• A derived struct is not a subtype of its base struct.

• You cannot assign a derived struct to a base struct variable without an explicit conversion.

• The following is not allowed:

  Vector2 v = new Vector3(); // Error: Cannot implicitly convert
  Vector2 v = (Vector2)new Vector3(); // OK: explicit conversion

• There is no runtime polymorphism: method dispatch and field access are always static and resolved at compile time.

---

Drawbacks

1. Semantics can lead developers to expect runtime polymorphism

Alternatives

1. Status Quo: Continue using interface implementation and code duplication.
2. Source Generators: Automate boilerplate, but can't ensure memory layout.
3. Composition over Inheritance: Encourage using composition patterns instead.

Impact of not doing this:

• Continued code duplication in struct-heavy codebases
• Reduced developer productivity when working with related value types

Open questions

1. Should non auto properties allow override?
2. Should it support abstract structs?

[HaloFour]

See: #6270

[333fred]

Closed as a duplicate.

[HitalloExiled]

I saw this one, but I didn't know if I could propose a new direction there.

[CyrusNajmabadi]

Source Generators: Automate boilerplate, but can't ensure memory layout.

What does this mean?

[HitalloExiled]

Source generator relies on partial. We can't control how this partials are merged.

What output should I expect of this?

// Vector3.cs
partial struct Vector3
{
    public float Z;
}

// Vector3.g.cs
partial struct Vector3
{
    public float X;
    public float Y;
}

I suspect it depends on the order in which the compiler collects these files.

An structure generated like this does not match expectations and may break some routines that strictly depend on the layout, such as interop.

partial struct Vector3
{
    public float Z;
    public float X;
    public float Y;
}

[HaloFour]

The source generator could rely on you to embed the struct and then generate delegating members and conversion operators.

[HitalloExiled]

Yes, something like this could solve most use cases.

But I still think it's a valid need, and that the solution being part of the language would ensure proper use.

namespace Test
{
    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
    public class ForwardAttribute : Attribute;

    namespace V0
    {
        public struct Vector2
        {
            public float X;
            public float Y;

            public readonly float Lenght() => MathF.Sqrt((this.X * this.X) + (this.Y * this.Y));
        }

        public partial struct Vector3
        {
            [Forward]
            public Vector2 XY;

            public float Z;
        }

        // Generates
        public partial struct Vector3
        {
            public float X
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                readonly get => this.XY.X;

                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                set => this.XY.X = value;
            }

            public float Y
            {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                readonly get => this.XY.Y;

                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                set => this.XY.Y = value;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            public readonly float Lenght() => this.XY.Lenght();

            public static explicit operator Vector2(Vector3 vector) => vector.XY;
        }
    }

    namespace V1
    {
        public struct Vector2
        {
            public float X;
            public float Y;

            public readonly float Lenght() => MathF.Sqrt((this.X * this.X) + (this.Y * this.Y));
        }

        // Generated
        public struct Vector3
        {
            [Forward]
            public Vector2 XY;

            public float Z;

            // ---------------------------------

            public float X { readonly get => this.XY.X; set => this.XY.X = value; }
            public float Y { readonly get => this.XY.Y; set => this.XY.Y = value; }

            public readonly float Lenght() => this.XY.Lenght();

            public static explicit operator Vector2(Vector3 vector) => vector.XY;
        }

        public struct Plane
        {
            public float X;
            public float Y;

            public readonly float GetArea() => this.X * this.Y;
        }

        // Generated
        public struct Box
        {
            [Forward]
            private Plane plane;

            public float Z;

            // ---------------------------------

            public float X { readonly get => this.plane.X; set => this.plane.X = value; }
            public float Y { readonly get => this.plane.Y; set => this.plane.Y = value; }

            public readonly float GetArea() => this.plane.GetArea() * this.Z;

            public static explicit operator Plane(Box box) => box.plane;
        }
    }

    namespace V2
    {
        public struct Vector2
        {
            public required float X;
            public required float Y;

            public Vector2(float x, float y) =>
                (this.X, this.Y) = (x, y);

            public readonly float Lenght() => MathF.Sqrt((this.X * this.X) + (this.Y * this.Y));
        }

        // Generated
        public struct Vector3
        {
            [Forward]
            public Vector2 XY;

            public float Z;

            // ---------------------------------

            public float X { readonly get => this.XY.X; set => this.XY.X = value; }
            public float Y { readonly get => this.XY.Y; set => this.XY.Y = value; }

            // Override
            public readonly float Lenght() => this.XY.Lenght() + (this.Z * this.Z);

            public static explicit operator Vector2(Vector3 vector) => vector.XY;
        }
    }

    namespace V3
    {
        public struct Vector2
        {
            public float X { get; set; }
            public float Y { get; set; }

            public readonly float Lenght() => MathF.Sqrt((this.X * this.X) + (this.Y * this.Y));
        }

        // Generated
        public struct Vector3
        {
            [Forward]
            public Vector2 XY;

            public float Z;

            // ---------------------------------

            public float X { readonly get => this.XY.X; set => this.XY.X = value; }
            public float Y { readonly get => this.XY.Y; set => this.XY.Y = value; }

            // Override
            public readonly float Lenght() => this.XY.Lenght() + (this.Z * this.Z);

            public static explicit operator Vector2(Vector3 vector) => vector.XY;
        }
    }

    namespace V4
    {
        public readonly struct Vector2
        {
            public float X { get; }
            public float Y { get; }

            public Vector2(float x, float y) =>
                (this.X, this.Y) = (x, y);

            public readonly float Lenght() => MathF.Sqrt((this.X * this.X) + (this.Y * this.Y));
        }

        // Generated
        public readonly struct Vector3
        {
            [Forward]
            public readonly Vector2 XY;

            public readonly float Z { get; }

            // ---------------------------------
            public readonly float X => this.XY.X;
            public readonly float Y => this.XY.Y;

            public Vector3(float x, float y, float z)
            {
                this.XY = new(x, y);

                this.Z = z;
            }

            // Override
            public readonly float Lenght() => this.XY.Lenght() + (this.Z * this.Z);

            public static explicit operator Vector2(Vector3 vector) => vector.XY;
        }
    }

    namespace V5
    {
        public readonly struct Vector2
        {
            public float X { get; init; }
            public float Y { get; init; }

            public readonly float Lenght() => MathF.Sqrt((this.X * this.X) + (this.Y * this.Y));
        }

        // Generated
        public struct Vector3
        {
            [Forward]
            public readonly Vector2 XY;

            public float Z;

            // ---------------------------------

            public readonly float X => this.XY.X;
            public readonly float Y => this.XY.Y;

            public Vector3(float x, float y, float z)
            {
                this.XY = new()
                {
                    X = x,
                    Y = y,
                };

                this.Z = z;
            }

            // Override
            public readonly float Lenght() => this.XY.Lenght() + (this.Z * this.Z);

            public static explicit operator Vector2(Vector3 vector) => vector.XY;
        }
    }

    public static class Playground
    {
        public static void Main()
        {
            var vectorV1 = new V1.Vector3
            {
                X = 1,
                Y = 2,
                Z = 3,
            };

            ref var xV1 = ref vectorV1.XY.X;
            ref var yV1 = ref vectorV1.XY.Y;
            ref var zV1 = ref vectorV1.Z;

            var vectorV2 = new V2.Vector3
            {
                X = 1,
                Y = 2,
                Z = 3,
            };

            ref var xV2 = ref vectorV2.XY.X;
            ref var yV2 = ref vectorV2.XY.Y;
            ref var zV2 = ref vectorV2.Z;

            var vectorV3 = new V3.Vector3
            {
                X = 1,
                Y = 2,
                Z = 3,
            };

            ref var xyV3 = ref vectorV3.XY;
            ref var zV3  = ref vectorV3.Z;

            var vectorV4 = new V4.Vector3(1, 2, 3);

            var _vectorV5 = new V5.Vector3
            {
                X = 1, // Error
                Y = 2, // Error
                Z = 3,
            };

            // Alternative - Rely on constructor
            var vectorV5 = new V5.Vector3(1, 2, 3);
        }
    }
}