Mono.Debugger.Backend.Inferior.RuntimeInvoke C# (CSharp) Method

        public void RuntimeInvoke(TargetAddress invoke_method,
					   TargetAddress method_argument,
					   TargetObject object_argument,
					   TargetObject[] param_objects,
					   long callback_arg, bool debug)
        {
            check_disposed ();

            int length = param_objects.Length + 1;

            TargetObject[] input_objects = new TargetObject [length];
            input_objects [0] = object_argument;
            param_objects.CopyTo (input_objects, 1);

            int blob_size = 0;
            byte[][] blobs = new byte [length][];
            int[] blob_offsets = new int [length];
            long[] addresses = new long [length];

            for (int i = 0; i < length; i++) {
                TargetObject obj = input_objects [i];

                if (obj == null)
                    continue;
                if (obj.Location.HasAddress) {
                    blob_offsets [i] = -1;
                    addresses [i] = obj.Location.GetAddress (this).Address;
                    continue;
                }
                blobs [i] = obj.Location.ReadBuffer (this, obj.Type.Size);
                blob_offsets [i] = blob_size;
                blob_size += blobs [i].Length;
            }

            byte[] blob = new byte [blob_size];
            blob_size = 0;
            for (int i = 0; i < length; i++) {
                if (blobs [i] == null)
                    continue;
                blobs [i].CopyTo (blob, blob_size);
                blob_size += blobs [i].Length;
            }

            IntPtr blob_data = IntPtr.Zero, param_data = IntPtr.Zero;
            IntPtr offset_data = IntPtr.Zero;
            try {
                if (blob_size > 0) {
                    blob_data = Marshal.AllocHGlobal (blob_size);
                    Marshal.Copy (blob, 0, blob_data, blob_size);
                }

                param_data = Marshal.AllocHGlobal (length * 8);
                Marshal.Copy (addresses, 0, param_data, length);

                offset_data = Marshal.AllocHGlobal (length * 4);
                Marshal.Copy (blob_offsets, 0, offset_data, length);

                check_error (mono_debugger_server_call_method_invoke (
                    server_handle, invoke_method.Address, method_argument.Address,
                    length, blob_size, param_data, offset_data, blob_data,
                    callback_arg, debug));
            } finally {
                if (blob_data != IntPtr.Zero)
                    Marshal.FreeHGlobal (blob_data);
                Marshal.FreeHGlobal (param_data);
                Marshal.FreeHGlobal (offset_data);
            }
        }