private object InvokeMethod(string name, Type[] typeArgs, object[] args, object[] bindArgs) { var bindResult = BindMethod(name, typeArgs, args, bindArgs); if ((bindResult is MethodBindFailure) && target.Flags.HasFlag(HostTargetFlags.AllowExtensionMethods)) { var targetArg = new[] { target.Target }; var extensionArgs = targetArg.Concat(args).ToArray(); var targetBindArg = new object[] { target }; var extensionBindArgs = targetBindArg.Concat(bindArgs).ToArray(); foreach (var type in ExtensionMethodSummary.Types) { var extensionHostItem = (HostItem)Wrap(engine, HostType.Wrap(type)); var extensionBindResult = extensionHostItem.BindMethod(name, typeArgs, extensionArgs, extensionBindArgs); if (extensionBindResult is MethodBindSuccess) { var result = extensionBindResult.Invoke(extensionHostItem); for (var index = 1; index < extensionArgs.Length; index++) { args[index - 1] = extensionArgs[index]; } return(result); } } } return(bindResult.Invoke(this)); }
private static void AddTypeToNamespaceNode(PropertyBag node, Type type) { object value; var name = type.GetRootName(); if (!node.TryGetValue(name, out value)) { node.SetPropertyNoCheck(name, HostType.Wrap(type)); return; } var hostType = value as HostType; if (hostType != null) { var types = type.ToEnumerable().Concat(hostType.Types).ToArray(); var groups = types.GroupBy(testType => testType.GetGenericParamCount()).ToIList(); if (groups.Any(group => group.Count() > 1)) { types = groups.Select(ResolveTypeConflict).ToArray(); } node.SetPropertyNoCheck(name, HostType.Wrap(types)); return; } if (value is PropertyBag) { throw new OperationCanceledException(MiscHelpers.FormatInvariant("Type conflicts with namespace at '{0}'", type.GetLocator())); } throw new OperationCanceledException(MiscHelpers.FormatInvariant("Type conflicts with '{0}' at '{1}'", value.GetFriendlyName(), type.GetLocator())); }
/// <summary> /// Exposes a host type to script code with the specified options. /// </summary> /// <param name="itemName">A name for the new global script item that will represent the type.</param> /// <param name="flags">A value that selects options for the operation.</param> /// <param name="type">The type to expose.</param> /// <remarks> /// Host types are exposed to script code in the form of objects whose properties and /// methods are bound to the type's static members and nested types. If the type has /// generic parameters, the corresponding object will be invocable with type arguments to /// yield a specific type. /// <para> /// For more information about the mapping between host members and script-callable /// properties and methods, see <see cref="AddHostObject(string, HostItemFlags, object)"/>. /// </para> /// </remarks> public void AddHostType(string itemName, HostItemFlags flags, Type type) { MiscHelpers.VerifyNonNullArgument(type, "type"); AddHostItem(itemName, flags, HostType.Wrap(type)); }
/// <summary> /// Adds a type to a host type collection. /// </summary> /// <param name="type">The type to add.</param> public void AddType(Type type) { MiscHelpers.VerifyNonNullArgument(type, "type"); AddType(HostType.Wrap(type)); }
/// <summary> /// Converts a type to a host type for use with script code running in the specified /// script engine. /// </summary> /// <param name="type">The type to convert to a host type.</param> /// <param name="engine">The script engine in which the host type will be used.</param> /// <returns>A host type for use with script code.</returns> public static object ToHostType(this Type type, ScriptEngine engine) { MiscHelpers.VerifyNonNullArgument(type, nameof(type)); MiscHelpers.VerifyNonNullArgument(engine, nameof(engine)); return(HostItem.Wrap(engine, HostType.Wrap(type))); }