public IOWrapper(RubyContext/*!*/ context, object io, bool canRead, bool canWrite, bool canSeek, bool canFlush, bool canBeClosed, int bufferSize) {
            Assert.NotNull(context);

            _writeSite = CallSite<Func<CallSite, object, object, object>>.Create(
                RubyCallAction.Make(context, "write", RubyCallSignature.WithImplicitSelf(1))
            );
            _readSite = CallSite<Func<CallSite, object, object, object>>.Create(
                RubyCallAction.Make(context, "read", RubyCallSignature.WithImplicitSelf(1))
            );
            _seekSite = CallSite<Func<CallSite, object, object, object, object>>.Create(
                RubyCallAction.Make(context, "seek", RubyCallSignature.WithImplicitSelf(2))
            );
            _tellSite = CallSite<Func<CallSite, object, object>>.Create(
                RubyCallAction.Make(context, "tell", RubyCallSignature.WithImplicitSelf(0))
            );

            _obj = io;

            _canRead = canRead;
            _canWrite = canWrite;
            _canSeek = canSeek;
            _canFlush = canFlush;
            _canBeClosed = canBeClosed;
            _buffer = new byte[bufferSize];
            _writePos = 0;
            _readPos = 0;
            _readLen = 0;
        }

 public DynamicInstructionN(Type delegateType, CallSite site) {
     var methodInfo = delegateType.GetMethod("Invoke");
     _target = ReflectedCaller.Create(methodInfo);
     _targetField = site.GetType().GetField("Target");
     _site = site;
     _argCount = methodInfo.GetParameters().Length;
 }

        public RubyRepresenter(RubyContext/*!*/ context, Serializer/*!*/ serializer, YamlOptions/*!*/ opts)
            : base(serializer, opts) {
            _context = context;
            _objectToYamlMethod = context.GetClass(typeof(object)).ResolveMethod("to_yaml", VisibilityContext.AllVisible).Info;

             _TagUri =
                CallSite<Func<CallSite, object, object>>.Create(
                RubyCallAction.Make(context, "taguri", RubyCallSignature.WithImplicitSelf(0))
            );

            _ToYamlStyle =
                CallSite<Func<CallSite, object, object>>.Create(
                RubyCallAction.Make(context, "to_yaml_style", RubyCallSignature.WithImplicitSelf(0))
            );

            _ToYamlNode =
                CallSite<Func<CallSite, object, RubyRepresenter, object>>.Create(
                RubyCallAction.Make(context, "to_yaml_node", RubyCallSignature.WithImplicitSelf(1))
            );

            _ToYaml =
                CallSite<Func<CallSite, object, RubyRepresenter, object>>.Create(
                RubyCallAction.Make(context, "to_yaml", RubyCallSignature.WithImplicitSelf(0))
            );

            _ToYamlProperties = 
                CallSite<Func<CallSite, object, object>>.Create(
                RubyCallAction.Make(context, "to_yaml_properties", RubyCallSignature.WithImplicitSelf(0))
            );
        }

 public DynamicInstructionN(Type delegateType, CallSite site)
 {
     MethodInfo method = delegateType.GetMethod("Invoke");
     ParameterInfo[] parameters = method.GetParameters();
     this._target = CallInstruction.Create(method, parameters);
     this._site = site;
     this._argumentCount = parameters.Length - 1;
     this._targetDelegate = site.GetType().GetField("Target").GetValue(site);
 }

        public DynamicInstructionN(Type delegateType, CallSite site) {
            var methodInfo = delegateType.GetMethod("Invoke");
            var parameters = methodInfo.GetParameters();

            _target = CallInstruction.Create(methodInfo, parameters);
            _targetField = site.GetType().GetField("Target");
            _site = site;
            _argCount = parameters.Length;
        }

        public DynamicInstructionN(Type delegateType, CallSite site) {
            var methodInfo = delegateType.GetMethod("Invoke");
            var parameters = methodInfo.GetParameters();

            // <Delegate>.Invoke is ok to target by a delegate in partial trust (SecurityException is not thrown):
            _targetInvocationInstruction = CallInstruction.Create(methodInfo, parameters);
            _site = site;
            _argumentCount = parameters.Length - 1;
            _targetDelegate = site.GetType().GetInheritedFields("Target").First().GetValue(site);
        }

        public RubyConstructor(RubyGlobalScope/*!*/ scope, NodeProvider/*!*/ nodeProvider)
            : base(nodeProvider, scope) {
            
            _newSite = CallSite<Func<CallSite, RubyModule, object, object, object, object>>.Create(
                RubyCallAction.Make(scope.Context, "new", RubyCallSignature.WithImplicitSelf(3))
            ); 

            _yamlInitializeSite = CallSite<Func<CallSite, object, object, Hash, object>>.Create(
                RubyCallAction.Make(scope.Context, "yaml_initialize", RubyCallSignature.WithImplicitSelf(3))
            );
        }

        internal object Invoke(object[] args) {
            Debug.Assert(args != null);

            // If it is a delegate, just let DynamicInvoke do the binding.
            var d = _callable as Delegate;
            if (d != null) {
                return d.DynamicInvoke(args);
            }

            // Otherwise, create a CallSite and invoke it.
            if (_site == null) {
                _site = CallSite<Func<CallSite, object, object[], object>>.Create(SplatInvokeBinder.Instance);
            }

            return _site.Target(_site, _callable, args);
        }

 /// <summary>
 /// Converts an object to string using to_path-to_str protocol.
 /// Protocol:
 /// ? to_path => to_path() and to_str conversion on the result
 /// ? to_str => to_str()
 /// </summary>
 public static MutableString/*!*/ CastToPath(CallSite<Func<CallSite, object, MutableString>>/*!*/ toPath, object obj) {
     MutableString result = toPath.Target(toPath, obj);
     if (result == null) {
         throw RubyExceptions.CreateTypeConversionError("nil", "String");
     }
     return result;
 }

 public FinalizerInvoker(CallSite<Func<CallSite, object, object, object>>/*!*/ callSite, object finalizer)
 {
     Assert.NotNull(callSite);
     _callSite = callSite;
     _finalizer = finalizer;
 }

 public defaultdict(CodeContext/*!*/ context) {
     _missingSite = CallSite<Func<CallSite, CodeContext, object, object>>.Create(
         new PythonInvokeBinder(
             PythonContext.GetContext(context),
             new CallSignature(0)
         )
     );
 }

		public static object LessThanObjUInt (CallSite site, object a, uint b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			if (a is uint)
			{
				return (uint)a < b;
			}
			if ((a == null) || (a == PlayScript.Undefined._undefined))
			{
				return false;
			}
			return Convert.ToDouble(a) < (double)b;
		}

		public static object ShiftRightDoubleObj (CallSite site, double a, object b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			if ((b == null) || (b == PlayScript.Undefined._undefined))
			{
				return a;
			}
			return (int)a >> Convert.ToInt32(b);
		}

		public static object XorObjBool (CallSite site, object a, bool b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			return Dynamic.CastObjectToBool(a) ^ b;
		}

		public static object XorUIntObj (CallSite site, uint a, object b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			if ((b == null) || (b == PlayScript.Undefined._undefined))
			{
				return a;
			}
			return a ^ Convert.ToUInt32(b);
		}

		public static object ModDoubleObj (CallSite site, double a, object b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			if ((b == null) || (b == PlayScript.Undefined._undefined))
			{
				return Double.NaN;		// Should probably also use Positive and Negative Infinity
			}
			return a % Convert.ToDouble(b);
		}

		public static object ShiftRightObjDouble (CallSite site, object a, double b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			if ((a == null) || (a == PlayScript.Undefined._undefined))
			{
				return (int)0;
			}
			return Convert.ToInt32(a) >> (int)b;
		}

		public static object XorBoolObj (CallSite site, bool a, object b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			return a ^ Dynamic.CastObjectToBool(b);
		}

		public static object ShiftRightObjObj (CallSite site, object a, object b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			if (a is int) {
				return ShiftRightIntObj (site, (int)a, b);
			} else if (a is uint) {
				return ShiftRightUIntObj (site, (uint)a, b);
			} else if (a is double) {
				return ShiftRightDoubleObj (site, (double)a, b);
			} else if (a is float) {
				return ShiftRightDoubleObj (site, (float)a, b);
			} else {
				ThrowOnInvalidOp (a, SHR);
				return null;
			}
		}

		public static object XorObjObj (CallSite site, object a, object b)
		{
#if BINDERS_RUNTIME_STATS
			Stats.Increment(StatsCounter.BinaryOperationBinderInvoked);
#endif
			if (a is int) {
				return XorIntObj (site, (int)a, b);
			} else if (a is double) {
				return XorDoubleObj (site, (double)a, b);
			} else if (a is float) {
				return XorDoubleObj (site, (float)a, b);
			} else if (a is bool) {
				return XorBoolObj (site, (bool)a, b);
			} else if (a is uint) {
				return XorUIntObj (site, (uint)a, b);
			} else {
				ThrowOnInvalidOp (b, XOR);
				return null;
			}
		}