Apa bahasa skrip terbaik untuk disematkan dalam aplikasi desktop C #? [Tutup]

Kami sedang menulis aplikasi desktop kaya yang kompleks dan perlu menawarkan fleksibilitas dalam format pelaporan jadi kami pikir kami hanya akan mengekspos model objek kami ke bahasa skrip. Waktu adalah ketika itu berarti VBA (yang masih merupakan opsi), tetapi kode turunan VSTA yang dikelola (saya pikir) tampaknya telah layu di pohon anggur.

Apa sekarang pilihan terbaik untuk bahasa skrip yang disematkan di Windows .NET?

Saya telah menggunakan CSScript dengan hasil yang luar biasa. Ini benar-benar mengurangi keharusan melakukan binding dan hal-hal tingkat rendah lainnya di aplikasi saya yang dapat ditulis.

Secara pribadi, saya akan menggunakan C # sebagai bahasa scripting. Kerangka .NET (dan Mono, terima kasih Matthew Scharley) sebenarnya menyertakan kompiler untuk setiap bahasa .NET di kerangka itu sendiri.

Pada dasarnya, ada 2 bagian dari penerapan sistem ini.

1. Izinkan pengguna untuk mengkompilasi kode Ini relatif mudah, dan dapat dilakukan hanya dalam beberapa baris kode (meskipun Anda mungkin ingin menambahkan dialog kesalahan, yang mungkin akan menjadi beberapa lusin baris kode lagi, tergantung bagaimana dapat digunakan Anda menginginkannya).

2. Membuat dan menggunakan kelas-kelas yang terdapat dalam rakitan terkompilasi Ini sedikit lebih sulit daripada langkah sebelumnya (memerlukan sedikit refleksi). Pada dasarnya, Anda harus memperlakukan rakitan yang dikompilasi sebagai "plug-in" untuk program tersebut. Ada cukup banyak tutorial tentang berbagai cara membuat sistem plug-in di C # (Google adalah teman Anda).

Saya telah menerapkan aplikasi "cepat" untuk mendemonstrasikan bagaimana Anda dapat mengimplementasikan sistem ini (termasuk 2 skrip yang berfungsi!). Ini adalah kode lengkap untuk aplikasi, cukup buat yang baru dan tempel kode di file "program.cs". Pada titik ini saya harus meminta maaf atas potongan besar kode yang akan saya tempel (saya tidak bermaksud untuk menjadi begitu besar, tetapi sedikit terbawa dengan komentar saya)

using System;
using System.Windows.Forms;
using System.Reflection;
using System.CodeDom.Compiler;

namespace ScriptingInterface
{
    public interface IScriptType1
    {
        string RunScript(int value);
    }
}

namespace ScriptingExample
{
    static class Program
    {
        /// 
        /// The main entry point for the application.
        /// 
        [STAThread]
        static void Main()
        {

            // Lets compile some code (I'm lazy, so I'll just hardcode it all, i'm sure you can work out how to read from a file/text box instead
            Assembly compiledScript = CompileCode(
                "namespace SimpleScripts" +
                "{" +
                "    public class MyScriptMul5 : ScriptingInterface.IScriptType1" +
                "    {" +
                "        public string RunScript(int value)" +
                "        {" +
                "            return this.ToString() + \" just ran! Result: \" + (value*5).ToString();" +
                "        }" +
                "    }" +
                "    public class MyScriptNegate : ScriptingInterface.IScriptType1" +
                "    {" +
                "        public string RunScript(int value)" +
                "        {" +
                "            return this.ToString() + \" just ran! Result: \" + (-value).ToString();" +
                "        }" +
                "    }" +
                "}");

            if (compiledScript != null)
            {
                RunScript(compiledScript);
            }
        }

        static Assembly CompileCode(string code)
        {
            // Create a code provider
            // This class implements the 'CodeDomProvider' class as its base. All of the current .Net languages (at least Microsoft ones)
            // come with thier own implemtation, thus you can allow the user to use the language of thier choice (though i recommend that
            // you don't allow the use of c++, which is too volatile for scripting use - memory leaks anyone?)
            Microsoft.CSharp.CSharpCodeProvider csProvider = new Microsoft.CSharp.CSharpCodeProvider();

            // Setup our options
            CompilerParameters options = new CompilerParameters();
            options.GenerateExecutable = false; // we want a Dll (or "Class Library" as its called in .Net)
            options.GenerateInMemory = true; // Saves us from deleting the Dll when we are done with it, though you could set this to false and save start-up time by next time by not having to re-compile
            // And set any others you want, there a quite a few, take some time to look through them all and decide which fit your application best!

            // Add any references you want the users to be able to access, be warned that giving them access to some classes can allow
            // harmful code to be written and executed. I recommend that you write your own Class library that is the only reference it allows
            // thus they can only do the things you want them to.
            // (though things like "System.Xml.dll" can be useful, just need to provide a way users can read a file to pass in to it)
            // Just to avoid bloatin this example to much, we will just add THIS program to its references, that way we don't need another
            // project to store the interfaces that both this class and the other uses. Just remember, this will expose ALL public classes to
            // the "script"
            options.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);

            // Compile our code
            CompilerResults result;
            result = csProvider.CompileAssemblyFromSource(options, code);

            if (result.Errors.HasErrors)
            {
                // TODO: report back to the user that the script has errored
                return null;
            }

            if (result.Errors.HasWarnings)
            {
                // TODO: tell the user about the warnings, might want to prompt them if they want to continue
                // runnning the "script"
            }

            return result.CompiledAssembly;
        }

        static void RunScript(Assembly script)
        {
            // Now that we have a compiled script, lets run them
            foreach (Type type in script.GetExportedTypes())
            {
                foreach (Type iface in type.GetInterfaces())
                {
                    if (iface == typeof(ScriptingInterface.IScriptType1))
                    {
                        // yay, we found a script interface, lets create it and run it!

                        // Get the constructor for the current type
                        // you can also specify what creation parameter types you want to pass to it,
                        // so you could possibly pass in data it might need, or a class that it can use to query the host application
                        ConstructorInfo constructor = type.GetConstructor(System.Type.EmptyTypes);
                        if (constructor != null && constructor.IsPublic)
                        {
                            // lets be friendly and only do things legitimitely by only using valid constructors

                            // we specified that we wanted a constructor that doesn't take parameters, so don't pass parameters
                            ScriptingInterface.IScriptType1 scriptObject = constructor.Invoke(null) as ScriptingInterface.IScriptType1;
                            if (scriptObject != null)
                            {
                                //Lets run our script and display its results
                                MessageBox.Show(scriptObject.RunScript(50));
                            }
                            else
                            {
                                // hmmm, for some reason it didn't create the object
                                // this shouldn't happen, as we have been doing checks all along, but we should
                                // inform the user something bad has happened, and possibly request them to send
                                // you the script so you can debug this problem
                            }
                        }
                        else
                        {
                            // and even more friendly and explain that there was no valid constructor
                            // found and thats why this script object wasn't run
                        }
                    }
                }
            }
        }
    }
}

IronPython . Berikut ikhtisar tentang cara menyematkannya .

Mesin PowerShell dirancang agar mudah disematkan dalam aplikasi agar dapat ditulis. Faktanya, PowerShell CLI hanyalah antarmuka berbasis teks ke mesin.

Edit: Lihat https://devblogs.microsoft.com/powershell/making-applications-scriptable-via-powershell/

Bahasa hinaan .

Bahasa skrip pilihan saya adalah Lua hari ini. Kecil, cepat, bersih, terdokumentasi lengkap, didukung dengan baik, memiliki komunitas yang hebat , digunakan oleh banyak perusahaan besar di industri (Adobe, Blizzard, EA Games), pasti patut dicoba.

Untuk menggunakannya dengan bahasa .NET, proyek LuaInterface akan menyediakan semua yang Anda butuhkan.

Mengapa tidak mencoba C #? Mono memiliki proyek baru yang hebat terutama untuk mengevaluasi C # secara dinamis:

http://tirania.org/blog/archive/2008/Sep-10.html

IronRuby seperti yang disebutkan di atas. Proyek yang menarik bagi saya sebagai programmer C # adalah dukungan C # Eval di Mono . Tapi itu belum tersedia (akan menjadi bagian dari Mono 2.2).

Suara lain untuk IronPython. Menyematkan itu sederhana, interoperasi dengan kelas .Net sangat mudah, dan, yah, itu Python.

Saya mungkin menyarankan S # yang saat ini saya pertahankan. Ini adalah proyek open source, ditulis dalam C # dan dirancang untuk aplikasi .NET.

Awalnya (2007-2009) dihosting di http://www.codeplex.com/scriptdotnet , tetapi baru-baru ini dipindahkan ke github.

Coba Ela . Ini adalah bahasa fungsional yang mirip dengan Haskell dan dapat disematkan ke aplikasi .Net apa pun. Meskipun memiliki IDE yang sederhana namun dapat digunakan.

Saya belum mencoba ini tetapi terlihat cukup keren:

http://www.codeplex.com/scriptdotnet

Saya baru saja membuat plugin untuk klien, memungkinkan mereka menulis kode C # dalam modul yang berfungsi seperti yang dilakukan VBA untuk Office.

Saya telah menggunakan Lua sebelumnya; di aplikasi Delphi tetapi dapat disematkan di banyak hal. Ini digunakan di Adobe Photoshop Lightroom .

Saya suka membuat skrip dengan C # itu sendiri . Sekarang, pada tahun 2013, ada dukungan yang cukup baik untuk C # scripting, semakin banyak pustaka yang tersedia.

Mono memiliki dukungan yang bagus untuk skrip kode C # , dan Anda dapat menggunakannya dengan .NET hanya dengan memasukkan Mono.CSharp.dlldalam aplikasi Anda. Untuk aplikasi scripting C # yang saya buat, periksa CShell

Lihat juga 'ScriptEngine' di Roslyn yang berasal dari Microsoft, tetapi ini hanya CTP.

Seperti yang telah disebutkan beberapa orang, CS-Script telah ada sejak lama juga.