Is there any shelf component that can be used to evaluate expressions on an object?

This method may be helpful to you - especially with regard to dependency views, since you only depend on infrastructure components.

EDIT : As defined by @Asti, this method creates dynamic assemblies which, unfortunately, cannot be unloaded due to design limitations of the .net Framework, so should be examined carefully before using it. This means that when the script is updated, the old assembly containing the previous version of the script cannot be unloaded from memory and will linger until the application or hosting services are restarted.

In a scenario where the frequency of changes to scripts is reduced, and where compiled scripts are cached and reused and not recompiled on every use, this memory leak can be safely tolerated IMO (this was the case for all of our uses of this method). Fortunately, in my experience, the memory footprint of the generated assemblies for typical scripts tends to be quite small.

If this is not acceptable, the scripts can be compiled on a separate AppDomain, which can be removed from memory, although this would require marshalling calls between domains (such as a WCF service named pipe) or perhaps an IIS hosting service where the offload occurs automatically after a period inactivity or memory threshold exceeded.)

End EDIT

First, you need to add a reference to your project Microsoft.CSharp

and add the following expressions using operators

using System.CodeDom.Compiler;   // this is included in System.Dll assembly
using Microsoft.CSharp;

      

        
        
        
      

    

Then I add the following method:

 private void TestDynCompile() {
         // the code you want to dynamically compile, as a string

         string code = @"
            using System;

            namespace DynCode {
               public class TestClass {
                  public string MyMsg(string name) {
                     //---- this would be code your users provide
                     return string.Format(""Hello {0}!"", name);
                     //-----
                  }
               }
            }";

         // obtain a reference to a CSharp compiler
         var provider = CodeDomProvider.CreateProvider("CSharp");

         // Crate instance for compilation parameters
         var cp = new CompilerParameters();

         // Add assembly dependencies
         cp.ReferencedAssemblies.Add("System.dll");

         // hold compiled assembly in memory, don't produce an output file
         cp.GenerateInMemory = true;
         cp.GenerateExecutable = false;

         // don't produce debugging information    
         cp.IncludeDebugInformation = false;

         // Compile source code
         var rslts = provider.CompileAssemblyFromSource(cp, code);

         if( rslts.Errors.Count == 0 ) {
            // No errors in compilation, obtain type for DynCode.TestClass
            var type = rslts.CompiledAssembly.GetType("DynCode.TestClass");
            // Create an instance for the dynamically compiled class
            dynamic instance = Activator.CreateInstance(type);
            // Invoke dynamic code
            MessageBox.Show(instance.MyMsg("Gerardo"));  // Hello Gerardo! is diplayed  =)
         }
       }

      

        
        
        
      

    

As you can see, you need to add boilerplate like wrapper class definition, inject assembly dependencies, etc.), but this is a really powerful technique that adds scripting capabilities with full C # syntax and is almost as fast as static code. (Invocation will be a little slower).

Assembly dependencies can reference your own project dependencies, so the classes and types defined in your project can be referenced and used within dynamic code.

Hope this helps!

The "component" you are talking about:

• It is required to understand the C # syntax (to parse your input string)
• It is necessary to understand the semantics of C # (where to perform implicit int-> double conversions, etc.).
• Need to generate IL code

Such a "component" is called a C # compiler.

• The existing Microsoft C # compiler is a bad option because it runs in a separate process (thus increasing compilation time since all metadata needs to be loaded into this process) and can only collect complete assemblies (and .NET assemblies cannot be unloaded without unloading the entire AppDomain, thereby leaking memory). However, if you can live with these limitations, this is an easy solution - see sgorozco's answer.

• The future Microsoft C # compiler (Roslyn project) will be able to do what you want, but that's still some time in the future. I assume it will be released with the next VS after VS11, i.e. with C # 6.0.

• The Mono C # compiler (see Response to H answer) can do what you want, but I don't know if it supports code unloading or if there will be a memory leak.

• Scan your own. You know which subset of C # you need to support, and there are separate components available for the various "needs" above. For example, NRefactory 5 can parse C # code and parse semantics. Expression trees make it much easier to generate IL code. You can write a converter from NRefactory ResolveResults to expression trees that will most likely solve your problem in less than 300 lines of code. However, NRefactory reuses a significant chunk of the Mono C # compiler in its parser - and if you accept this large dependency, you can go with option 3 as well.

Not sure about performance, but it looks like a good dynamic linq match ...

Generate an xsd from the SiteModel class, then via web / whatever-UI let the admin enter the expression, transform the input via xsl, where you modify the expression as a literal functor, and then generate and execute it via CodeDom on the fly.