Using F# type extensions in C#

[ernestasjuska]

Hi,

I found that F# class library generates weird method names like Thing.get_Texture which are not discoverable in C# unless using reflection.

F# code:

// NOTE: Extending Thing with things that weren't "available" where it was defined.
module ThingExtensions =
    type Thing with
        member this.Texture =
            match this with
            | A -> "smooth"
            | B -> "rough"
            | C -> "smooth"

Assembly C# code - the method name is literally Thing.get_Texture:

// ThingsLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// ThingsLibrary.ThingExtensions
using Microsoft.FSharp.Core;
using ThingsLibrary;

[CompilationMapping(SourceConstructFlags.Module)]
public static class ThingExtensions
{
	[CompilationArgumentCounts(new int[] { 1, 0 })]
	public static string Thing.get_Texture(Thing P_0)
	{
		return P_0.Tag switch
		{
			1 => "rough", 
			2 => "smooth", 
			_ => "smooth", 
		};
	}
}

So to use property Texture from C# I ended up doing:

public static class ThingExtensionsFix
{
    private static readonly MethodInfo _getThingTextureMethodInfo =
        typeof(ThingExtensions).GetMethods().First(x => x.Name == "Thing.get_Texture");

    extension(Thing @this)
    {
        public string TextureFix => (string)_getThingTextureMethodInfo.Invoke(null, [@this])!;
    }
}

Source code: https://github.com/ernestasjuska/FSharpIssues.TypeExtensionsDemo

Are there already some solutions for this: like asking F# compiler more nicely or maybe a polyfill for C# end? My quick google and annoying Copilot gave results like dump everything into single file. I don't want that.

Thanks.

[Happypig375]

C# currently does not support extension properties. You need to either define them as C#-style extension methods using [<Extension>] or define them within the same module as the type being extended such that they are not compiled as external F# type extensions.

[ernestasjuska]

Yes, this also works, but that is basically my current solution just pushed to F# end. And it does not use new extension members syntax which came out more than half year ago (C# 14, .Net 10, November 11, 2025).

    open System.Runtime.CompilerServices

    [<Extension>]
    type ThingExtensionMethods =
        [<Extension>]
        static member GetTexture(x: Thing): string = x.Texture

Console.WriteLine($"  TextureExtension: {thing.GetTexture()}");

Probably, I will make a F# type provider for this. The new extension members don't seem to use any new magic - just more attributes:

// TypeExtensionsDemo, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// ThingExtensionsFix
using System;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using ThingsLibrary;

public static class ThingExtensionsFix
{
	[SpecialName]
	public sealed class <G>$CB1060B9B8E6E0CF4796D8D9F652B67F
	{
		[SpecialName]
		public static class <M>$9E407C5424B735E28A38DE95816358BC
		{
		}

		[ExtensionMarker("<M>$9E407C5424B735E28A38DE95816358BC")]
		public string TextureFix
		{
			[ExtensionMarker("<M>$9E407C5424B735E28A38DE95816358BC")]
			get
			{
				throw new NotSupportedException();
			}
		}
	}

	private static readonly MethodInfo _getThingTextureMethodInfo = typeof(ThingExtensions).GetMethods().First((MethodInfo x) => x.Name == "Thing.get_Texture");

	public static string get_TextureFix(Thing @this)
	{
		return (string)_getThingTextureMethodInfo.Invoke(null, new object[1] { @this });
	}
}

It sems generated F# will not do - the problem is the second special name class. F# does not allow nesting types.

So the only other ways are C# source code generator or postprocessing F# assembly to inject C# extension member classes.