How To Using Node Services In ASP.NET Core

CheapASPNETHostingReview.com | Best and cheap ASP.NET Core Hosting. This post is about running Javascript code in the Server. Because a huge number of useful, high-quality Web-related open source packages are in the form of Node Package Manager (NPM) modules. NPM is the largest repository of open-source software packages in the world, and the Microsoft.AspNetCore.NodeServices package means that you can use any of them in your ASP.NET Core application.

To use Node Services, first you need to include the reference of Microsoft.AspNetCore.NodeServices package in your project file. You can do this using dotnet add package Microsoft.AspNetCore.NodeServices command.

    &lt;ItemGroup&gt;  
        &lt;PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.0-preview1-final" /&gt;  
        &lt;PackageReference Include="Microsoft.AspNetCore.NodeServices" Version="1.1.1" /&gt;  
    &lt;/ItemGroup&gt;

</ItemGroup>

Then you need to add the Node Services middleware to the request pipeline. You can do it in your ConfigureServices() method.

    public void ConfigureServices(IServiceCollection services) {  
        services.AddMvc();  
        services.AddNodeServices();  
    }

public void ConfigureServices(IServiceCollection services) {

services.AddMvc();

services.AddNodeServices();

}

Now you’re able to get instance of INodeServices in your application. INodeServices is the API through which .NET code can make calls into JavaScript that runs in a Node environment. You can use FromServices attribute to get the instance of `INodeServices’ in your action method. Here is Add method implementation in MVC.

public async Task &lt; IActionResult &gt; Add([FromServices] INodeServices nodeServices) {  
    var num1 = 10;  
    var num2 = 20;  
    var result = await nodeServices.InvokeAsync &lt; int &gt; ("AddModule.js", num1, num2);  
    ViewData["ResultFromNode"] = $ "Result of {num1} + {num2} is {result}";  
    return View();  
}

public async Task < IActionResult > Add([FromServices] INodeServices nodeServices) {

var num1 = 10;

var num2 = 20;

var result = await nodeServices.InvokeAsync < int > ("AddModule.js", num1, num2);

ViewData["ResultFromNode"] = $ "Result of {num1} + {num2} is {result}";

return View();

}

And here is the code of AddModule.js file

    module.exports = function(callback, num1, num2) {  
        var result = num1 + num2;  
        callback(null, result);  
    };

module.exports = function(callback, num1, num2) {

var result = num1 + num2;

callback(null, result);

};

You need to use the type of the result in your InvokeAsync method, in this example I am using int. NodeServices allows ASP.NET Core developers to make use of the entire NPM ecosystem, which gives rise to a huge range of possibilities. You can find the full source code on GitHub.

Happy Programming.

How to Create Dynamic DropDownLists in ASP.NET

CheapASPNETHostingReview.com | Best and cheap ASP.NET hosting. In this post I will tell you how to create Dynamic DropDownLists in ASP.NET

Object:

Create dropdownlist dynamically with autopostback property true
Keep dropdownlist during postback
Maintain selected value during postback.

Here is the sample for this :

In aspx page:
&lt;form id="form1" runat="server"&gt;
    &lt;div&gt;
        &lt;asp:Table ID="tbl" runat="server"&gt;
        &lt;/asp:Table&gt;
        &lt;asp:Button ID="btnSet" runat="server" Text="Button" onclick="btnSet_Click" /&gt; &lt;/div&gt;
    &lt;/form&gt;

In aspx page:

<div>

<asp:Table ID="tbl" runat="server">

</asp:Table>

<asp:Button ID="btnSet" runat="server" Text="Button" onclick="btnSet_Click" /> </div>

</form>

To Create Dynamic Dropdownlist:

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    {
    CreateDynamicTable();
    }
}
    private void CreateDynamicTable()
    {  
        // Fetch the number of Rows and Columns for the table
        // using the properties
        int tblRows = 3;
        int tblCols = 3;
        // Now iterate through the table and add your controls
        for (int i = 0; i &lt; tblRows; i++)
        {
            TableRow tr = new TableRow();
            for (int j = 0; j &lt; tblCols; j++)
            {
                TableCell tc = new TableCell();
                DropDownList ddl = new DropDownList();
                ddl.ID = "ddl-" + i.ToString() + "-" + j.ToString();
                for (int k = 0; k &lt; 5; k++)
                {
                    ddl.Items.Add(new ListItem("item-"+k.ToString(),k.ToString())); 
                }
                ddl.AutoPostBack = true;
                ddl.SelectedIndexChanged += new EventHandler(ddl_SelectedIndexChanged);
                // Add the control to the TableCell
                tc.Controls.Add(ddl);
                // Add the TableCell to the TableRow
                tr.Cells.Add(tc);
            }
            // Add the TableRow to the Table
            tbl.Rows.Add(tr);
            tbl.EnableViewState = true;
            ViewState["tbl"] = true;
        }
    }
protected void ddl_SelectedIndexChanged(object sender, EventArgs e)
    {
    // what you want to perform    
    }

protected void Page_Load(object sender, EventArgs e)

{

if (!Page.IsPostBack)

{

CreateDynamicTable();

}

private void CreateDynamicTable()

{

// Fetch the number of Rows and Columns for the table

// using the properties

int tblRows = 3;

int tblCols = 3;

// Now iterate through the table and add your controls

for (int i = 0; i < tblRows; i++)

{

TableRow tr = new TableRow();

for (int j = 0; j < tblCols; j++)

{

TableCell tc = new TableCell();

DropDownList ddl = new DropDownList();

ddl.ID = "ddl-" + i.ToString() + "-" + j.ToString();

for (int k = 0; k < 5; k++)

{

ddl.Items.Add(new ListItem("item-"+k.ToString(),k.ToString()));

}

ddl.AutoPostBack = true;

ddl.SelectedIndexChanged += new EventHandler(ddl_SelectedIndexChanged);

// Add the control to the TableCell

tc.Controls.Add(ddl);

// Add the TableCell to the TableRow

tr.Cells.Add(tc);

}

// Add the TableRow to the Table

tbl.Rows.Add(tr);

tbl.EnableViewState = true;

ViewState["tbl"] = true;

}

protected void ddl_SelectedIndexChanged(object sender, EventArgs e)

{

// what you want to perform

}

To retrieve value on button click:

protected void btnSet_Click(object sender, EventArgs e)
    {
        foreach (TableRow tr in tbl.Controls )
        {
            foreach (TableCell tc in tr.Controls)
           {
                if (tc.Controls[0] is DropDownList)
                {
                    Response.Write(((DropDownList)tc.Controls[0]).SelectedItem.Text+" ");        
                }
            }
            Response.Write("&lt;br/&gt;"); 
        }
    }

protected void btnSet_Click(object sender, EventArgs e)

{

foreach (TableRow tr in tbl.Controls )

{

foreach (TableCell tc in tr.Controls)

{

if (tc.Controls[0] is DropDownList)

{

Response.Write(((DropDownList)tc.Controls[0]).SelectedItem.Text+" ");

}

Response.Write("<br/>");

}

Right Now, No output because dynamic controls are lost in postback then what to do.
So we need to save dynamic controls value and generate dynamic controls again.we need to maintain viewstate.

protected override object SaveViewState()
{
    object[] newViewState = new object[2];
    List&lt;string&gt; txtValues = new List&lt;string&gt;();
    foreach (TableRow row in tbl.Controls)
    {
        foreach (TableCell cell in row.Controls)
        {
            if (cell.Controls[0] is DropDownList)
            {
                txtValues.Add(((DropDownList)cell.Controls[0]).SelectedIndex.ToString());
            }
        }
    }
    newViewState[0] = txtValues.ToArray();
    newViewState[1] = base.SaveViewState();
    return newViewState;
}
protected override void LoadViewState(object savedState)
{
    //if we can identify the custom view state as defined in the override for SaveViewState
    if (savedState is object[] &amp;&amp; ((object[])savedState).Length == 2 &amp;&amp; ((object[])savedState)[0] is string[])
    {
        object[] newViewState = (object[])savedState;
        string[] txtValues = (string[])(newViewState[0]);
        if (txtValues.Length &gt; 0)
        {
            //re-load tables
            CreateDynamicTable();
            int i = 0;
            foreach (TableRow row in tbl.Controls)
            {
                foreach (TableCell cell in row.Controls)
                {
                    if (cell.Controls[0] is DropDownList &amp;&amp; i &lt; txtValues.Length)
                    {
                        ((DropDownList)cell.Controls[0]).SelectedIndex = Convert.ToInt32(txtValues[i++]);
                    }
                }
            }
        }
        //load the ViewState normally
        base.LoadViewState(newViewState[1]);
    }
    else
    {
        base.LoadViewState(savedState);
    }
}

protected override object SaveViewState()

{

object[] newViewState = new object[2];

List<string> txtValues = new List<string>();

foreach (TableRow row in tbl.Controls)

{

foreach (TableCell cell in row.Controls)

{

if (cell.Controls[0] is DropDownList)

{

txtValues.Add(((DropDownList)cell.Controls[0]).SelectedIndex.ToString());

}

newViewState[0] = txtValues.ToArray();

newViewState[1] = base.SaveViewState();

return newViewState;

}

protected override void LoadViewState(object savedState)

{

//if we can identify the custom view state as defined in the override for SaveViewState

if (savedState is object[] && ((object[])savedState).Length == 2 && ((object[])savedState)[0] is string[])

{

object[] newViewState = (object[])savedState;

string[] txtValues = (string[])(newViewState[0]);

if (txtValues.Length > 0)

{

//re-load tables

CreateDynamicTable();

int i = 0;

foreach (TableRow row in tbl.Controls)

{

foreach (TableCell cell in row.Controls)

{

if (cell.Controls[0] is DropDownList && i < txtValues.Length)

{

((DropDownList)cell.Controls[0]).SelectedIndex = Convert.ToInt32(txtValues[i++]);

}

//load the ViewState normally

base.LoadViewState(newViewState[1]);

}

else

{

base.LoadViewState(savedState);

}

How To Using Sessions and HttpContext in ASP.NET Core and MVC Core

CheapASPNETHostingReview.com | Best and cheap ASP.NET core 1.0 hosting. If you’re new to ASP.NET Core or MVC Core, you’ll find that sessions don’t work the way they used to. Here’s how to get up and running the new way.

Add Session NuGet Package

Add the Microsoft.AspNetCore.Session NuGet package to your project.

VERSION WARNING: As you’ll find with most Microsoft.* packages, you should make sure the versions all match. At RTM time as of writing, this means “1.0.0”.

Update startup.cs

Now that we have the Session nuget package installed, we can add sessions to the ASP.NET Core pipeline.

Open up startup.cs and add the AddSession() and AddDistributedMemoryCache() lines to the ConfigureServices(IServiceCollection services)

// Add MVC services to the services container.
services.AddMvc();
services.AddDistributedMemoryCache(); // Adds a default in-memory implementation of IDistributedCache
services.AddSession();

// Add MVC services to the services container.

services.AddMvc();

services.AddDistributedMemoryCache(); // Adds a default in-memory implementation of IDistributedCache

services.AddSession();

Next, we’ll tell ASP.NET Core to use a Memory Cache to store the session data. Add the UseSession() call below to the Configure(IApplicationBulider app, ...)

// IMPORTANT: This session call MUST go before UseMvc()
app.UseSession();

// Add MVC to the request pipeline.
app.UseMvc(routes =&gt;
{
    routes.MapRoute(
        name: "default",
        template: "{controller=Home}/{action=Index}/{id?}");
});

// IMPORTANT: This session call MUST go before UseMvc()

app.UseSession();

// Add MVC to the request pipeline.

app.UseMvc(routes =>

{

routes.MapRoute(

name: "default",

template: "{controller=Home}/{action=Index}/{id?}");

});

Where’s the Session variable gone?

Relax it’s still there, just not where you think it is. You can now find the session object by using HttpContext.Session. HttpContext is just the current HttpContext exposed to you by the Controller class.

If you’re not in a controller, you can still access the HttpContext by injecting IHttpContextAccessor.

Let’s go ahead and add sessions to our Home Controller:

using Microsoft.AspNetCore.Http; // Needed for the SetString and GetString extension methods

public class HomeController : Controller
{
    public IActionResult Index()
    { 
        HttpContext.Session.SetString("Test", "Ben Rules!");
        return View();
    }

    public IActionResult About()
    {
        ViewBag.Message = HttpContext.Session.GetString("Test");

        return View();
    }
}

using Microsoft.AspNetCore.Http; // Needed for the SetString and GetString extension methods

public class HomeController : Controller

{

public IActionResult Index()

{

HttpContext.Session.SetString("Test", "Ben Rules!");

return View();

}

public IActionResult About()

{

ViewBag.Message = HttpContext.Session.GetString("Test");

return View();

}

You’ll see the Index() and About() methods making use of the Session object. It’s pretty easy here, just use one of the Set() methods to store your data and one of the Get() methods to retrieve it.

Just for fun, let’s inject the context into a random class:

public class SomeOtherClass
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private ISession _session =&gt; _httpContextAccessor.HttpContext.Session;

    public SomeOtherClass(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

    public void TestSet()
    {
        _session.SetString("Test", "Ben Rules!");
    }

    public void TestGet()
    {
        var message = _session.GetString("Test");
    }
}

public class SomeOtherClass

{

private readonly IHttpContextAccessor _httpContextAccessor;

private ISession _session => _httpContextAccessor.HttpContext.Session;

public SomeOtherClass(IHttpContextAccessor httpContextAccessor)

{

_httpContextAccessor = httpContextAccessor;

}

public void TestSet()

{

_session.SetString("Test", "Ben Rules!");

}

public void TestGet()

{

var message = _session.GetString("Test");

}

Let’s break this down.

Firstly I’m setting up a private variable to hold the HttpContextAccessor. This is the way you get the HttpContext now.

Next I’m adding a convenience variable as a shortcut directly to the session. Notice the =>? That means we’re using an expression body, aka a shortcut to writing a one liner method that returns something.

Moving to the contructor you can see that I’m injecting the IHttpContextAccessor and assigning it to my private variable. If you’re not sure about this whole dependency injection thing, don’t worry, it’s not hard to get the hang of (especially constructor injection like I’m using here) and it will improve your code by forcing you to write it in a modular way.

But wait a minute, how do I store a complex object?

How do I store a complex object?

I’ve got you covered here too. Here’s a quick JSON storage extension to let you store complex objects nice and simple

public static class SessionExtensions
{
    public static void SetObjectAsJson(this ISession session, string key, object value)
    {
        session.SetString(key, JsonConvert.SerializeObject(value));
    }

    public static T GetObjectFromJson&lt;T&gt;(this ISession session, string key)
    {
        var value = session.GetString(key);

        return value == null ? default(T) : JsonConvert.DeserializeObject&lt;T&gt;(value);
    }
}

public static class SessionExtensions

{

public static void SetObjectAsJson(this ISession session, string key, object value)

{

session.SetString(key, JsonConvert.SerializeObject(value));

}

public static T GetObjectFromJson<T>(this ISession session, string key)

{

var value = session.GetString(key);

return value == null ? default(T) : JsonConvert.DeserializeObject<T>(value);

}

Now you can store your complex objects like so:

var myComplexObject = new MyClass();
HttpContext.Session.SetObjectAsJson("Test", myComplexObject);

1 2	var myComplexObject = new MyClass(); HttpContext.Session.SetObjectAsJson("Test", myComplexObject);

and retrieve them just as easily:

var myComplexObject = HttpContext.Session.GetObjectFromJson&lt;MyClass&gt;("Test");

1	var myComplexObject = HttpContext.Session.GetObjectFromJson<MyClass>("Test");

Use a Redis or SQL Server Cache instead

Instead of using services.AddDistributedMemoryCache() which implements the default in-memory cache, you can use either of the following.

SQL Server
Firstly, install this nuget package:

"Microsoft.Extensions.Caching.SqlServer": "1.0.0"

Secondly, add the appropriate code snippet below:

// Microsoft SQL Server implementation of IDistributedCache.
// Note that this would require setting up the session state database.
services.AddSqlServerCache(o =&gt;
{
	o.ConnectionString = "Server=.;Database=ASPNET5SessionState;Trusted_Connection=True;";
	o.SchemaName = "dbo";
	o.TableName = "Sessions";
});

// Microsoft SQL Server implementation of IDistributedCache.

// Note that this would require setting up the session state database.

services.AddSqlServerCache(o =>

{

o.ConnectionString = "Server=.;Database=ASPNET5SessionState;Trusted_Connection=True;";

o.SchemaName = "dbo";

o.TableName = "Sessions";

});

Redis Cache
Unfortunately, the redis package does not support netcoreapp1.0 at the moment. You can still use this if you’re using net451 or higher.

"Microsoft.Extensions.Caching.Redis": "1.0.0"

// Redis implementation of IDistributedCache.
// This will override any previously registered IDistributedCache service.
services.AddSingleton&lt;IDistributedCache, RedisCache&gt;();

// Redis implementation of IDistributedCache.

// This will override any previously registered IDistributedCache service.

services.AddSingleton<IDistributedCache, RedisCache>();

Stay up to date

Even though we’ve reached RTM, you should still keep an eye on the ASP.NET Session Repository for any changes.

Using a Calculation Engine for .NET

CheapASPNETHostingReview.com | Best and cheap ASP.NET hosting. “Creating a mathematical expression evaluator is one of the most interesting exercises in computer science, whatever the language used. This is the first step towards really understanding what sort of magic is hidden behind compilers and interpreters….“.

I agree completely, and hope that you do too.

Using the CalcEngine class

The CalcEngine class performs two main tasks:

Parses strings that contain formulas into Expression objects that can be evaluated.
Evaluates Expression objects and returns the value they represent.

To evaluate a string that represents a formula, you call the CalcEngine.Parse method to get an Expression, then call the Expression.Evaluate method to get the value. For example:

var ce = new CalcEngine();
var x = ce.Parse("1+1");
var value = (double)x.Evaluate();

var ce = new CalcEngine();

var x = ce.Parse("1+1");

var value = (double)x.Evaluate();

Alternatively, you can call the CalcEngine.Evaluate method directly. This parses the string into an expression, evaluates the expression, and returns the result. For example:

var ce = new CalcEngine();
var value = (double)ce.Evaluate("1+1");

1 2	var ce = new CalcEngine(); var value = (double)ce.Evaluate("1+1");

The advantage of the first method is that it allows you to store the parsed expressions and re-evaluate them without re-parsing the same string several times. However, the second method is more convenient, and because the CalcEngine has a built-in expression cache, the parsing overhead is very small.

Functions

The CalcEngine class implements 69 functions, selected from Excel’s over 300. More functions can be added easily using the RegisterFunction method.

RegisterFunction takes a function name, the number of parameters (minimum and maximum), and a delegate that is responsible for evaluating the function. For example, the “atan” function is implemented as follows:

var ce = new CalcEngine();
ce.RegisterFunction("ATAN2", 2, Atan2);

static object Atan2(List&lt;Expression&gt; p)
{
    return Math.Atan2((double)p[0], (double)p[1]);
}

var ce = new CalcEngine();

ce.RegisterFunction("ATAN2", 2, Atan2);

static object Atan2(List<Expression> p)

{

return Math.Atan2((double)p[0], (double)p[1]);

}

Function names are case-insensitive (as in Excel), and the parameters are themselves expressions. This allows the engine to calculate expressions such as “=ATAN(2+2, 4+4*SIN(4))”.

The CalcEngine class also provides a Functions property that returns a dictionary containing all the functions currently defined. This can be useful if you ever need to enumerate remove functions from the engine.

Notice how the method implementation listed above casts the expression parameters to the expected type (double). This works because the Expression class implements implicit converters to several types (string, double, bool, and DateTime). I find that the implicit converters allow me to write code that is concise and clear.

If you don’t like implicit converters, the alternative would be to override ToString in the Expression class and add ToDouble, ToDateTime, ToBoolean, etc.

Variables: Binding to simple values

Most calculation engines provide a way for you to define variables which can be used in expressions. The CalcEngine class implements a Variables dictionary that associates keys (variable names) and values (variable contents).

For example, the code below defines a variable named angle and calculates a short sine table:

// create the CalcEngine
var ce = new CalcEngine.CalcEngine();

// calculate sin from 0 to 90 degrees
for (int angle = 0; angle &lt;= 90; angle += 30)
{
    // update value of "angle" variable
    ce.Variables["angle"] = angle;

    // calculate sine
    var sin = ce.Evaluate("sin(angle * pi() / 180)");

    // write it out
    Console.WriteLine("sin({0}) = {1}", angle, sin);
}

// output:
sin(0) = 0
sin(30) = 0.5
sin(60) = 0.866025403784439
sin(90) = 1

// create the CalcEngine

var ce = new CalcEngine.CalcEngine();

// calculate sin from 0 to 90 degrees

for (int angle = 0; angle <= 90; angle += 30)

{

// update value of "angle" variable

ce.Variables["angle"] = angle;

// calculate sine

var sin = ce.Evaluate("sin(angle * pi() / 180)");

// write it out

Console.WriteLine("sin({0}) = {1}", angle, sin);

}

// output:

sin(0) = 0

sin(30) = 0.5

sin(60) = 0.866025403784439

sin(90) = 1

Variables: Binding to CLR objects

In addition to simple values, the CalcEngine class implements a DataContext property that allows callers to connect a regular .NET object to the engine’s evaluation context. The engine uses Reflection to access the properties of the object so they can be used in expressions.

This approach is similar to the binding mechanism used in WPF and Silverlight, and is substantially more powerful than the simple value approach described in the previous section. However, it is also slower than using simple values as variables.

For example, if you wanted to perform calculations on an object of type Customer, you could do it like this:

// Customer class used as a DataContext
public class Customer
{
    public string Name { get; set; }
    public double Salary { get; set; }
    public List

// Customer class used as a DataContext

public class Customer

{

public string Name { get; set; }

public double Salary { get; set; }

public List

CalcEngine supports binding to sub-properties and collections. The object assigned to the DataContext property can represent complex business objects and entire data models.

This approach makes it easier to integrate the calculation engine into the application, because the variables it uses are just plain old CLR objects. You don’t have to learn anything new in order to apply validation, notifications, serialization, etc.

Variables: Binding to dynamic objects

The original usage scenario for the calculation engine was an Excel-like application, so it had to be able to support cell range objects such as “A1” or “A1:B10”. This requires a different approach, since the cell ranges have to be parsed dynamically (it would not be practical to define a DataContext object with properties A1, A2, A3, etc).

To support this scenario, the CalcEngine implements a virtual method called GetExternalObject. Derived classes can override this method to parse identifiers and dynamically build objects that can be evaluated.

If the object returned implements the CalcEngine.IValueObject interface, the engine evaluates it by calling the IValueObject.GetValue method. Otherwise, the object itself is used as the value.

If the object returned implements the IEnumerable interface, then functions that take multiple values (such as Sum, Count, or Average) use the IEnumerable implementation to get all the values represented by the object.

For example, the sample application included with this article defines a DataGridCalcEngine class that derives from CalcEngine and overrides GetExternalObject to support Excel-style ranges. This is described in detail in a later section (“Adding Formula Support to the DataGridView Control”).

Optimizations

I mentioned earlier that the CalcEngine class performs two main functions: parsing and evaluating.

If you look at the CalcEngine code, you will notice that the parsing methods are written for speed, sometimes even at the expense of clarity. The GetToken method is especially critical, and has been through several rounds of profiling and tweaking.

For example, GetToken detects characters and digits using logical statements instead of the convenient char.IsAlpha or char.IsDigit methods. This does make a difference that shows up clearly in the benchmarks.

In addition to this, CalcEngine implements two other optimization techniques:

Expression caching

The parsing process typically consumes more time than the actual evaluation, so it makes sense to keep track of parsed expressions and avoid parsing them again, especially if the same expressions are likely to be used over and over again (as in spreadsheet cells or report fields, for example).

The CalcEngine class implements an expression cache that handles this automatically. The CalcEngine.Evaluate method looks up the expression in the cache before trying to parse it. The cache is based on WeakReference objects, so unused expressions eventually get removed from the cache by the .NET garbage collector. (This technique is also used in the NCalc library.)

Expression caching can be turned off by setting the CalcEngine.CacheExpressions property to false.

Expression optimization

After a string has been parsed, the resulting expression can sometimes be optimized by replacing parts of the expression that refer only to constant values. For example, consider the expression:

{ 4 * (4 * ATAN(1/5.0) - ATAN(1/239.0)) + A + B }

1	{ 4 * (4 * ATAN(1/5.0) - ATAN(1/239.0)) + A + B }

This expression contains several constants and functions of constants. It can be simplified to:

{ 3.141592654 + A + B }

1	{ 3.141592654 + A + B }

This second expression is equivalent to the first, but can be evaluated much faster.

Expression simplification was surprisingly easy to implement. It consists of a virtual Expression.Optimize method that is called immediately after an expression is parsed.

The base Expression class provides an Optimize method that does nothing:

class BinaryExpression : Expression
{
    public virtual Expression Optimize()
    {
        return this;
    }
    ...

class BinaryExpression : Expression

{

public virtual Expression Optimize()

{

return this;

}

...

This simply allows all derived classes that derive from Expression to implement their own optimization strategy.

For example, the BinaryExpression class implements the Optimize method as follows:

class BinaryExpression : Expression
{
    public override Expression Optimize()
    {
        _lft = _lft.Optimize();
        _rgt = _rgt.Optimize();
        return _lft._token.Type == TKTYPE.LITERAL &amp;&amp;
               _rgt._token.Type == TKTYPE.LITERAL
            ? new Expression(this.Evaluate())
            : this;
    }
    ..

class BinaryExpression : Expression

{

public override Expression Optimize()

{

_lft = _lft.Optimize();

_rgt = _rgt.Optimize();

return _lft._token.Type == TKTYPE.LITERAL &&

_rgt._token.Type == TKTYPE.LITERAL

? new Expression(this.Evaluate())

: this;

}

The method calls the Optimize method on each of the two operand expressions. If the resulting optimized expressions are both literal values, then the method calculates the result (which is a constant) and returns a literal expression that represents the result.

To illustrate further, function call expressions are optimized as follows:

class FunctionExpression : Expression
{
    public override Expression Optimize()
    {
        bool allLits = true;
        if (_parms != null)
        {
            for (int i = 0; i &lt; _parms.Count; i++)
            {
                var p = _parms[i].Optimize();
                _parms[i] = p;
                if (p._token.Type != TKTYPE.LITERAL)
                {
                    allLits = false;
                }
            }
        }
        return allLits
            ? new Expression(this.Evaluate())
            : this;
    }
    ...

class FunctionExpression : Expression

{

public override Expression Optimize()

{

bool allLits = true;

if (_parms != null)

{

for (int i = 0; i < _parms.Count; i++)

{

var p = _parms[i].Optimize();

_parms[i] = p;

if (p._token.Type != TKTYPE.LITERAL)

{

allLits = false;

}

return allLits

? new Expression(this.Evaluate())

: this;

}

...

First, all parameters are optimized. Next, if all optimized parameters are literals, the function call itself is replaced with a literal expression that represents the result.

Expression optimization reduces evaluation time at the expense of a slight increase in parse time. It can be turned off by setting the CalcEngine.OptimizeExpressions property to false.

Globalization

The CalcEngine class has a CultureInfo property that allows you to define how the engine should parse numbers and dates in expressions.

By default, the CalcEngine.CultureInfo property is set to CultureInfo.CurrentCulture, which causes it to use the settings selected by the user for parsing numbers and dates. In English systems, numbers and dates look like “123.456” and “12/31/2011”. In German or Spanish systems, numbers and dates look like “123,456” and “31/12/2011”. This is the behavior used by Microsoft Excel.

If you prefer to use expressions that look the same on all systems, you can set the CalcEngine.CultureInfo property to CultureInfo.InvariantCulture for example, or to whatever your favorite culture happens to be.

Sample: A DataGridView control with formula support

The sample included with this article shows how the CalcEngine class can be used to extend the standard Microsoft DataGridView control to support Excel-style formulas. The image at the start of the article shows the sample in action.

Note that the formula support described here is restricted to typing formulas into cells and evaluating them. The sample does not implement Excel’s more advanced features like automatic reference adjustment for clipboard operations, selection-style formula editing, reference coloring, and so on.

The DataGridCalcEngine class

The sample defines a DataGridCalcEngine class that extends CalcEngine with a reference to the grid that owns the engine. The grid is responsible for storing the cell values which are used in the calculations.

The DataGridCalcEngine class adds cell range support by overriding the CalcEngine.GetExternalObject method as follows:

/// &amp;lt;summary&gt;
/// Parses references to cell ranges.
/// &amp;lt;/summary&gt;
/// &amp;lt;param name="identifier"&gt;String representing a cell range 
/// (e.g. "A1" or "A1:B12".&amp;lt;/param&gt;
/// &amp;lt;returns&gt;A &amp;lt;see cref="CellRange"/&gt; object that represents 
/// the given range.&amp;lt;/returns&gt;
public override object GetExternalObject(string identifier)
{
    // check that we have a grid
    if (_grid != null)
    {
        var cells = identifier.Split(':');
        if (cells.Length &gt; 0 &amp;&amp; cells.Length &amp;lt; 3)
        {
            var rng = GetRange(cells[0]);
            if (cells.Length &gt; 1)
            {
                rng = MergeRanges(rng, GetRange(cells[1]));
            }
            if (rng.IsValid)
            {
                return new CellRangeReference(_grid, rng);
            }
        }
    }

    // this doesn't look like a range
    return null;
}

/// &lt;summary>

/// Parses references to cell ranges.

/// &lt;/summary>

/// &lt;param name="identifier">String representing a cell range

/// (e.g. "A1" or "A1:B12".&lt;/param>

/// &lt;returns>A &lt;see cref="CellRange"/> object that represents

/// the given range.&lt;/returns>

public override object GetExternalObject(string identifier)

{

// check that we have a grid

if (_grid != null)

{

var cells = identifier.Split(':');

if (cells.Length > 0 && cells.Length &lt; 3)

{

var rng = GetRange(cells[0]);

if (cells.Length > 1)

{

rng = MergeRanges(rng, GetRange(cells[1]));

}

if (rng.IsValid)

{

return new CellRangeReference(_grid, rng);

}

// this doesn't look like a range

return null;

}

The method analyzes the identifier passed in as a parameter. If the identifier can be parsed as a cell reference (e.g., “A1” or “AZ123:XC23”), then the method builds and returns a CellRangeReference object. If the identifier cannot be parsed as an expression, the method returns null.

The CellRangeReference class is implemented as follows:

class CellRangeReference : 
    CalcEngine.IValueObject, // to get the cell value
    IEnumerable // to enumerate cells in the range
{
    // ** fields
    DataGridCalc _grid;
    CellRange _rng;
    bool _evaluating;

    // ** ctor
    public CellRangeReference(DataGridCalc grid, CellRange rng)
    {
        _grid = grid;
        _rng = rng;
    }

    // ** IValueObject
    public object GetValue()
    {
        // get simple value (e.g. "A1")
        return GetValue(_rng);
    }

    // ** IEnumerable
    public IEnumerator GetEnumerator()
    {
        // get multiple values (e.g. "A1:B10")
        for (int r = _rng.TopRow; r &amp;lt;= _rng.BottomRow; r++)
        {
            for (int c = _rng.LeftCol; c &amp;lt;= _rng.RightCol; c++)
            {
                var rng = new CellRange(r, c);
                yield return GetValue(rng);
            }
        }
    }

    // ** implementation
    object GetValue(CellRange rng)
    {
        if (_evaluating)
        {
            throw new Exception("Circular reference");
        }
        try
        {
            _evaluating = true;
            return _grid.Evaluate(rng.r1, rng.c1);
        }
        finally
        {
            _evaluating = false;
        }
    }
}

class CellRangeReference :

CalcEngine.IValueObject, // to get the cell value

IEnumerable // to enumerate cells in the range

{

// ** fields

DataGridCalc _grid;

CellRange _rng;

bool _evaluating;

// ** ctor

public CellRangeReference(DataGridCalc grid, CellRange rng)

{

_grid = grid;

_rng = rng;

}

// ** IValueObject

public object GetValue()

{

// get simple value (e.g. "A1")

return GetValue(_rng);

}

// ** IEnumerable

public IEnumerator GetEnumerator()

{

// get multiple values (e.g. "A1:B10")

for (int r = _rng.TopRow; r &lt;= _rng.BottomRow; r++)

{

for (int c = _rng.LeftCol; c &lt;= _rng.RightCol; c++)

{

var rng = new CellRange(r, c);

yield return GetValue(rng);

}

// ** implementation

object GetValue(CellRange rng)

{

if (_evaluating)

{

throw new Exception("Circular reference");

}

try

{

_evaluating = true;

return _grid.Evaluate(rng.r1, rng.c1);

}

finally

{

_evaluating = false;

}

The CellRangeReference class implements the IValueObject interface to return the value in the first cell in the range. It does this by calling the owner grid’s Evaluate method.

The CellRangeReference also implements the IEnumerable interface to return the value of all cells in the range. This allows the calculation engine to evaluate expressions such as “Sum(A1:B10)”.

Notice that the GetValue method listed above uses an _evaluating flag to keep track of ranges that are currently being evaluated. This allows the class to detect circular references, where cells contain formulas that reference the cell itself or other cells that depend on the original cell.

The DataGridCalc class

The sample also implements a DataGridCalc class that derives from DataGridView and adds a DataGridCalcEngine member.

To display formula results, the DataGridCalc class overrides the OnCellFormatting method as follows:

// evaluate expressions when showing cells
protected override void OnCellFormatting(DataGridViewCellFormattingEventArgs e)
{
    // get the cell
    var cell = this.Rows[e.RowIndex].Cells[e.ColumnIndex];

    // if not in edit mode, calculate value
    if (cell != null &amp;&amp; !cell.IsInEditMode)
    {
        var val = e.Value as string;
        if (!string.IsNullOrEmpty(val) &amp;&amp; val[0] == '=')
        {
            try
            {
                e.Value = _ce.Evaluate(val);
            }
            catch (Exception x)
            {
                e.Value = "** ERR: " + x.Message;
            }
        }
    }

    // fire event as usual
    base.OnCellFormatting(e);
}

// evaluate expressions when showing cells

protected override void OnCellFormatting(DataGridViewCellFormattingEventArgs e)

{

// get the cell

var cell = this.Rows[e.RowIndex].Cells[e.ColumnIndex];

// if not in edit mode, calculate value

if (cell != null && !cell.IsInEditMode)

{

var val = e.Value as string;

if (!string.IsNullOrEmpty(val) && val[0] == '=')

{

try

{

e.Value = _ce.Evaluate(val);

}

catch (Exception x)

{

e.Value = "** ERR: " + x.Message;

}

// fire event as usual

base.OnCellFormatting(e);

}

The method starts by retrieving the value stored in the cell. If the cell is not in edit mode, and the value is a string that starts with an equals sign, the method uses CalcEngine to evaluate the formula and assigns the result to the cell.

If the cell is in edit mode, then the editor displays the formula rather than the value. This allows users to edit the formulas by typing into in the cells, just like they do in Excel.

If the expression evaluation causes any errors, the error message is displayed in the cell.

At this point, the grid will evaluate expressions and show their results. But it does not track dependencies, so if you type a new value into cell “A1” for example, any formulas that use the value in “A1” will not be updated.

To address this, the DataGridCalc class overrides the OnCellEditEnded method to invalidate the control. This causes all visible cells to be repainted and automatically recalculated after any edits.

// invalidate cells with formulas after editing
protected override void OnCellEndEdit(DataGridViewCellEventArgs e)
{
    this.Invalidate();
    base.OnCellEndEdit(e);
}

// invalidate cells with formulas after editing

protected override void OnCellEndEdit(DataGridViewCellEventArgs e)

{

this.Invalidate();

base.OnCellEndEdit(e);

}

Let’s not forget that implementation of the Evaluate method used by the CellRangeReference class listed earlier. The method starts by retrieving the cell content. If the content is a string that starts with an equals sign, the method evaluates it and returns the result; otherwise it returns the content itself:

// gets the value in a cell
public object Evaluate(int rowIndex, int colIndex)
{
    // get the value
    var val = this.Rows[rowIndex].Cells[colIndex].Value;
    var text = val as string;
    return !string.IsNullOrEmpty(text) &amp;&amp; text[0] == '='
        ? _ce.Evaluate(text)
        : val;
}

// gets the value in a cell

public object Evaluate(int rowIndex, int colIndex)

{

// get the value

var val = this.Rows[rowIndex].Cells[colIndex].Value;

var text = val as string;

return !string.IsNullOrEmpty(text) && text[0] == '='

? _ce.Evaluate(text)

: val;

}

That is all there is to the DataGridCalc class. Notice that calculated values are never stored anywhere . All formulas are parsed and evaluated on demand.

The sample application creates a DataTable with 50 columns and 50 rows, and binds that table to the grid. The table stores the values and formulas typed by users.

The sample also implements an Excel-style formula bar across the top of the form that shows the current cell address, content, and has a context menu that shows the functions available and their parameters.

Finally, the sample has a status bar along the bottom that shows summary statistics for the current selection (Sum, Count, and Average, as in Excel 2010). The summary statistics are calculated using the grid’s CalcEngine as well.

Testing

I built some testing methods right into the CalcEngine class. In debug builds, these are called by the class constructor:

public CalcEngine()
{
    _tkTbl = GetSymbolTable();
    _fnTbl = GetFunctionTable();
    _cache = new ExpressionCache(this);
    _optimize = true;
#if DEBUG
    this.Test();
#endif
}

public CalcEngine()

{

_tkTbl = GetSymbolTable();

_fnTbl = GetFunctionTable();

_cache = new ExpressionCache(this);

_optimize = true;

#if DEBUG

this.Test();

#endif

}

This ensures that tests are performed whenever the class is used (in debug mode), and that derived classes do not break any core functionality when they override the base class methods.

The Test method is implemented in a Tester.cs file that extends the CalcEngine using partial classes. All test methods are enclosed in an #if DEBUG/#endif block, so they are not included in release builds.

This mechanism worked well during development. It helped detect many subtle bugs that might have gone unnoticed if I had forgotten to run my unit tests when working on separate projects.

Benchmarks

While implementing the CalcEngine class, I used benchmarks to compare its size and performance with alternate libraries and make sure CalcEngine was doing a good job. A lot of the optimizations that went into the CalcEngine class came from these benchmarks.

I compared CalcEngine with two other similar libraries which seem to be among the best available. Both of these started as CodeProject articles and later moved to CodePlex:

NCalc: This is a really nice library, small, efficient, and feature-rich. I could not use NCalc in my Silverlight project because it relies on the ANTLR runtime DLL, which cannot be used in Silverlight projects (at least I couldn’t figure out how to do it).
Flee: Unlike CalcEngine and NCalc, Flee keeps track of formulas, their values, and dependencies. When a formula changes, Flee re-evaluates all cells that depend on it. One of the interesting features of Flee is that it actually compiles formulas into IL. This represents a trade-off since compilation is quite slow, but evaluation is extremely fast. I decided not to use Flee in my Silverlight project because it is relatively large and the parsing times were too long for the type of application I had in mind.

The benchmarking method was similar to the one described by Gary Beene in his 2007 Equation Parsers article. Each engine was tested for parsing and evaluating performance using three expressions. The total time spent was used to calculate a “Meps” (million expressions parsed or evaluated per second) index that represents the engine speed.

The expressions used were the following:

4 * (4 * Atan(1 / 5.0) - Atan(1 / 239.0)) + a + b
Abs(Sin(Sqrt(a*a + b*b))*255)
Abs(Sin(Sqrt(a^2 + b^2))*255)

4 * (4 * Atan(1 / 5.0) - Atan(1 / 239.0)) + a + b

Abs(Sin(Sqrt(a*a + b*b))*255)

Abs(Sin(Sqrt(a^2 + b^2))*255)

Where “a” and “b” are variables set to 2 and 4.

Each engine parsed and evaluated the expressions 500,000 times. The times were added and used to calculate the “Meps” index by dividing the number of repetitions by the time consumed. The results were as follows:

	Time in seconds		Speeds in “Meps”
Library	Parse	Evaluate	Parse	Evaluate
CalcEngine	1.4	1.3	1.04	1.18
NCalc	7.1	5.7	0.21	0.26
Flee	1,283.0	0.5	0.00	2.91
CalcEngine*	10.7	1.5	0.14	0.99
NCalc*	145.2	5.7	0.01	0.27

Some comments about the benchmark results:

CalcEngine performed well, being the fastest parser and the second fastest evaluator (after Flee).
Flee is literally “off the charts” on both counts, almost 900 times slower parsing and 2.5 times faster evaluating than CalcEngine. Because Flee compiles formulas to IL, I expected slow parsing and fast evaluation, but the magnitude of the difference was surprising.
Entries marked with asterisks were performed with optimizations off. They are included to demonstrate the impact of the optimization options.

In addition to speed, size is important, especially for Silverlight applications that need to be downloaded to the client machine. Here is a comparison of library sizes:

Library	Size (kB)
CalcEngine	26
NCalc	188
Flee	202

CalcEngine is the smallest library by far, more than seven times smaller than NCalc. If necessary, it could be trimmed even further by removing some of the less important built-in functions.

Conclusion

The CalcEngine class is compact, fast, extensible, and multi-platform. I think it is different enough from NCalc and Flee to add value for many types of projects, especially Silverlight applications like the one it was created for. You can see the Silverlight app in action in the image below.

I hope others will find CalcEngine useful and interesting as well.

Cheap ASP.NET Security With SQL Server 2005

CheapASPNETHostingRerview.com | Cheap and Reliable ASP.NET hosting. This article focuses on security concerm when using SQL Server 2005 in ASP.NET application..

Today I was trying to access the web page from and getting following error
Error Message:Login failed for user . The user is not associated with a trusted SQL Server connection.Web server and database are on different server and I am using Virtual machines (VMWare) for my development and DB server.There can be problem in SQL server or IIS or application, so lets start with SQL Server.SQL Server Settings: The security should be set for SQL Server and Windows Authentication.

The SQL server has the logins for authenticated users and has proper permissions as I also use development machine to maintain DB.

IIS: Open IIS and select properties and under directory security tab click edit button.

Uncheck Anonymous access and check integrated windows security; integrated windows security will enable users login to be used for authentication instead of IIS default user.

Now, lets put application web.config under microscope.
I have custom error tag to redirect error to default page

<customErrors mode="On" defaultRedirect="showError.aspx">
</customErrors>

1 2	<customErrors mode="On" defaultRedirect="showError.aspx"> </customErrors>

This is good and for testing I set the Mode tag to off
Connection string uses integrated security tag and set it to true.

"server=servername;database=TestDB;Integrated Security=true" />

1	"server=servername;database=TestDB;Integrated Security=true" />

Here is another tag identity. Ah! Impersonate is false and I want it false so I can have connection pooling.

<identity impersonate="false"/>

1	<identity impersonate="false"/>

So where is the problem, all the setting seems right, why the heck it does not work.
I changes the identity impersonate tag to true and Voila! It works.J
For the time being I can work but it’s not a solution. L Adding a login to SQL Server for IIS user of web server is also not going to work.