public MyClass {

    // Delegate type. The 'firstArgument' will be 'this', i.e., this is an open instance
    // method: the implicit argument is here given explicitly, in 'firstArgument'.
    // (below there's a link explaining open instance methods; I wasn't sure it would work
    // within the code block and there's no way to preview!)
    public delegate Object DirectReadAccessor<T>(T firstArgument);

    // Array of delegates. T has been replaced with MyClass because the argument will be
    // 'this', which is of type MyClass.
    private static DirectReadAccessor<MyClass>[] directReadAccessors;

    // Method that looks up a delegate in the array of delegates and calls it with 'this'.
    public Object DirectRead(int index) {
        directReadAccessors[index](this);
    }

    // Method that is called by the declaring type to pass an array with the MethodInfo
    // of some methods. MyClass then creates delegates for these methods and stores them
    // in the directReadAccessors array.
    public static void InitializeClass(MethodInfo[] directReadAccessorsMInfo) {
        int length = directReadAccessorsMInfo.Length;
        Type[] typeArguments = new Type[] { typeof(MyClass) };
        directReadAccessors = new DirectReadAccessor<MyClass>[length];
        // For each method in directReadAccessorsMInfo...
        for (int index = 0; index < length; index++) {
            // Create a delegate and store it in directReadAccessors.
            directReadAccessors[index] = (DirectReadAccessor<MyClass>)
                  Delegate.CreateDelegate(
                        DirectReadAccessor<MyClass>,  // Type of the delegate.
                        null, // Specify null first argument so that it's *open* instance.
                        directReadAccessorsMInfo[index].MakeGenericMethod(typeArguments) // The method.
                  );
        }
    }

}

ilGenerator.Emit(OpCodes.Callvirt, invokeMInfo);

MethodInfo invokeMInfo = typeof(DirectReadAccessor<MyClass>).GetMethod(
        "Invoke",                        // Name of the method.
        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, // Binding attributes.
        null,                            // Binder.
        new Type[] { typeof(MyClass) },  // Types of the arguments.
        null                             // Modifiers for the arguments.
);

directReadAccessorType = typeof(DirectReadAccessor<>).MakeGenericType(typeBuilder);

typeBuilder.CreateType();

MethodInfo mi = typeof(DirectReadAccessor<>).GetMethod(
        "Invoke",                        // Name of the method.
        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, // Binding attributes.
        null,                            // Binder.
        new Type[] { myClassTypeBuilder },  // <---- exception
        null                             // Modifiers for the arguments.
); // use unbound generic type

MethodInfo mi = typeof(DirectReadAccessor<>).GetMethod(
        "Invoke",                        // Name of the method.
        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, // Binding attributes.
        null,                            // Binder.
        typeof(DirectReadAccessor<>).GetGenericArguments(),  // Types of the arguments
        null                             // Modifiers for the arguments.
); // use unbound generic type

public Object DirectRead(int index) {
   // Push 'this' onto the stack.
   L_0000: ldarg.0 
   // Pop 'this' and push this.directReadAccessors
   // (Note: Factory is the class from which I'm emitting the code of MyClass)
   L_0001: ldfld class Factory/DirectReadAccessor<class MyClass>[] MyClass::directReadAccessors
   // Push 'index'.
   L_0006: ldarg.1 
   // Pop 'index' and this.directReadAccessors and push this.directReadAccessors[index], as
   // an object reference. Now we have the delegate on top of the stack.
   L_0007: ldelem.ref 
   // Push 'this', as a parameter for the delegate.
   L_0008: ldarg.0 
   // Invoke the delegate: this.directReadAccessors[index](this)
   // (I made up this line; this is how it should be, but it won't be like this because I
   // don't have MyClass)
   L_0009: callvirt instance void DirectReadAccessor<class MyClass>::Invoke(!0)
   // Return.
   L_000a: ret 
}

MethodInfo mi = typeof(DirectReadAccessor<>).MakeGenericType(myClassTypeBuilder).GetMethod(
        "Invoke",                        // Name of the method.
        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, // Binding attributes.
        null,                            // Binder.
        typeof(DirectReadAccessor<>).GetGenericArguments(),  // Types of the arguments
        null                             // Modifiers for the arguments.
); // use unbound generic type

MethodInfo mi = typeof(DirectReadAccessor<>).GetMethod(
        "Invoke",                        // Name of the method.
        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, // Binding attributes.
        null,                            // Binder.
        directReadAccessorType.GetGenericArguments(),  // Types of the arguments
        null                             // Modifiers for the arguments.
); // use unbound generic type

typeof(DirectReadAccessor<>).MakeGenericType(myClassBuilder)