How do you embed other programming languages into your code?

Question

Using C# for ASP.NET and MOSS development, we often have to embed JavaScript into our C# code. To accomplish this, there seems to be two prevalent schools of thought:

string blah = "asdf";
StringBuilder someJavaScript = new StringBuilder();
someJavaScript.Append("<script language='JavaScript' >");
someJavaScript.Append("function foo()\n");
someJavaScript.Append("{\n");
someJavaScript.Append("  var bar = '{0}';\n", blah);
someJavaScript.Append("}\n");
someJavaScript.Append("</script>");

The other school of thought is something like this:

string blah = "asdf";
string someJavaScript = @"
    <script language='JavaScript' >
    function foo()
    {
      var bar = '" + blah + @"';
    }
    </script>";

Is there a better way than either of these two methods? I like the second personally, as you can see the entire section of JavaScript (or other language block, whether SQL or what have you), and it also aids in copying the code between another editor for that specific language.

Edit:
I should mention that the end goal is having formatted JavaScript in the final web page.

I also changed the example to show interaction with the generated code.

Answer 1

How about adding the JavaScript as a resource section to the file, so that it can be loaded as an (embedded) script from the resource section of the executable?

Answer 2

The string literal for one reason: readability.

(performance is a non-issue, this is MOSS we're talking about...)

Answer 3

The second is obviously way, way, clearer. There couldn't really be any reason at all for doing the first.

I would, however, extend it to this:

string someJavaScript = string.Format(@"
    <script language='JavaScript' >
      function foo()
      {
          var bar = '{0}';
      }
    </script>", blah);

If you have several things to stick inside the string, the string.Format method will become rather more readable than inline concatenation.

Answer 4

For portability reasons I would choose StringBuilder over the other. Languages like VB do not have the ability to line-break in the middle of a string. So if theres a chance that this code will someday have to be ported to another language I'd go with StringBuilder.

Answer 5

The second way, although using an external file is much better and allows modifications to be made to the application without recompiling it all.

You also need a nice, readable way to insert variables. The simplest approach is to use string.Format, but then each variable is {0} or {1} and so this can be unreadable.

How about:

public static string Insert(object dictionary, string into)
{
    foreach (PropertyInfo property in dictionary.GetType().GetProperties())
        into = into.Replace("<%" + property.Name + "%>", 
                            property.GetValue(dictionary, null).ToString());

    return into;
}

Then you can do this:

string js = Insert(new { divList, url }, 
                   @"jQuery(document).ready(function(){
                        jQuery('#<%divList%>').jqGrid({
                            url:'<%url%>',
                            datatype: 'json',
                            mtype: 'GET', ... etc...");

Or if the script is in an external file:

string js = Insert(new { divList, url }, File.ReadAllText("someFile.js"));

You can pass any object and its properties will be directly accessible via an ASP-style escaping syntax.

The implementation given above is not very efficient, obviously, but it's short.

Another possibility is to write an .aspx page that returns JavaScript, and then you can include it in your HTML pages with a <script> reference. You can set the ContentType of the page to be application/x-javascript.

This will let you use normal ASP.NET <%= %> tags to modify it, and will already be a fast, robust solution with external files, compiling automatically on the fly when you make edits to the script.

Answer 6

We wrote a library just for this purpose, that offers a fluent-syntax to embedding JavaScript in C# code. You can read more about it here.

In short, your example would be written as:

var function = JS.Function("foo").Do(
    JS.Var(JS.Id("bar").AssignWith(blah)));
string someJavaScript = "<script>" + function + "</script>";

For one, it will make sure that the contents of the blah variable is properly quoted, if it contains special characters, for example.