How do I make anonymous class implementing an interface with std only?

Question

Here is a sample Scala code that I'm trying to rewrite in C#:

trait FuncHolder[T, TResult] {
  def Value: Function1[T, TResult]
}

object FuncHolder {
  def GetFunctionHolder[T, TResult](func: Function1[T, TResult]) = new FuncHolder[T, TResult] {
    override def Value: Function1[T, TResult] = func
  }
}

Here is where I started:

public abstract class FuncHolder<T, TResult>
{
    public Func<T, TResult> Value { get; }

    protected FuncHolder(Func<T, TResult> value)
    {
        Value = value;
    }
}


public static class FuncHolder
{
    public static FuncHolder<T, TResult> GetFuncHolder<T, TResult>(Func<T, TResult> func)
    {
        var ilBody = func.Method.GetMethodBody().GetILAsByteArray();
    } 
}

But then I stuck because I'm not sure if I could just copy that byte array in il.emit and it will work. So I thought maybe in 2019 there could be some ways in acheiving it without dirty magic, postsharping output binaries or something. I'm looking for a pure solution in terms of BCL and Expressions/DynamicMethods.

The most recent attempt is following:

public abstract class FuncHolder<T, TResult>
{
    public abstract TResult GetResult(T value);
}

public static class FuncHolder
{
    private static ModuleBuilder _builder = AssemblyBuilder
        .DefineDynamicAssembly(new AssemblyName("OmsCodegen"), AssemblyBuilderAccess.Run)
        .DefineDynamicModule("MainModule");

    /// <summary>
    /// Returns a holder that allows safely pass delegates through the network
    /// </summary>
    /// <param name="func">Func to hold. Note that it must be pure function, closure with external dependencies will fail</param>
    public static FuncHolder<T, TResult> GetFuncHolder<T, TResult>(Func<T, TResult> func)
    {
        var tb = _builder.DefineType($"<{func.Method.MetadataToken}>__FuncHolder", TypeAttributes.Class | TypeAttributes.Sealed);
        tb.SetParent(typeof(FuncHolder));
        var baseMethod = typeof(FuncHolder<,>).GetMethod("GetResult");
        Debug.Assert(baseMethod != null);
        var implementation = tb.DefineMethod(baseMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual);
        CopyIl(implementation, func.Method);
        tb.DefineMethodOverride(implementation, baseMethod);
        tb.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName |
                                    MethodAttributes.RTSpecialName);
        return (FuncHolder<T, TResult>) Activator.CreateInstance(tb.CreateTypeInfo().AsType());
    }

    private static void CopyIl(MethodBuilder implementation, MethodInfo methodInfo)
    {
        var ilGenerator = implementation.GetILGenerator();
        var methodBody = methodInfo.GetMethodBody();
        var il = methodBody?.GetILAsByteArray() ?? throw new InvalidOperationException("Cannot get method body");

        foreach (var local in methodBody.LocalVariables)
            ilGenerator.DeclareLocal(local.LocalType);

        var opCodes = GetOpCodes(il);
        for (int i = 0; i < opCodes.Length; ++i)
        {
            if (!opCodes[i].code.HasValue)
                continue;
            OpCode opCode = opCodes[i].code.Value;
            if (opCode.OperandType == OperandType.InlineBrTarget)
            {
                ilGenerator.Emit(opCode, BitConverter.ToInt32(il, i + 1));
                i += 4;
                continue;
            }
            if (opCode.OperandType == OperandType.ShortInlineBrTarget)
            {
                ilGenerator.Emit(opCode, il[i + 1]);
                ++i;
                continue;
            }
            if (opCode.OperandType == OperandType.InlineType)
            {
                Type tp = methodInfo.Module.ResolveType(BitConverter.ToInt32(il, i + 1), methodInfo.DeclaringType.GetGenericArguments(), methodInfo.GetGenericArguments());
                ilGenerator.Emit(opCode, tp);
                i += 4;
                continue;
            }
            if (opCode.FlowControl == FlowControl.Call)
            {
                MethodInfo mi = methodInfo.Module.ResolveMethod(BitConverter.ToInt32(il, i + 1)) as MethodInfo;
                if (mi == methodInfo)
                    ilGenerator.Emit(opCode, implementation);
                else
                    ilGenerator.Emit(opCode, mi);
                i += 4;
                continue;
            }
            ilGenerator.Emit(opCode);
        }
    }

    static OpCodeContainer[] GetOpCodes(byte[] data)
    {
        List<OpCodeContainer> opCodes = new List<OpCodeContainer>();
        foreach (byte opCodeByte in data)
            opCodes.Add(new OpCodeContainer(opCodeByte));
        return opCodes.ToArray();
    }

    class OpCodeContainer
    {
        public OpCode? code;
        byte data;

        public OpCodeContainer(byte opCode)
        {
            data = opCode;
            try
            {
                code = (OpCode)typeof(OpCodes).GetFields().First(t => ((OpCode)(t.GetValue(null))).Value == opCode).GetValue(null);
            }
            catch
            {
                // if it throws an exception then code should remain null
            }
        }
    }
}

Which fails with CLR execution error.

Answer 1

It's not exactly what I wanted but it's the only solution I came with

public abstract class FuncHolder<T, TResult>
{
    [JsonIgnore]
    public abstract Func<T, TResult> Value { get; }
}

public static class FuncHolder
{
    private static Dictionary<int, object> _metadataTokenToMethodDictionary = new Dictionary<int, object>();

    private class FuncHolderImplementation<T, TResult> : FuncHolder<T, TResult>
    {
        public int MetadataToken { get; }

        public FuncHolderImplementation(int metadataToken)
        {
            MetadataToken = metadataToken;
        }

        public override Func<T, TResult> Value => (Func<T, TResult>)_metadataTokenToMethodDictionary[MetadataToken];
    }

    public static FuncHolder<T, TResult> GetFuncHolder<T, TResult>(Func<T, TResult> func)
    {
        if (!_metadataTokenToMethodDictionary.ContainsKey(func.Method.MetadataToken))
        {
            _metadataTokenToMethodDictionary[func.Method.MetadataToken] = func;
        }

        return new FuncHolderImplementation<T, TResult>(func.Method.MetadataToken);
    }
}

Instead of wrapping a function in the type I merely pass a metadataToken which I then convert back.

---

Why is this needed may be shown as following:

var holder = FuncHolder.GetFuncHolder<string, int>(s => s.Length);
var settings = new JsonSerializerSettings {TypeNameHandling = TypeNameHandling.All};
var json = JsonConvert.SerializeObject(holder, settings);
var holder2 = JsonConvert.DeserializeObject<FuncHolder<string, int>>(json, settings);
Console.WriteLine(holder2.Value("hello"));

As you can see, this way function callback may be serialized and deserialized back.