AMT Blog

Compilify is an open source online compiler as a service, developed by Justin Rusbatch, which works on top of the  Roslyn CTP. Started recently, it has already received a good amount of attention from the .NET community. compilify.net allows you to learn C#, share and test code, reproduce bugs, explore fixes, and to demonstrate and collaborate on ideas. It's fast and simple and can be used from any device with a web browser, without installing any additional plugins. It can be handy when you don't have time for a full IDE!

Compilify is freely available on GitHub under a MIT Licence. This service is currently hosted by it's sponsor AppHarbor.

Read more…

Like what we post? Share your thoughts on the comments below. If you wish to get regular updates on what we post, do subscribe to our RSS Feed

Chocolatey NuGet is a good Machine Package Manager for Windows; similar to apt-get in Ubuntu, Chocolatey is a global automation tool that makes use of PowerShell and the NuGet infrastructure to allow you to do virtually anything. 

How chocolatey works:

When a package has an exe file, chocolatey will generate a link "shortcut" to the file so that you can run that tool anywhere on the machine.

When a package has a chocolateyInstall.ps1, it will run the script. The instructions in the file can be anything. This is limited only by the .NET framework and powershell.

Most of the chocolatey packages that take advantage of the powershell download an application installer and execute it silently.

Read more…

Like what we post? Share your thoughts on the comments below. If you wish to get regular updates on what we post, do subscribe to our RSS Feed

Unlike other templating engines that focus on given as much power as possible to the user, Liquid is designed to restrict what the user can do. The goal is to allow end-users to create their own templates without jeopardizing the security of the server.

Liquid was originally created for the eCommerce platform Shopify and has been in production use since 2006. Tim Jones ported the engine to .NET under the name DotLiquid. Both versions get their safety by not allowing templates to access the underlying platform. Instead they use a highly restricted instruction set that is primarily limited to simple functions, called “filters”, and conditional statements. The Liquid markup syntax is the same for both versions.

Rendering templates involves two steps. First the source code is parsed into a reusable Template object. Then when needed the template’s render method is called. Since templates have no access to Ruby/.NET variables, these have to be passed in using a dictionary of key-value pairs.

Developers can create their own filters to be leveraged by their users. New filters can be exposed to a specific template or registered globally. Either way, they are essentially a function that accepts and returns a string. New tag blocks are somewhat more complicated, requiring both an initialization and a rendering phase. Fortunately most of the messiness is handled by calls to the base class.

Read more…

Like what we post? share your thoughts on the comments below.  If you wish to get regular updates on what we post, do subscribe to our RSS Feed

Xamarin.Mobile is a library that runs on iPhone, Android and Windows Phone 7 & unifies hardware access across these platforms.

When .NET developers target mobile devices they have three API sets to choose from: Windows 7, MonoTouch, and Mono for Android. While the .NET framework standardizes a lot of stuff, there are many hardware features that simply aren’t covered by the Base Class Library. looks to greatly increase the amount of reusable code by standardizing the API across the platforms.

Like .NET itself, Xamarin.Mobile is an abstraction layer that sits on top of the native API. In exchange for giving up some of the underlying operating system capabilities, developers no longer need to re-implement common functionality for each of the three platforms. The areas Xamarin.Mobile is proposing to cover are:

• Contacts
• Geolocation
• Compass and Accelerometer
• Video and Audio
• Notifications

The most notable area missing from the list is the user interface itself. Much like its predecessors Ximian and Novell, Xamarin is still dedicated to their vision of platform specific, first-class user interfaces written in .NET/Mono.

Read More…

This article briefly introduced Phalanger – a PHP compiler for .NET – and several scenarios where it can be used to solve important problems in practice. It was written by Tomas Petricek, A Microsoft C# MVP and F# enthusiast & originally appeared on infoq.

Phalanger is a PHP language compiler and a PHP runtime for .NET. It can be used to compile PHP web projects into .NET bytecode and execute them as ASP.NET applications using either IIS on Windows or using Mono and Apache on Linux. However, Phalanger goes beyond just compiling existing PHP applications to .NET.

In this article, we’ll briefly introduce Phalanger and then look at three usage scenarios. We’ll discuss how to integrate PHP applications with ASP.NET; how to efficiently run PHP applications on Windows and how to use PHP as a view engine for ASP.NET.

Introducing Phalanger

Phalanger has been around for quite some time. The first version of Phalanger was created as a software project at Charles University in Prague in 2003. The development of version 2.0 started later and was released as open-source project in 2006 on CodePlex. Microsoft supported the project for a while and one of the Phalanger developers later joined Microsoft to work on the Dynamic Language Runtime (DLR).

The activity on Phalanger resumed in 2008 thanks to collaboration with Jadu which used Phalanger to build a .NET version of their CMS developed in PHP [8]. Since 2010, the development of Phalanger has been mainly funded by DEVSENSE, which provides commercial support for Phalanger. Recently released version Phalanger 2.1 [7] improves compatibility with the standard PHP implementation, takes advantage of the DLR in the implementation of dynamic operations and provides better interoperability between PHP and other .NET languages (like C#, F# and Visual Basic).

Components of Phalanger

Phalanger consists of several, partly independent, components that can be used to develop PHP applications running on .NET and to run them using .NET or Mono:

• Phalanger Compiler. Phalanger compiles PHP source code into .NET assemblies that are executed using .NET JIT (Just-in-time compiler that generates native code for the current platform). Compiled PHP code uses Phalanger Runtime and Dynamic Language Runtime that provides efficient implementation of dynamic features of the PHP language.
• Phalanger Runtime and Libraries. The Phalanger Runtime provides an implementation of PHP features like arrays. Phalanger also comes with a .NET implementation of standard PHP libraries for I/O, regular expressions and others.
• Native Extensions. On 32 bit Windows platform, Phalanger is capable of using any existing PHP 4 extension via a native bridge. Despite some runtime overhead, this makes it possible to run some PHP applications without additional effort.
• Managed Extensions. PHP extensions can be also re-implemented by wrapping similar functionality available in .NET. These extensions can be written in any .NET language and provide great performance. Phalanger comes with several extensions including SPL, JSON, SimpleXML, MySQL and MS SQL providers. Additional extensions such as Memcached, image, or cURL are available from DEVSENSE [9].
• Visual Studio Integration. Phalanger also integrates with Visual Studio (recently updated to support Visual Studio 2010). The integration adds color highlighting and IntelliSense for PHP files and allows debugging of PHP applications running using Phalanger.

Phalanger Use Cases

Phalanger is largely compatible with PHP 5 and can run a large number of open-source PHP projects including WordPress and MediaWiki. It can be used to integrate these projects in a .NET ecosystem as well as to develop new projects that combine the benefits of PHP and .NET. In the rest of the article, we discuss the following three use cases:

• Scenario #1: Running PHP Applications Efficiently. The performance of PHP applications compiled using Phalanger on Windows is better than when using a standard PHP interpreter via FastCGI. This makes Phalanger an attractive option for hosting PHP in Windows environment.
• Scenario #2: Integrating WordPress with ASP.NET. PHP code compiled using Phalanger can call any .NET library. This can be used to share database of users or other data between PHP and ASP.NET applications.
• Scenario #3: Calling PHP from ASP.NET Applications. The flexibility of PHP is useful for scripting or writing the presentation layer of web applications. Thanks to Phalanger, it is possible to develop an application in .NET and use PHP as a scripting language or a view engine.

The following three sections discuss each of the scenarios in detail. We first give a general overview and then look at some technical details that demonstrate interesting aspects of Phalanger.

Scenario #1: Running PHP Applications Efficiently

Phalanger makes running PHP applications efficient for two reasons. Firstly, it compiles the PHP source code instead of interpreting it and secondly, it runs the application as an ASP.NET application, which provides additional performance benefits on Windows.

Compiling PHP using Phalanger and .NET

The compilation process is shown in Figure 1. As the diagram shows, Phalanger compiles PHP source code to a .NET IL (Intermediate Language), which is a low-level bytecode that is independent of the architecture. The compiled code uses PHP Core Library (a part of Phalanger) and Dynamic Language Runtime (DLR) to perform standard PHP operations. When the application starts, the .NET JIT (Just-in-time) compiler turns all these components into a native code optimized for the current processor architecture.

Figure 1. Compilation of PHP source code to native code using Phalanger

As Phalanger Benchmarks show [10], the performance of WordPress compiled using Phalanger on Windows is significantly better than when using standard PHP interpreter via FastCGI and slightly better than using PHP with WinCache. However, the benchmarks did not test the most recent version of Phalanger that is further optimized using the DLR.

Hosting PHP applications using ASP.NET

Phalanger applications run in the same mode as ASP.NET applications. This gives an important performance advantage, especially on Windows systems where processes are more expensive than threads.

The diagram in Figure 2 shows different options for running PHP applications.

When using the standard CGI mode, the web server starts a new process for every incoming request. On Windows, this is inefficient, but it also prevents sharing state in a shared memory or easy in-process caching. When using FastCGI mode, the web server reuses processes, so it doesn’t have to start new process for every request. However, it is still not possible to share state in memory, because different processes would have different state.

(Click on the image to enlarge it)

Figure 2. Running PHP using CGI, FastCGI and Phalanger

Phalanger behaves just like any ASP.NET application. A single ASP.NET process, called Application Pool handles all incoming requests. It is even possible to configure multiple PHP applications (such as several independent instances of WordPress) in a single process (Application Pool). Inside the process, there are multiple threads that are re-used to handle individual requests. On Windows, threads are more lightweight than processes, so this is more efficient and less memory-consuming solution.

That the application runs in a single process allows further optimizations and other interesting scenarios. For example, Phalanger uses the Dynamic Language Runtime (DLR) for dynamic method invocation. DLR uses a caching mechanism that adapts over time, so after several requests, the DLR “learns” what methods the application uses and becomes faster. This is only possible if requests are handled within a single process.

Running all code in a single process also means the application can store global state in memory. This can be used to implement functionality similar to the User Cache provided by WinCache, but without the overhead of inter-process communication.

Scenario #2: Integrating WordPress with ASP.NET

One of the benefits of PHP is the wide range of excellent open-source CMS systems (WordPress, Joomla, etc.), form applications (phpBB and others) or wikis (MediaWiki and others), many of which have been tested with Phalanger.

These applications often provide more features than similar packages for the .NET platform. A company that develops an ASP.NET based web page may face the following situation:

• It needs to add wiki, forum or blogs to an existing ASP.NET solution, but the only suitable applications (e.g., free, with all necessary features) are available in PHP.
• The application may run under a sub-domain, but it should share the user database. Moreover, once the user signs-in on the main page, it should remain signed-in on the wiki, forum or a blog.

ASP.NET applications can use ASP.NET Membership, which is a standardized mechanism for managing users, roles and their profiles. With Phalanger, it is possible to modify any open-source PHP project to use the same mechanism. The next section demonstrates how this works using WordPress.

Implementing ASP.NET Membership Plugin for WordPress

If you’re not interested in code, you can skip this section and look at the third scenario. However, we won’t look at any technical details – just a very brief overview of PHP extensions that allow PHP to call .NET libraries.

Handling of users in WordPress can be easily customized using a plugin. The plugin for managing users’ needs to implement a PHP class with various member functions. One of the expected functions is authenticate, which gets a user name and a password. It should fill information about the current user or set the name to NULL if the user does not exist.

To implement authentication using ASP.NET Membership in .NET, we can use functionality from the System.Web.Security namespace. The static method Membership.ValidateUser tests whether the password is correct and Membership.GetUser returns basic information about the user. Using Phalanger, we can access .NET objects as if they were standard PHP objects, so implementing the authentication is easy. Listing 1 shows a simplified version of the code.

Listing 1. Function implementing authentication in a WordPress plugin

import namespace System:::Web:::Security;
function authenticate(&$username,$password) {  global $errors;  // Test whether the password is correct  if (Membership::ValidateUser($username,$password)) {    // Get information about the user and fill $userarray    $user = Membership::GetUser($username);    $userarray['user_login'] = $user->UserName;    $userarray['user_email'] = $user->Email;    $userarray['display_name'] = $username;    $userarray['user_pass'] = $password;    // Loading of roles & profiles omitted for simplicity    // Update or create the user information in WordPress    if ($id = username_exists($username)) {      $userarray['ID'] = $id;      wp_update_user($userarray);    }    else      wp_insert_user($userarray);  } else {    // Report error if the login failed    $errors->add('user-rejected', 'Log-in failed!');    $username = NULL;  }}

The code starts with an import namespace declaration. This is a non-standard Phalanger extension that imports functionality from a .NET namespace of one of the referenced assemblies (assemblies can be referenced using a web.config file). In a future version, Phalanger will use standard namespaces as supported by PHP 5.3, but this change is not fully implemented yet.

The rest of the code looks like standard PHP code. However, the Membership class is actually a standard .NET class. Phalanger treats PHP classes and .NET classes equally, so we can use standard syntax for calling .NET methods. The functions ValidateUser and GetUser are static functions, so they are called using the :: syntax. The result of GetUser is a .NET object MembershipUser with various properties that contain basic information about the user. Again, we can use the standard notation to access fields of the object (which are implemented as .NET properties).

As you can see, using .NET functionality from PHP is very natural. Since the code is compiled to .NET assembly, there is also no overhead when calling .NET libraries. The next section shows integration in an opposite direction – calling PHP from .NET application.

Scenario #3: Calling PHP from ASP.NET Applications

The main advantage of PHP is its flexibility and simplicity, which makes it a great language for writing scripts or implementing rendering of HTML. However, some people find it easier to implement large-scale applications in statically-typed languages such as Java or C#. Using Phalanger, we can get the best of both worlds.

The scenario discussed in this section demonstrates one way to combine ASP.NET and PHP. It is based on the modern ASP.NET MVC (Model View Controller) Framework that separates the presentation layer, layer responsible for interaction and the business logic of the application. We can develop individual components in different languages:

• C# Model and Controllers. The model and the controllers will be written in C#. This part of the application implements the business logic, which is often easier to write in a statically-typed language, especially if the logic becomes more complicated. Moreover, it is possible to use technologies like LINQ for data access and Task Parallel Library to implement high-performance calculations using multiple threads.
• PHP Views. The presentation layer of the application will be written in PHP. This is where the simplicity and flexibility of PHP provides the most benefits. Moreover, it means that this part of application can be written by less experienced developers, because most of web developers and web designers know some PHP.

There are other situations where calling PHP from C# would be useful. For example, you can use PHP as a scripting language in a larger C# project. This is again very useful, because PHP is a widely known language. Another situation is when using PHP library from C# - this is largely simplified thanks to Phalanger’s duck typing mechanism, which can even generate a statically-typed C# interface for calling well documented PHP code.

In the rest of the article, we focus on the scenario that uses PHP to implement presentation layer of an ASP.NET application. You can find references to information about other scenarios (such as scripting) at the end of the article.

Creating Model-View-Controller Application in C# and PHP

Let’s first look at a simple application we could create using a combination of C# and PHP. The Model and Controller of the application is written in C# and are shown in Listing 2. In the example, the model is just a simple C# class representing information about products. In reality, this would be responsible for loading data from a database and might be implemented using LINQ.

Listing 2. Model and Controller of a sample web application (C#)

public class Product {
  public string ProductName { get; set }
  public double Price { get; set }
}
public class HomeController : Controller {  public ActionResult Index() {    ViewData.Model = new Product { ProductName = "John Doe", Price = 99.9 };    return View();  }}

The controller component is implemented by the HomeController class, which inherits from ASP.NET MVC Controller. The class contains a single action representing the index page of the application. The action will be invoked when the user accesses /Home/Index (or just the root URL). It creates the model (instance of Product class) and passes it to the View component.

In a standard ASP.NET MVC application, the View component is typically implemented using ASPX page or using Razor view engine with code written using C# or Visual Basic. Phalanger makes it possible to use PHP in the implementation of the views. Listing 3 shows an example.

Listing 3. View of a sample web application (PHP)

<html><head>
  <title>Sample view written in PHP</title>
</head>
<body>
  <h1>Product Listing using Phalanger</h1>
  Product: <? echo $MODEL->ProductName; ?><br />
  Price: <? echo $MODEL->Price; ?>
</body></html>

The view is rendered using and ASP.NET MVC extension described below. The extension executes the PHP script shown in Listing 3 and defines a global variable named $MODEL that contains the data returned by the controller. In the above example, $MODEL is a reference to a standard .NET class. Phalanger treats .NET classes as equal to PHP objects, so it is very easy to display properties of the product using the echo construct.

The example shows the basic structure of the application, but it is extremely simple, so it doesn’t really show all the benefits we can get by using PHP in the presentation layer:

• The dynamic nature of PHP makes it easy to render data of any structure. The view is not limited to simple scripts, but can use any existing PHP libraries, including popular templating engines.
• The view can be structured into multiple files using PHP include, so you have full control over how the page is generated.
• The developer creating the view doesn’t need to know anything about .NET. This means a company transitioning from PHP to C# can still leverage existing developer skills.

To give you some idea how this scenario works, the following section reveals some technical details about the PHP and C# integration. If you’re not interested in the details, you can go straight to the summary.

Looking Under the Cover

The scenario described in this section is based on the PicoMVC project [4], which allows combining PHP with F#. To keep the examples simpler, I translated them from F# to C#. The core of the PHP integration in PicoMVC is a simple function that takes a file name of a PHP script and runs it using the Phalanger runtime. The function is shown in Listing 4.

Listing 4. Calling PHP script from an ASP.NET web application.

void PhalanagerView(string fileName, object model, HttpContext current) {
  // Initialize PHP request context and output stream
  using(var rc = RequestContext.Initialize(ApplicationContext.Default, current))
  using(var byteOut = HttpContext.Current.Response.OutputStream)
  using(var uftOut = new StreamWriter(byteOut)) {
    // Current context for evaluating PHP scripts     var phpContext = ScriptContext.CurrentContext;    // Redirect PHP output to the HTTP output stream    phpContext.Output = uftOut;    phpContext.OutputStream = byteOut;    // Declare global $MODEL variable (if model is set)    if (model != null)      Operators.SetVariable(phpContext, null, "MODEL",                            ClrObject.WrapDynamic(model));    phpContext.Include(fileName, false);  }}

The PhalangerView method gets a file name (referring to a PHP script), a .NET object that represents the data returned as a model, and a current HTTP context. It first initializes RequestContext, so Phalanger knows it is processing a script as part of HTTP request. Then it ensures all output generated by the PHP script is sent directly as a HTTP response. When running PHP as a script, the output can be redirected to a memory stream and processed in a different way. Finally, the method declares a global variable MODEL and executes the PHP script using the Include method provided by Phalanger.

This example is not a definitive guide on calling PHP scripts from C# - you can find more detailed information in an article on the Phalanger blog. However, it should demonstrate that calling PHP scripts from C# using Phalanger is quite easy. This can be useful in the web programming scenario discussed in this section, but it gives a wide range of other options.

Click here to download:

Monospace_2011-GregShackles-IntroductiontoAndroiddevelopmentusing.NetandMono2.pdf (1.06 MB)

(download)

Click here to download:

Monospace_2011-GregShackles-IntroductiontoAndroiddevelopmentusing.NetandMono2.pdf (1.06 MB)

About the conference
Monospace provides developers a unique look at running their applications across all the platforms using Microsoft's .NET Framework by focusing on the Mono framework and open source .NET technologies. We will start with 2 days of talks and sessions, aiming to teach the attendees about the various technologies and innovations that currently exists. We will then end with a one day open space unconference where dialogs and conversations will help kick start the next wave of open source projects that will help the community remain competitive.   

Read More…

Looking for a trusted development partner to build your custom Mobile applications using .Net? Visit us at: www.amt.in

The mobile revolution is all about the apps, and expectations of both device capabilities and user experience have profoundly changed. Consumer owned devices are entering the workplace at an unprecedented level, and rather than the IT department dictating device choice the average worker is driving adoption.

This seismic shift in the power structure of enterprise IT is creating a huge demand for cross-platform development solutions. CEO’s and CIO’s across industries have made significant investments in C# and .NET technologies. Mono empowers them to bring these technologies to new platforms, and is poised to make a huge impact in the enterprise.

Scott Olson presents the current mobile industry landscape, what enterprise mobility opportunities are, and how developers can profit with cross-platform development with Mono.

Click here to download:

MONO2011-ScottOlson-MonospaceKeynote.pdf (1.32 MB)

(download)

Click here to download:

MONO2011-ScottOlson-MonospaceKeynote.pdf (1.32 MB)

About the conference

Monospace provides developers a unique look at running their applications across all the platforms using Microsoft's .NET Framework by focusing on the Mono framework and open source .NET technologies.

Read the full story…

In what’s becoming a tradition, Microsoft has once again confused the version numbers of one of their key products. In brief what you need to target Windows Phone 7.5 is the Windows Phone 7.1 SDK and the August 2011 build of the Windows Phone Toolkit. Or you can give the PhoneGap beta a spin.

“Windows Phone 7.5” is the official name for the successor to Windows Phone 7. Originally called “Mango” or “Windows Phone 7.1”, it WP 7.5 is packed with features deemed necessary to compete with the iOS and Android-based devices. From a technological standpoint it seems to be a solid operating system with support for both Silverlight 4 and IE 9‘s variant of HTML 5. Native development is not possible at this time, that level of the operating system is essentially restricted to device drivers. Rumor has it that Adobe and possibly the actual device manufacturers have access to a native SDK, but nothing definitive is known at this time.

.NET Development

The preferred development environment for Windows Phone 7.5 is Silverlight 4. In the previous version developers had to choose between Silverlight 3 or XNA, but that dichotomy is no longer exists. Though the final version won’t be ready until September, developers can now use the release candidate of the matching SDK, confusingly named Windows Phone SDK 7.1.

Like the browser-based version of Silverlight, Microsoft has a separate project for experimental features. The full name of this is the Windows Phone Toolkit - August 2011 (7.1 SDK). Jeff Wilcox is highlighting these new features for this release.

• LongListSelector has been rebuilt and redesigned to take advantage of the new smooth scrolling and off-thread touch input support in ‘Mango’. This is a buttery-smooth control for showing lists, including grouping and jump list support.
• MultiselectList control enables multiple selection for easily working with lists of data, similar to the Mail app’s capability.
• LockablePivot adds a special mode to the Pivot control where only the current item is shown (often used with multiple selection).
• ExpanderView is a primitive items control that can be used for expanding and collapsing items (like the threaded views in the Mail app).
• HubTile lets you add beautiful, informative, animated tiles to your application, similar to the new People groups in ‘Mango’.
• ContextMenu control has been reworked: performance improvements and visual consistency fixes.
• ListPicker now supports multiple selection.
• RecurringDaysPicker lets your users select a day of the week.
• Date & Time Converters localized to 22 languages. The converters let developers easily display date and time in the user interface in one of the many styles found throughout the phone’s UI, from a short date like ‘7/19’ to relative times like ‘about a month ago’.
• Page Transitions have improved performance for a more responsive feel.
• PhoneTextBox is an early look at an enhanced text box with action icon support, watermarking, etc.

The toolkit is available as an open source project under the Microsoft Public License.

Web Development

The web browser included in WP 7.5 is Internet Explorer 9, which in theory means anything that works in IE 9 for the desktop will also work in the phone’s browser. There are numerous compatibility charts, one of the more useful one is found on CanIUse.com.

Native Feature Support with HTML/JavaScript Development

PhoneGap offers a way to access native features on the phone while still using HTML and JavaScript in a cross-platform setting. The PhoneGap runtime is essentially a dedicated web browser that is backed with the application it runs. AJAX calls to specially formed URLs are intercepted by this “browser” and rerouted to native calls on the device. Applications built this way need to be repackaged for each target operating system. Full support is offered for Android and newer iOS devices, with many other devices having partial support.

Matt Lacey is leading the effort to offer PhoneGap support for Windows Phone 7.5. It currently isn’t release quality, but for internal applications and demos it may be enough. There is also an ongoing project for PhoneGap on Blackberry.

Adobe Flash/AIR

Unfortunately it has been over a year since we heard anything definitive from Adobe. At this point our recommendation is to not bet on AIR to actually be available this year, but we cannot rule out a surprise announcement at the BUILD conference either.

Read more…

(download)

Click here to download:

a-few-useful-resources-for-windows-phone-developers-lGlDHixDqcipDhvpjhso.zip (59 KB)

Don't like to miss out any of our posts? Do Subscribe to our Feed

This is an interesting video presentation where Bart De Smet explains the design philosophy behind the reactive framework Rx, the combinators and operators defined by Rx, and the work in progress to integrate it with async.

You may also check out the slide of the presentation here.

Don't like to miss out any of our posts? Do Subscribe to our Feed

What is Jurassic?

Jurassic is an implementation of the ECMAScript language and runtime. It aims to provide the best performing and most standards-compliant implementation of JavaScript for .NET. Jurassic is not intended for end-users; instead it is intended to be integrated into .NET programs. If you are the author of a .NET program, you can use Jurassic to compile and execute JavaScript code.

Features

1. Supports all ECMAScript 3 and ECMAScript 5 functionality, including ES5 strict mode
2. Simple yet powerful API
3. Compiles JavaScript into .NET bytecode (CIL); not an interpreter
4. Deployed as a single .NET assembly (no native code)
5. Basic support for integrated debugging within Visual Studio
6. Uses light-weight code generation, so generated code is fully garbage collected
7. Tested on .NET 3.5, .NET 4 and Silverlight

Read more...

Have you tried jurassic? Share your thoughts about it in the comments section.