Quantcast
Are you the publisher? Claim or contact us about this channel


Embed this content in your HTML

Search

Report adult content:

click to rate:

Account: (login)

More Channels


Showcase


Channel Catalog



Channel Description:

ClearScript is a library that makes it easy to add scripting to your .NET applications. It currently supports JavaScript (via V8 and JScript) and VBScript.

older | 1 | .... | 92 | 93 | (Page 94) | 95 | 96 | .... | 115 | newer

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!
    Comments: Greetings! What you're seeing is the expected behavior; that is, extension methods have always worked this way in ClearScript. There's always room for improvement, of course. Extension methods become available when the implementing class is exposed, either via `ScriptEngine.AddHostType` or by exposing a `HostTypeCollection` that contains the corresponding type. Once available, extension methods appear as properties on all host objects, regardless of type, and only when script code attempts to invoke an extension method is the object's suitability evaluated. The reason for this is that, generally speaking, determining whether an object is suitable for an extension method is nontrivial. An extension method can be generic, with a `this` parameter of an open constructed type (see [`System.Linq.Enumerable`](https://msdn.microsoft.com/en-us/library/system.linq.enumerable(v=vs.100).aspx) for some examples). Matching such a type against an object's specific type might require relatively complex (and expensive) recursive analysis of the metadata. Such analysis is subject to various rules encoded within the C# compiler, and our preference was not to try to duplicate it within ClearScript. Instead, we chose to defer to the compiler itself, by relying on the C# Runtime Binder (part of the C# compiler) to reject invalid extension method calls when they're made. This was a practical approach, as ClearScript was already using the C# Runtime Binder for method invocation. All that having been said, it's been a while since we've looked at this, and we can certainly see how this aspect of ClearScript's implementation could undermine REPL features such as the one you're building. Therefore we'll activate this issue and investigate potential improvements. We should be able to eliminate at least some of the false positives. Thank you!

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!

    0 0

    I´m trying to create a UDPClient from javascript but I cannot find the way to add the event to the object I´ve created on the javascript side and assign a callback function.

    Can someone help me with some simple sample code of how I can accomplish this?..

    Thanks.

    0 0

    nicoriffwrote:

    I´m trying to create a UDPClient from javascript but I cannot find the way to add the event to the object I´ve created on the javascript side and assign a callback function. Can someone help me with some simple sample code of how I can accomplish this?

    We'd love to help, but we'd need more information. What kind of object (host or script) is the event source? What kind of object is the listener? How does the listener register itself with the source (or how would you like that to happen)? What host facilities are you exposing to the script engine? Some sample code could provide the necessary context.

    Thanks!

    0 0

    I´m trying to create a UDPClient from javascript but I cannot find the way to add the event to the object I´ve created on the javascript side and assign a callback function.

    Can someone help me with some simple sample code of how I can accomplish this?..

    Thanks.
    Comments: Moved to a [discussion thread](https://clearscript.codeplex.com/discussions/651909).

    0 0

    I´m trying to create a UDPClient from javascript but I cannot find the way to add the event to the object I´ve created on the javascript side and assign a callback function.

    Can someone help me with some simple sample code of how I can accomplish this?..

    Thanks.

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!
    Comments: I understand. Thank you for clarifying this. I overlooked the possibilities of such complex cases with generics, and fully agree with your practical and reasonable solution to this problem. It also seems that I had misunderstood this statement in the FAQtorial ```"Extension methods are available if the type that implements them has been exposed."``` by thinking that you need to explicitly expose the leaf node type to script e.g. ```lib.System.Linq.Enumerable```, something like using statements in C#. I fear that trying to exclude trivial matches would be of no help, since a mere "System.Core' would flood objects with generic LINQ extensions. Even in IEnumerables where those matches would be correct, having so many methods show would make it an annoyance, so I'm thinking it would be better not to show extensions altogether for cases such as REPL. I came up with some ideas: 1. Make extensions "non-enumerable" JavaScript properties. 2. For every ```MethodName``` extension added, add a ```MethodName{c2cf47d3-916b-4a3f-be2a-6ff567425808}``` property with value true, like it's currently done to indicate CLR objects, so when looping through property P, you can exclude it if property P{...} exists. 3. Make a NoExtensionsHostTypeCollection, so that when exposed, it doesn't bind extensions, so control is given to the user to decide if they want extensions with that library (might also be faster in performance?). 4. Add a method to HostFunctions/EngineInternal somewhere else to get "own" properties of a CLR object if they are already stored somewhere in the back, or even calculate them from scratch as if that type has no extensions. Something like ```return TypeHelpers.GetScriptable...``` 5. Hard way, but no addition to ClearScript would be required: Get members via reflection, figure out the wrapped type if it's restricted. figure out script access and names recursively. I am not sure which one of these could be implemented with the least effort, any thoughts? Thank you!

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!
    Comments: Hi again, We could probably make extension methods non-enumerable (idea #1 above), provided that this change in behavior is (a) optional and disabled by default, (b) engine-level, meaning that, once enabled, it would affect all exposed objects and extension methods, and (c) V8-specific, as Windows script engines don't support non-enumerable properties. Would that work for your project?

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!
    Comments: That would be ideal, since I'm using a singleton V8 engine which I create on startup. Thanks!

    0 0

    Rated 5 Stars (out of 5) - Fantastic library and responsive support from the devs!

    0 0

    Added V8ScriptEngine.SuppressExtensionMethodEnumeration.

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!
    Comments: We've posted an [interim update](https://clearscript.codeplex.com/SourceControl/changeset/bc70fda0c516068a0727ebb8f4d6beafedcb2614) that adds `V8ScriptEngine.SuppressExtensionMethodEnumeration`. Please give it a try if you get a chance. Thanks!

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!
    Comments: Hello, I tested it and it works perfectly! Thank you very much and sorry for the trouble!

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!

    0 0

    Hello! First of all thank you for this amazing library and your great effort in maintaining it!

    I am building a runtime on top of ClearScript that supports node-like requiring of scripts and dll's. I also implemented a REPL feature to explore my objects in console and print them like node does. I do so by enumerating Object.keys(obj).

    The issue I am facing is confusing - ```Object.keys()``` is returning names of extension methods even if the object is not suitable for those methods (different type), but only if the assembly containing those methods is exposed in a specific way to script. The type containing the extension methods is not required to be exposed, only the assembly suffices.

    How I managed to narrow down the reproduction:

    bot.js:
    ```js
    // The assembly I want to import
    var telegram = require('./Telegram.Bot.dll');
    // require loads the file dynamically and returns a wrapper for its System.Reflection.Assembly
    // calling root() on that wrapper returns a new HostTypeCollection(assembly) in C#
    var root = telegram.root();

    // use the library as it's intended (note: the bug occurs even without this line)
    var api = new root.Telegram.Bot.Api(......);

    // The next line returns a regular CLR object module
    var core = require('core');

    var keys = Object.keys(core); // keys now contains ToUnixTime and some other irrelevant extensions!
    // From the source code of the library: public static long ToUnixTime(this DateTime self) { ... }
    // My object is not a DateTime, nor did I import root.Telegram.Bot.Helpers.Extensions
    // class where it resides

    // Calling sleep tells the runtime to start a REPL
    //after the script file finishes running instead of terminating
    core.sleep();
    // Exporting object to global namespace
    global.core = core;
    ```

    After running this file with my executable, if I type ```core``` in my REPL, It still prints out those keys, and evaluating ```core.ToUnixTime``` as a command returns ```[HostMethod:ToUnixTime]```, trying to invoke ```core.ToUnixTime()``` throws ```... does not contain a definition for 'ToUnixTime'```. This issue pollutes my objects and defeats the purpose of having an inspector.

    This bug does not occur (at first) under these conditions:
    ```js
    global.telegram = require('./Telegram.Bot.dll');
    // I am not exposing root() here
    global.core = require('core');
    global.core.sleep();
    ```

    After this file finishes running, typing ```root = telegram.root()``` in REPL exposes the assembly but does not introduce those buggy extension methods. More so, calling ```ext = root.Telegram.Bot.Helpers.Extensions``` does not cause any trouble. However, objects exposed afterwards: ```console = require('console')``` get polluted.

    Notes:
    -I am using the latest version of ClearScript from NuGet (v5.4.4)
    -Executing files runs them within a ```function (exports, require, module, __filename, __dirname) { code }``` wrapper.
    -This means that the first case is entirely executed within a engine.Execute(...) call.
    -The bug occurs in the first case even if core is exposed before the library.
    -The REPL loop starts after executions are finished, so in the second case it is a different execution - an engine.Evaluate(...) more exactly.
    -Runtime source code https://github.com/EdonGashi/ShipScript
    -Library source code https://github.com/MrRoundRobin/telegram.bot

    Thanks!
    Comments: No trouble at all! Thanks again!

    0 0

    Hi,

    We currently use ClearScript v5.4.2 and wanted to upgrade to v5.4.4, but some of our tests started failing. This is because the method "toString()" no longer binds to the method on the managed instance of the HostObject - this means that it always returns "[object HostObject]".

    I also tried using extension methods and interface methods, but all of them return the same string: "[object HostObject]". The problem is that we can't upgrade to ClearScript v5.4.4 because of this issue. If it turns out to be a v8 issue that can't be fixed in ClearScript, do you know what version of v8 made it stop working?

    I attached an additional test fixture that you can just add to the ClearScriptTest project so you can see experience the problem.

    Thank you.

    0 0

    The tests in PropertyBagTests are passing because an exception is thrown as expected, but it's not thrown at the place it should.

    (You should probably scope the throw assertions on the statement expected to throw to avoid this kind of issue).

    0 0
  • 03/03/16--08:40: New Post: Date marshalling
  • I've toyed a bit with this issue because I like to keep the .NET DateTime as they are on the script side but the comparison operators are a bit of a trap when we write our business rules.

    I wonder if javascript's valueOf is not a good solution.

    The problem is to attach the valueOf method to the .NET DateTime objetcs, as expected I can't "monkey patch" the object, and it would not be convenient to have to do it that way, but if it was possible to globally define the javascript "prototype" for a .NET class (or struct), we could just set it as { valueOf: function() { return this.Ticks } } for DateTime and the operators would work (similar for TimeSpan).

    The API could be something nice (another overload to provide the complete prototype could also be available):
    engine.AddHostType<DateTime>(valueOf: (instance) => instance.Ticks);

    0 0

    Right you are! We'll fix the tests in the next point release. Thanks for reporting this!

older | 1 | .... | 92 | 93 | (Page 94) | 95 | 96 | .... | 115 | newer