Riferimento motore V8 di Google da un'applicazione .NET

Question

Sto costruendo un'applicazione .NET 3.5 e hanno la necessità di valutare il codice JS sul server - in pratica una serie di regole utente a condizione che può funzionare all'interno di un browser o sul server. Gestito JS non è un'opzione, perché il codice JS sarebbe stato fornito in fase di esecuzione. Jaxer di Aptana inoltre, non è un'opzione. Quindi cercavo nel usando una build del motore V8 nel mio app.

Ho costruito la fonte con successo in una DLL, ma che DLL non non è una libreria gestita e non è neanche COM. V8 è semplicemente C ++.

Tutte le idee su come interoperabilità con questo tipo di DLL in C #? Inoltre, io sono aperto ad altri suggerimenti per SpiderMonkey o un altro motore di JS.

Grazie in anticipo.

UPDATE:

Sono stato in grado di utilizzare la soluzione di Ryan. Ho appena aggiornato i riferimenti alla build per le ultime dal tronco. Ha funzionato alla grande. Grazie Ryan.

Answer 1

mi rendo conto che questo non può essere una risposta esatta alla tua domanda, ma ho pensato che avrei messo i miei 2 centesimi vale la pena come dubito molte persone hanno provato questo.

ho preso a lavorare con creato un wrapper gestito utilizzando la modalità mista C ++. Ci sono altri modi per farlo, ma stavo per tentare di effettuare un involucro pieno che potrebbe essere utilizzato da qualsiasi linguaggio .NET.

Come la lib di compilare in modo tale da poter essere incluso in un progetto di modalità mista è stata un po 'di una sfida. Ho dovuto modificare la libreria di runtime (nel file SConstruct) utilizzato per / MD e / MDd in modo che sia compatibile con l'opzione / CLR.

Finora ho solo semplici script in esecuzione callback come non ho implementato, metodi personalizzati, oggetti e così via.

Ecco un breve esempio di ciò che l'uso appare come per una delle mie applicazioni di test:

V8DotNet.Shell shell = new V8DotNet.Shell();

shell.ExecuteScript(@"print('V8 version is: ' + version());");

Si corre script più complicati come una multa encoder base64 pure. Ma per ora posso solo aggiungere elementi personalizzati dal C ++ lato.

Sono disposto a fornire maggiori informazioni + codice, se qualcuno è interessato, come io non mai scegliere questo progetto di back up. Ma, temo che modo per molto codice di andare in un post qui così avremmo trovare qualche altro mezzo come il codice Google o CodePlex.

Modifica

---

OK, ho caricato il codice. Devo mettere un disclaimer su questo: Il progetto è molto presto e io sono un dilettante in C ++ nella migliore delle ipotesi, quindi non ci si illuda troppo. Inoltre, questo progetto è stato creato / fatto proprio dopo il cromo è stato rilasciato in modo che la versione di V8 incluso può essere vecchio.

Detto questo, qui è: http://ryanscook.com/Files/V8- DotNet.zip (21,5 MB)

Nel pacchetto troverete i seguenti elementi di interesse:

  

V8Net-Library \ V8.Net \ V8.Net.sln - Questo   è la soluzione che ha il gestito   C ++ proj involucro e un C # console app   per il test.

     

Dipendenze \ V8 - Questo è il mio codice V8   che ho usato per costruire il lib V8.

Speranza che aiuta!

Answer 2

Si può provare JavaScript NET:

http://javascriptdotnet.codeplex.com/

Consente di creare un contesto V8 da NET e registri CLI oggetti in esso in modo da poterli manipolare e chiamare i membri del codice Javascript. Compila il Javascript in fase di esecuzione.

Check it out.

Answer 3

v8sharp . Supporta l'esecuzione di JS all'interno di un'applicazione .NET. Permette anche di registrare tipi .NET con il motore V8 in modo che il codice JS può interagire con il codice .NET. Sono in procinto di aggiungere il supporto per l'aggancio di sostegno di funzione / delegato.

Answer 4

stanno costruendo un vero e proprio javascript - non "JScript" - runtime (insieme con IronPython, IronRuby, e VB10) sul CLR utilizzando il DLR, ma non riesco a trovare alcun download o contenuti per esso. Forse questo arriverà con C # 4?

Answer 5

Da quello che ho sentito compilarlo con IJW (Managed C ++) dovrebbe funzionare -. Ma posso davvero sbagliato, non ho mai toccare MC ++

Answer 6

Credo gatapia ha sostituito js.net con Jish

Answer 7

Necromancing.
Come per il 2018 e .NET Nucleo 2.0+
è possibile utilizzare vroomjs-core

Esegui alcuni Javascript:

using (var engine = new JsEngine())
{
    using (var context = engine.CreateContext())
    {
        var x = (double)context.Execute("3.14159+2.71828");
        Console.WriteLine(x);  // prints 5.85987
    }
}

Crea e restituisce un oggetto JavaScript, quindi chiamare un metodo su di esso:

using (JsEngine js = new JsEngine(4, 32))
{
    using (JsContext context = js.CreateContext())
    {
        // Create a global variable on the JS side.
        context.Execute("var x = {'answer':42, 'tellme':function (x) { return x+' '+this.answer; }}");
        // Get it and use "dynamic" to tell the compiler to use runtime binding.
        dynamic x = context.GetVariable("x");
        // Call the method and print the result. This will print:
        // "What is the answer to ...? 42"
        Console.WriteLine(x.tellme("What is the answer to ...?"));
    }
}

proprietà di accesso e metodi call su oggetti CLR da JavaScript:

class Test
{
    public int Value { get; set; }
    public void PrintValue(string msg)
    {
        Console.WriteLine(msg+" "+Value);
    }
}

using (JsEngine js = new JsEngine(4, 32))
{
    using (JsContext context = js.CreateContext())
    {
        context.SetVariable("m", new Test());
        // Sets the property from Javascript.
        context.Execute("m.Value = 42");
        // Call a method on the CLR object from Javascript. This prints:
        // "And the answer is (again!): 42"
        context.Execute("m.PrintValue('And the answer is (again!):')");
    }
}

Answer 8

Si può provare V8.NET pure.

https://www.nuget.org/packages/V8.Net/

Permette di integrare facilmente il codice con V8 ad un livello inferiore rispetto a molti altri involucri. Supporta anche .Net 4.6.1+ e .Net standard 2.0+ (Net Core).