Decoding Asp.net , Asp.net MVC, SQL Server ,Firebird,Jquery,JavaScript

Using C# 4.0 and dynamic to parse JSON

2016-01-09T12:26:00.000-08:00

UPDATE: take a look at http://json.codeplex.com/ before you try and roll your own, it supports dynamic now...

I recently had to get a JSON feed from the web and traverse it. Like any good developer I started off with a Bing search and stumbled across a few posts.

The first by Nikhil Kothari looked interesting but his implementation did way too much, all I needed to do was read a JSON file, did I really need all that code.

http://www.nikhilk.net/CSharp-Dynamic-Programming-JSON.aspx

The second post I saw by Alex Ghiondea again looked interesting but relied on a library from codeplex (JSON.NET, http://json.codeplex.com/) and again I thought this was a bit overkill for my project.

http://blogs.msdn.com/b/alexghi/archive/2008/12/22/using-anonymous-types-to-deserialize-json-data.aspx

But Nikhil’s post did get me thinking that this might be a good place to use the new dynamic “type” in C# 4.0. With some further research I dug up that in .NET 3.5 we got a new class called the JavaScriptSerializer, MSDN describes it as:

The JavaScriptSerializer class is used internally by the asynchronous communication layer to serialize and deserialize the data that is passed between the browser and the Web server. You cannot access that instance of the serializer. However, this class exposes a public API. Therefore, you can use the class when you want to work with JavaScript Object Notation (JSON) in managed code.

http://msdn.microsoft.com/en-us/library/system.web.script.serialization.javascriptserializer(v=VS.100).aspx

To use the JavaScriptSerializer (from the System.Web.Extensions dll) you have to implement a JavaScriptConverter. I can do that. :) After poking around a bit with the JavaScriptSerializer I realized that it gives you a few things. A value, an array list of values, a dictionary of key value pairs, or an ArrayList containing an array of dictionary of key value pairs. What I want to do is if I see a dictionary I want my user to be able to use the key as a property on my dynamic, if I see an ArrayList I want the user to be able to iterate over the collection and see its members, finally if I see a value I want to just return it.

Lets start with a simple JSON file, that I borrowed from json.org:

{
    "glossary": {
        "title": "example glossary",
        "GlossDiv": {
            "title": "S",
            "GlossList": {
                "GlossEntry": {
                    "ID": "SGML",
                    "SortAs": "SGML",
                    "GlossTerm": "Standard Generalized Markup Language",
                    "Acronym": "SGML",
                    "Abbrev": "ISO 8879:1986",
                    "GlossDef": {
                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
                        "GlossSeeAlso": ["GML", "XML"]
                    },
                    "GlossSee": "markup"
                }
            }
        }
    }
}

http://www.json.org/example.html

So with this the above JSON I want to be able to write “glossaryEntry.glossary.title” or “glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.ID” and get back “example glossary” and “SGML” respectively. All without having to actually create a static “glossary” object.

So the first step is to create our DynamicObject. I called mine DynamicJsonObject and as you can see it inherits from the base DynamicObject class.

public class DynamicJsonObject : DynamicObject
{
    private IDictionary<string, object> Dictionary { get; set; }
 
    public DynamicJsonObject(IDictionary<string, object> dictionary)
    {
        this.Dictionary = dictionary;
    }
 
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        result = this.Dictionary[binder.Name];
 
        if (result is IDictionary<string, object>)
        {
            result = new DynamicJsonObject(result as IDictionary<string, object>);
        }
        else if (result is ArrayList && (result as ArrayList) is IDictionary<string, object>)
        {
            result = new List<DynamicJsonObject>((result as ArrayList).ToArray().Select(x => new DynamicJsonObject(x as IDictionary<string, object>)));
        }
        else if (result is ArrayList)
        {
            result = new List<object>((result as ArrayList).ToArray());
        }
 
        return this.Dictionary.ContainsKey(binder.Name);
    }
}

The tricky bit is in the “TryGetMember” Method. The binder.Name is the property value you used in your code. As you can see I am looking that guy up in the current internal dictionary. I then test its type. If it is a dictionary, I wrap it in another DynamicJsonObject and give it back. If it is an ArrayList of Dictionaries then I wrap each item as an DynamicJsonObject and send back the List. If it is just an Array List I convert it to a List and send it back. Finally we have to tell .NET if we found it at all.

The only other thing we need is an implementation of the JavaScriptConverter.

    public class DynamicJsonConverter : JavaScriptConverter
    {
        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");
 
            if (type == typeof(object))
            {
                return new DynamicJsonObject(dictionary);
            }
 
            return null;
        }
 
        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            throw new NotImplementedException();
        }
 
        public override IEnumerable<Type> SupportedTypes
        {
            get { return new ReadOnlyCollection<Type>(new List<Type>(new Type[] { typeof(object) })); }
        }
    }

As you can see by the above code we are only supporting the deserialize method, and the only thing we do is wrap the dictionary with our DynamicJsonObject. Finally since we are using dynamic we can support any object type with this converter.

Now for the fun bit, lets use it.

            JavaScriptSerializer jss = new JavaScriptSerializer();
            jss.RegisterConverters(new JavaScriptConverter[] { new DynamicJsonConverter() });
 
            dynamic glossaryEntry = jss.Deserialize(json, typeof(object)) as dynamic;
 
            Console.WriteLine("glossaryEntry.glossary.title: " + glossaryEntry.glossary.title);
            Console.WriteLine("glossaryEntry.glossary.GlossDiv.title: " + glossaryEntry.glossary.GlossDiv.title);
            Console.WriteLine("glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.ID: " + glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.ID);
            Console.WriteLine("glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.para: " + glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.para);
            foreach (var also in glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso)
            {
                Console.WriteLine("glossaryEntry.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso: " + also);
            }

To use our converter we create a serializer, register our converter with it and then call the deserialize method. Now we can use our standard “dot” notation to traverse our JSON object without the need for external libraries and in under 100 lines of code. Now JSON in .NET feels a lot like JSON in JavaScript. . . When I heard that C# was getting this dynamic stuff I was unsure of its power and relevance, now I have “seen the light” and can really see where this was a great addition to the language.

String to Json

2016-01-09T12:25:00.002-08:00

var input = ["Fred-Jim-Bob", "Fred-Jim", "Fred-Thomas-Rob", "Fred"];
var output = [];
for (var i = 0; i < input.length; i++) {
    var chain = input[i].split("-");
    var currentNode = output;
    for (var j = 0; j < chain.length; j++) {
        var wantedNode = chain[j];
        var lastNode = currentNode;
        for (var k = 0; k < currentNode.length; k++) {
            if (currentNode[k].name == wantedNode) {
                currentNode = currentNode[k].children;
                break;
            }
        }
        // If we couldn't find an item in this list of children
        // that has the right name, create one:
        if (lastNode == currentNode) {
            var newNode = currentNode[k] = {name: wantedNode, children: []};
            currentNode = newNode.children;
        }
    }
}

output[{

    "name": "Fred",
    "children": [{
        "name": "Jim",
        "children": [{
            "name": "Bob",
            "children": []
        }]
    }, {
        "name": "Thomas",
        "children": [{
            "name": "Rob",
            "children": []
        }]
    }]
}]

Evaluating JavaScript code from C#

2016-01-09T12:25:00.001-08:00

As was going through my JSON Serialization code the other day I kept re-thinking this idea I had some time ago: Why not use Microsoft’s built in JavaScript engine to perform the JavaScript and JSON deserialization. After all there is an official Microsoft JavaScript .NET language and it should be possible to take advantage of this from within an application. I finally had some time to check this out...

I started searching for how to do this and there’s not a heck of a lot of information available on this so I started playing around with this on my own. The good news is that it’s pretty straight forward to evaluate JavaScript code, the bad news is that for what I really need it for it doesn’t work quite right.

In order to use JScript you need to add a reference to the the Microsoft.vsa assembly.

First here are a few eval scenarios and how you can call them from a bit of C# code in ASP.NET:

using Microsoft.JScript;

public partial class JavaScriptEval : System.Web.UI.Page

{

public static Microsoft.JScript.Vsa.VsaEngine Engine = Microsoft.JScript.Vsa.VsaEngine.CreateEngine();

public static object EvalJScript(string JScript)

{

object Result = null;

try

{

Result = Microsoft.JScript.Eval.JScriptEvaluate(JScript, Engine);

}

catch (Exception ex)

{

return ex.Message;

}

return Result;

}

public void Page_Load(object sender,EventArgs e)

{

// *** String Value

object Result = EvalJScript(@"('hello world: ' + new Date())");

Response.Write( Result.ToString() );

Response.Write(" Type: " + Result.GetType().Name);

Response.Write("<hr>");

// *** Return an integer or numeric - no conversion required

Result = EvalJScript(@"( 11 * 12)");

Response.Write(Result.ToString());

Response.Write(" Type: " + Result.GetType().Name);

Response.Write("<hr>");

// *** Date value - must be converted!

Result = EvalJScript(@"(new Date())");

Response.Write(Result);

Response.Write(" - Type: " + Result.GetType().Name + "<br>");

// *** Must convert from DateObject to DateTime by coercing

DateObject dateObject = Result as DateObject;

Result = Microsoft.JScript.Convert.Coerce(Result,typeof(DateTime));

Response.Write("Converted to DateTime: " + Result);

Response.Write("<hr>");

// *** Block of code (last assignment is the return value)

Result = EvalJScript(@"var out = 'hello'; for ( var x = 1; x < 10; x++) { out = out + 'Line ' + x + '<br>'; }");

Response.Write(Result);

Response.Write(" - Type: " + Result.GetType().Name);

Response.Write("<hr>");

/// *** Closure - calling a JavaScript Function with return value

Result = EvalJScript(@"( function Test(inputParm) { return 'hello world ' + inputParm; } )");

/// *** Invoke the function and retrieve the result

Closure close = Result as Closure;

// *** This requires full trust

Result = close.Invoke(close, new object[1] { "Start with this bub..." });

Response.Write(Result);

Response.Write(" - Type: " + Result.GetType().Name);

Response.Write("<hr>");

// *** JSON style object

Result = EvalJScript(@"( {""timeString"":'Time is: ' + new Date(),""dateValue"":new Date()} )");

JSObject obj = Result as JSObject;

Response.Write(Result);

// *** JavaScript style property array access can be used

object val = obj["dateValue"];

Response.Write(Microsoft.JScript.Convert.Coerce(val,typeof(DateTime)));

val = obj["timeString"];

Response.Write(val);

}

As you can see execution of simple bits of code is pretty straight forward. If you need to evaluate an expression that returns a simple type like string, bool or numeric you can simply eval the expression and you get the right value and type back.

If you eval something that results in a date however things get more tricky already. You basically need to coerce the JavaScript date into a .NET date. It’s fairly easy to do this luckily – and it might be a decent solution to the lousy kind of code you have to write to deal with all the different date formats available in JSON (new Date() syntax allows for string values, numeric values all in various format). This is somewhat useful.

More interesting is the ability to execute a whole block of code. There are a few ways to do this. You can simply pass the code directly and execute it which works just fine. The problem with this is that you can’t directly return a value. Instead the last assignment ends up as your return value. This is similar to the behavior you see in event handlers like onclick in Web pages where you sometimes get unexpected results if you don’t explicitly return a value. This is probably the best choice even though it’s a bit unconventional.

Result = EvalJScript(@"( function Test(inputParm) { return 'hello world ' + inputParm; } )");

What happens here is that rather than returning you an evaluated result the parser returns you the closure – ie. essentially a function pointer. You can now use Reflection to execute the Result which is a little more involved:

Closure close = Result as Closure;

Result = close.Invoke(close, new object[1] { "Start with this bub..." });

This works fine, but it requires full Reflection rights in order to be able to access this anonymous function. The closure is treated like a private/internal/protected member by Reflection and so you need Full trust in ASP.NET to execute this code. Bummer – this would be the most natural way to execute code because you’d have the ability to pass in parameter and get a return value using standard .NET Reflection logic. But given the rights issues this is probably not an option. I can’t figure out any other way to pass a parameter into the parser.

Next, there’s the actual issue I was after: Being able to pass an arbitrary object (in JSON style format) in and get this object back in some way to that can be parsed in .NET.

Result = EvalJScript(@"( {""timeString"":'Time is: ' + new Date(),""dateValue"":new Date()} )");

This returns a JavaScript object which can then be parsed with typical JavaScript member arrays syntax:

Result = EvalJScript(@"( {""timeString"":'Time is: ' + new Date(),""dateValue"":new Date()} )");

JSObject obj = Result as JSObject;

foreach ( string FieldName in obj)

{

object FieldVal = obj[FieldName];

Response.Write( FieldVal.ToString() + " - " + FieldVal.GetType().ToString() + "<br>");

}

This works and you can potentially parse out the different types , but that still leaves the issue of how to get an actual object from the JavaScript object or more specifically how to ‘cast’ this object to another object.

I’m just thinking out loud here <s>:

Say you have a JSON method you call and you have a method which takes an object as a strongly typed object parameter:

Public bool SaveCustomer(CustomerEntity Customer)

…

I suppose one could use the Customer object as the ‘schema’ and walk through that object with Reflection and then pull values from the JavaScript with the code above and then assign them.

I took a closer look at what MS Ajax is doing – and well they’re manually parsing the javascript which is fine, but MS AJAX doesn’t work with a lot of types and doesn’t work of generic type value returned at all – any object structure must exist on the client before it can be passed back (that’s what that long Proxy block for a class definition does basically – it creates type definitions for any parameters and return values).

I have my own JSON parsing code and it works reasonably well against a wide variety of types generically using a mechanism similar to the above but by parsing string values. But the code is pretty messy and it can easily be broken by some funky JSON formatting. It would be much nicer to leave this sort of thing to a JavaScript parser.

OTOH, manually parsing is probably a safer solution. Using the JSCript parser as shown above actually executes code on the server. If you take a JSON input and do that there’s a lot of potential for security issues.

Actually it’s surprising that the Jscript Eval works at all under a limited trust environment.

Anyway it’s an interesting experiment but for my needs probably a dead end. But these samples might help someone trying to add JavaScript support to a .NET app out or at least get them started.....

Rick,
I used a similar technique in ASP.Net 1.1. When I converted to 2.0 I noticed the VSA library was marked obsolete. So I searched for a way to eval basic javascript expressions. (I was looking for something that would simply return True or False base on whatever I passed in to it.)

We had a problem with the 'Microsoft.JScript.Vsa.VsaEngine' code in ValruleFilters because Microsoft deprecated it and made it obsolete.

They recommended you use the ICodeDomCompiler interface to build code on the fly instead.
I took a look at it and it is very complex.

I came up with a much simpler solution instead.

I built a .dll file using javascript and then compiled it using the javascript compiler which is available in a VS2005 command prompt.

Once we have the .dll we simply add it to the \Support folder and then referenced it in the project which needed to eval javascript stateemnts.

We call it like this:

Dim jScriptEvaluator As New EvalClass
Dim objResult As Object
objResult = jScriptEvaluator.Evaluate(“1==1 && 2==2”)

This is *much* simpler and safer than ICodeDom.
======================================================================
Warning

'Microsoft.JScript.Vsa.VsaEngine' is obsolete:
'Use of this type is not recommended because it is being deprecated in Visual Studio 2005;
there will be no replacement for this feature. Please see the ICodeCompiler documentation for additional help.'

======================================================================

Detailed Steps to create a .dll:

1. Create a file in Notepad with only these contents:

class EvalClass { function Evaluate(expression: String) { return eval(expression); } }

2. Save the file as C:\MyEval.js

3. Open a VS2005 Command Prompt (Start, Programs, VS2005, VS2005 Tools)

4. Type Cd\ to get to C:\

5. Type
jsc /t:library C:\MyEval.js

6. A new file is created named MyEval.dll.

7. Copy MyEval.dll to the project and reference it (also reference Microsoft.Jscript.dll).

8. Then you should be able to call it like this:

Dim jScriptEvaluator As New EvalClass
Dim objResult As Object
objResult = jScriptEvaluator.Evaluate(“1==1 && 2==2”)

objResult is True.

Parent Child in MVC

2016-01-09T12:25:00.000-08:00

Given your structure of Albums and Tracks, it would probably be preferable to have a direct 1 to many relationship between Albums and Tracks so that 1 album can have many tracks. Regardless of how many albums a track may appear on, your models could look like:

public class Albums {
public int ID { get; set; }
public string Artist { get; set; }
public string AlbumTitle { get; set; }
public string Notes { get; set; }
public IQueryable<Track> Tracks { get; set; }
}

public class Track {
public int ID { get; set; }
public int AlbumID { get; set; } // This may be unnecessary
public string TrackTitle { get; set; }
public string Notes { get; set; }
}
This would allow your data layer to populate all of the tracks that belong to a specific Album, but if you don't need to know the tracks it can just remain null. But your data layer just needs to fetch the album and then populate the Tracks property with an IQueryable object.

public ViewResult AlbumExt(int id)
{
Album album = albumRepository.All.Where(a => a.ID == id);
album.Tracks = tracksRepository.All.Where(t => t.AlbumId == id);
return View(album);
}
This would give you a single model, but all of the related tracks would still be accessible through the Model.Tracks property in the view:

@model MyNameSpace.Album

@{
foreach (var track in Model.Tracks)
{
<text>
<h1>@track.TrackTitle</h1><br />
</text>
}
}

Example 2

MVC: Multiple Models in One Single View
Here the question is say you have two model M1 and M2. M1 model consistd properties like a,b. M2 Consists properties like c,d. All a,b,c, d are required(Tagged as [Required]). Now you have a single View V. You have to display all a,b,c,d four properties into V view.

The simplest solution is first create M1 and M2 model class with a,b[in M1] and c,d[in M2] property . Now in M1 Model have a list property of M2 class

public List<M2> M2Prop { get; set; }

Access M1 Class in V view. You are done. Have a look on the below sample code.

public class Student
{
[Required]
public int RollNo { get; set; }

[Required]
public string Name { get; set; }

[Required]
public string Class { get; set; }

public string Address { get; set; }

public List<StudentScore> StudentScore { get; set; }

}

And the ‘StudentScore’ class is as follows.

public class StudentScore
{
[Required]
public int StudentRollNo { get; set; }

[Required]
public string StudentName { get; set; }

[Required]
public string Subject { get; set; }

[Required]
public int Marks { get; set; }

[Required]
public string Grade { get; set; }

}

Create View with strongly typed of Student Class.
And on the view it is like below.

@model IEnumerable<MultipleModelInOneView.Models.Student>

@foreach (var item in Model)
{

<td>
@item.RollNo
</td>
<td>
@item.Name
</td>

@foreach (var score in item.StudentScore)
{
<td>
@score.Grade

</td>
<td>
@score.Marks
</td>

}

}

html elements find all css

2016-01-09T12:24:00.001-08:00

<input type="submit" name="ctl00$MainContent$btnSearch" value="Search Now" onclick="return validateAge();" id="MainContent_btnSearch" class="btn btn-secondary btn-block">

Find the html element all css in a page.

simply register the function

var getCss = function(el) {

var style = window.getComputedStyle(el);

return Object.keys(style).reduce(function(acc, k) {

var name = style[k],

value = style.getPropertyValue(name);

if (value !== null) {

acc[name] = value;

}

return acc;

}, {});

};

and call the css function

(MainContent_btnSearch).getCss();

Database to Object

2013-06-20T04:59:00.003-07:00

You have a lot of questions in one question.

Linq2SQL is just an ORM kind of, if you are going that route I'd look at the entity framework (microsoft's orm).

Let's talk about layered applications a bit to help you understand how to populate objects. Your typical database app is composed of 3 layers (some say 4 and refer to the database itself as a layer, it really doesn't matter). You have the following:

-UI

-BLL

-DAL

So your communication is the UI talks to the BLL and the BLL talks to the DAL. The DAL returns some data to the BLL which in turn present it back to the UI. I don't know who told you datasets / tables are bad...sure a reader is faster but it doesn't mean using a datatable is bad.

Let me give you an example. Stop thinking of your DAL as one simple class. Start thinking of the DAL layer as an entire folder of different classes. One of those classes is a static DB class. It's static because you are dealing with one database (in most cases), so no need to instantiate the class. So it may look like this:

public static class DB {
private static readonly string connectionString = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
private static readonly DbProviderFactory factory = DbProviderFactories.GetFactory(dataProvider);

public static int Update(string sql)
{
using (DbConnection connection = factory.CreateConnection())
{
connection.ConnectionString = connectionString;

using (DbCommand command = factory.CreateCommand())
{
command.Connection = connection;
command.CommandText = sql;

connection.Open();
return command.ExecuteNonQuery();
}
}
}

public static DataTable GetDataTable(string sql)
{
using (DbConnection connection = factory.CreateConnection())
{
connection.ConnectionString = connectionString;

using (DbCommand command = factory.CreateCommand())
{
command.Connection = connection;
command.CommandType = CommandType.Text;
command.CommandText = sql;

using (DbDataAdapter adapter = factory.CreateDataAdapter())
{
adapter.SelectCommand = command;

DataTable dt = new DataTable();
adapter.Fill(dt);

return dt;
}
}
}
}

Some of this was taken from the dofactory website. Great resource to learn how to use design patterns. Anyhow that is just one .class file. Now you need another one for say a CustomerDAO (a customer data access object).

Ok so how can you use that DB class you created (well I would use a combination of sprocs but to make this a simple post lets avoid stored procedures for now). If I need to Get Customers I could define this:

public IList<Customer> GetCustomers()
{
StringBuilder sql = new StringBuilder();
sql.Append(" SELECT CustomerId, CompanyName, City, Country ");
sql.Append(" FROM Customer ");

DataTable dt = Db.GetDataTable(sql.ToString());

return MakeCustomers(dt);
}

Remember this is in an entirely different .class file. Ok so how does make customers look:

private IList<Customer> MakeCustomers(DataTable dt)
{
IList<Customer> list = new List<Customer>();
foreach (DataRow row in dt.Rows)
list.Add(MakeCustomer(row));

return list;
}

So what I am doing here is I had a datatable full of customers. I need to loop through each row of the datatable and Make the customer:

private Customer MakeCustomer(DataRow row)
{
int customerId = int.Parse(row["CustomerId"].ToString());
string company = row["CompanyName"].ToString();
string city = row["City"].ToString();
string country = row["Country"].ToString();

return new Customer(customerId, company, city, country);
}

So this customer is new'd and stored in a customer list.

This is just a small example of what your Data Access Layer does. The database class simply stores the connection string and functions to get a data set or get a data table or even in your case get a data reader (which you could do too). The CustomerDAO class is simply a class that deals with customer objects and may implement say an ICustomer interface.

So where is the Customer class itself? It can be in another folder as the business layer, because it simply is a business object. Here you can set validations, and required fields inside of the customer class.

Your UI doesnt have anything related to datareaders, datasets, or SQL at all. Your Business layer has nothing to do with it either (it defines some rules behind your business objects). Your dal can be very flexible (can work with SQL, Oracle, etc) or can be limited to say SQL Server if that is what you plan on doing. Do not overkill your app. If you are a MS guy and are certain to only use SQL Server don't make your job difficult by trying to roll out the ultimate DAL that works with any vendor. it is ok to use SQLCommand, SQLConnection, etc.

2013-06-03T01:48:00.000-07:00

Skip to main content
Sign in (or register) English IBM

Technical topics
Evaluation software
Community
Events
Search developerWorks

developerWorks
Web development
Technical library
JavaScript EE, Part 1: Run JavaScript files on the server side

Learn how to use the javax.script API in Ajax and Java EE applications

Andrei Cioroianu, Senior Java Developer and Consultant, Devsphere
Summary: Combine JavaScript with Java™ code on the server to get the freedom to use the same JavaScript routines on both servers and clients. In addition, the techniques presented throughout this series will allow you to maintain a single code base for both Ajax and non-Ajax clients. Because much of the server-side code would still be written in the Java language, you'll find it necessary to expose the Java Platform, Enterprise Edition (Java EE) features to JavaScript. In this series, learn how to run JavaScript files on the server side, call remote JavaScript functions with Ajax, and use the Java Scripting API with the JavaServer Pages (JSP) technology.

View more content in this series

Date: 16 Dec 2008
Level: Intermediate
PDF: A4 and Letter (56KB | 19 pages)Get Adobe® Reader®
Also available in: Chinese Russian Japanese

Activity: 45190 views
Comments: 1 (View | Add comment - Sign in)

Average rating (22 votes)
Rate this article
Typical Ajax applications use JavaScript on the client side and a different language, such as Java, on the server side. As a result, developers must implement some of their routines twice, using JavaScript for the Web browser and another language for the server. This double-coding issue can be avoided by using JavaScript combined with Java code on the server side, getting full support of scripting languages through the javax.script API. In addition, the Java SE Development Kit (JDK) 6 already includes Mozilla's Rhino JavaScript engine, which means no setup is required.

In this first article of the series, you will use a simple script runner that lets you execute JavaScript files within a Java EE application. Scripts will have access to the so-called "implicit objects" that are used in JSP pages, such as application, session, request, and response. Most of the samples consist of reusable code so that you can easily start using JavaScript on the server in your own applications.

Using the javax.script API

This section provides an overview of the javax.script API. You will learn how to execute scripts that access Java objects, invoke JavaScript functions from your Java code, and implement a caching mechanism for the compiled scripts.

Executing scripts

The javax.script API is very simple. You start by creating a ScriptEngineManager instance, which lets you obtain a ScriptEngine object (see Listing 1), using one of the following methods:

getEngineByName()
getEngineByExtension()
getEngineByMimeType()

Listing 1. Getting a ScriptEngine instance
import javax.script.*;
...
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
...
engine.eval(...);

You can also obtain the list of available script engines with getEngineFactories(). Currently, only the JavaScript engine is bundled with JDK 6, but ScriptEngineManager implements a discovery mechanism for third-party engines that support JSR-223 Scripting for the Java Platform (see Resources). You just have to place the JAR files of the script engines in your CLASSPATH.

After you get the javax.script.ScriptEngine instance, you can call eval() to execute scripts. You can also export Java objects as script variables, passing a Bindings instance to the eval() method. Listing 2 contains the ScriptDemo.java example, which exports two variables named demoVar and strBuf, executes a script named DemoScript.js, and then gets the variables to output their modified values.

Listing 2. The ScriptDemo.java example
package jsee.demo;

import javax.script.*;
import java.io.*;

public class ScriptDemo {

public static void main(String args[]) throws Exception {
// Get the JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");

// Set JavaScript variables
Bindings vars = new SimpleBindings();
vars.put("demoVar", "value set in ScriptDemo.java");
vars.put("strBuf", new StringBuffer("string buffer"));

// Run DemoScript.js
Reader scriptReader = new InputStreamReader(
ScriptDemo.class.getResourceAsStream("DemoScript.js"));
try {
engine.eval(scriptReader, vars);
} finally {
scriptReader.close();
}

// Get JavaScript variables
Object demoVar = vars.get("demoVar");
System.out.println("[Java] demoVar: " + demoVar);
System.out.println(" Java object: " + demoVar.getClass().getName());
System.out.println();
Object strBuf = vars.get("strBuf");
System.out.println("[Java] strBuf: " + strBuf);
System.out.println(" Java object: " + strBuf.getClass().getName());
System.out.println();
Object newVar = vars.get("newVar");
System.out.println("[Java] newVar: " + newVar);
System.out.println(" Java object: " + newVar.getClass().getName());
System.out.println();
}

}

The DemoScript.js file (shown in Listing 3) contains a function named printType(), which is used to output the type of each script variable. The example calls the append() method of the strBuf object, modifies the value of demoVar, and sets a new script variable named newVar.

If the object passed to printType() has a getClass() method, it must be a Java object whose class name is obtained with obj.getClass().name. This JavaScript expression calls the getName() method of the object's java.lang.Class instance. If the object doesn't have a getClass member, printType() calls the toSource() method, which all JavaScript objects must have.

Listing 3. The DemoScript.js example
println("Start script \r\n");

// Output the type of an object
function printType(obj) {
if (obj.getClass)
println(" Java object: " + obj.getClass().name);
else
println(" JS object: " + obj.toSource());
println("");
}

// Print variable
println("[JS] demoVar: " + demoVar);
printType(demoVar);

// Call method of Java object
strBuf.append(" used in DemoScript.js");
println("[JS] strBuf: " + strBuf);
printType(strBuf);

// Modify variable
demoVar = "value set in DemoScript.js";
println("[JS] demoVar: " + demoVar);
printType(demoVar);

// Set a new variable
var newVar = { x: 1, y: { u: 2, v: 3 } }
println("[JS] newVar: " + newVar);
printType(newVar);

println("End script \r\n");

Listing 4 contains the output of the ScriptDemo.java example. The first thing you'll notice is that demoVar is exported as a JavaScript String while the type of strBuf remains java.lang.StringBuffer. Primitive variables and Java strings are exported as native JavaScript objects. Any other Java objects (including arrays) are exported unaltered.

Listing 4. The output of ScriptDemo.java
Start script

[JS] demoVar: value set in ScriptDemo.java
JS object: (new String("value set in ScriptDemo.java"))

[JS] strBuf: string buffer used in DemoScript.js
Java object: java.lang.StringBuffer

[JS] demoVar: value set in DemoScript.js
JS object: (new String("value set in DemoScript.js"))

[JS] newVar: [object Object]
JS object: ({x:1, y:{u:2, v:3}})

End script

[Java] demoVar: value set in DemoScript.js
Java object: java.lang.String

[Java] strBuf: string buffer used in DemoScript.js
Java object: java.lang.StringBuffer

[Java] newVar: [object Object]
Java object: sun.org.mozilla.javascript.internal.NativeObject

After running the script, the engine takes all variables (including new ones) and performs the inverse conversion, turning JavaScript primitives and strings into Java objects. Other JavaScript objects are wrapped into Java objects, which use some engine-specific internal API, such as sun.org.mozilla.javascript.internal.NativeObject.

Because you probably want to use only standard APIs, all data exchange between the Java code and the executed script should be done through primitive variables, strings, and Java objects (for example, beans) whose properties and methods can be accessed very easily in the JavaScript code. Simply said, don't try to access native JavaScript objects in your Java code. Use Java objects in the JavaScript code instead.

Invoking functions

In the previous example, you've seen that it is possible to call Java methods from JavaScript. Now you'll learn how to invoke JavaScript functions from your Java code. First of all, you must execute the script containing the function that you want to call. Then, you'll cast the ScriptEngine instance to javax.script.Invocable, which provides invokeFunction() and invokeMethod(). If your script implements all the methods of a Java interface, you can also use getInterface() to obtain a Java object whose methods are coded in the scripting language.

The InvDemo.java example (shown in Listing 5) executes a script named InvScript.js, which contains the demoFunction() routine. After casting the ScriptEngine instance to Invocable, the Java example passes the function name and the parameters to the engine's invokeFunction() method, which returns the value returned by demoFunction().

Listing 5. The InvDemo.java example
package jsee.demo;

import javax.script.*;
import java.io.*;

public class InvDemo {

public static void main(String args[]) throws Exception {
// Get the JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");

// Run InvScript.js
Reader scriptReader = new InputStreamReader(
InvDemo.class.getResourceAsStream("InvScript.js"));
try {
engine.eval(scriptReader);
} finally {
scriptReader.close();
}

// Invoke a JavaScript function
if (engine instanceof Invocable) {
Invocable invEngine = (Invocable) engine;
Object result = invEngine.invokeFunction("demoFunction", 1, 2.3);
System.out.println("[Java] result: " + result);
System.out.println(" Java object: "
+ result.getClass().getName());
System.out.println();
} else
System.out.println("NOT Invocable");
}

}

The InvScript.js file (see Listing 6) contains the demoFunction() routine and the same printType() function that was used in the previous script example.

Listing 6. The InvScript.js example
println("Start script \r\n");

function printType(obj) {
if (obj.getClass)
println(" Java object: " + obj.getClass().name);
else
println(" JS object: " + obj.toSource());
println("");
}

function demoFunction(a, b) {
println("[JS] a: " + a);
printType(a);
println("[JS] b: " + b);
printType(b);
var c = a + b;
println("[JS] c: " + c);
printType(c);
return c;
}

println("End script \r\n");

If you look at the output of InvDemo.java (shown in Listing 7), you'll observe that the numeric parameters are converted to JavaScript objects and the value returned by demoFunction() is obtained as a Java object. These conversions are performed only for primitives and strings. Any other objects are passed unchanged between the JVM and the JavaScript engine, and vice-versa.

Listing 7. The output of InvDemo.java
Start script

End script

[JS] a: 1
JS object: (new Number(1))

[JS] b: 2.3
JS object: (new Number(2.3))

[JS] c: 3.3
JS object: (new Number(3.3))

[Java] result: 3.3
Java object: java.lang.Double

Note that javax.script.Invocable is an optional interface, which some script engines may not implement. The JavaScript engine that comes with JDK 6 does support this interface.

Compiling scripts

Interpreting scripts every time they are executed wastes CPU resources. If you run the same scripts multiple times, you can significantly reduce the execution time by compiling the scripts, using the methods provided by another optional interface named javax.script.Compilable, which is supported by the JavaScript engine of JDK 6.

The CachedScript class (see Listing 8) takes a script file and recompiles it only when the source code is modified. The getCompiledScript() method calls the script engine's compile(), which returns a javax.script.CompiledScript object whose eval() methods execute the script.

Listing 8. The CachedScript class
package jsee.cache;

import javax.script.*;
import java.io.*;
import java.util.*;

public class CachedScript {
private Compilable scriptEngine;
private File scriptFile;
private CompiledScript compiledScript;
private Date compiledDate;

public CachedScript(Compilable scriptEngine, File scriptFile) {
this.scriptEngine = scriptEngine;
this.scriptFile = scriptFile;
}

public CompiledScript getCompiledScript()
throws ScriptException, IOException {
Date scriptDate = new Date(scriptFile.lastModified());
if (compiledDate == null || scriptDate.after(compiledDate)) {
Reader reader = new FileReader(scriptFile);
try {
compiledScript = scriptEngine.compile(reader);
compiledDate = scriptDate;
} finally {
reader.close();
}
}
return compiledScript;
}

}

The ScriptCache class (shown in Listing 9) implements a repository for the compiled scripts, using a java.util.LinkedHashMap object. The map's initial capacity is set to a maximum number of cached scripts and the load factor is 1. These two parameters guarantee that cacheMap will never need a rehash.

By default, the LinkedHashMap class uses the insert-order for its entries. The third parameter of the LinkedHashMap() constructor must be true to use the access-order for the map's entries instead of the default order.

After the maximum capacity of the cache is reached, the removeEldestEntry() method starts returning true so that an entry is automatically removed from cacheMap each time a new compiled script is added to the cache.

By using the auto-removal mechanism of LinkedHashMap in combination with the access-order, ScriptCache ensures that the Least Recently Used (LRU) script will be removed from the full cache when a new script is added.

Listing 9. The ScriptCache class
package jsee.cache;

import javax.script.*;

import java.io.*;
import java.util.*;

public abstract class ScriptCache {
public static final String ENGINE_NAME = "JavaScript";
private Compilable scriptEngine;
private LinkedHashMap<String, CachedScript> cacheMap;

public ScriptCache(final int maxCachedScripts) {
ScriptEngineManager manager = new ScriptEngineManager();
scriptEngine = (Compilable) manager.getEngineByName(ENGINE_NAME);
cacheMap = new LinkedHashMap<String, CachedScript>(
maxCachedScripts, 1, true) {
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > maxCachedScripts;
}
};
}

public abstract File getScriptFile(String key);

public synchronized CompiledScript getScript(String key)
throws ScriptException, IOException {
CachedScript script = cacheMap.get(key);
if (script == null) {
script = new CachedScript(scriptEngine, getScriptFile(key));
cacheMap.put(key, script);
}
return script.getCompiledScript();
}

public ScriptEngine getEngine() {
return (ScriptEngine) scriptEngine;
}

}

The next section uses the ScriptCache class, implementing the abstract getScriptFile() method and using getScript() to retrieve compiled scripts from the cache.

Building a script runner

In this section, you'll learn how to create a simple Java servlet that implements a URL-script mapping, which allows you to invoke server-side scripts from the Web browser. In addition, the servlet will expose several Java EE objects as variables that can be used in your JavaScript code. You'll also learn how to use script contexts that let you run multiple concurrent scripts with a single JavaScript engine.

Initializing the servlet

The name of the servlet class is JSServlet. Its init() method (see Listing 10) gets several configuration parameters and creates a ScriptCache object. The servlet's script cache uses getRealPath() to obtain the path of the script file that is mapped to a given URI.

Listing 10. The init() method of JSServlet
package jsee.servlet;

import javax.script.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import jsee.cache.*;

public class JSServlet extends HttpServlet {
private String cacheControlHeader;
private String contentTypeHeader;
private ScriptCache scriptCache;

public void init() throws ServletException {
ServletConfig config = getServletConfig();
cacheControlHeader = config.getInitParameter("Cache-Control");
contentTypeHeader = config.getInitParameter("Content-Type");
int maxCachedScripts = Integer.parseInt(
config.getInitParameter("Max-Cached-Scripts"));
scriptCache = new ScriptCache(maxCachedScripts) {
public File getScriptFile(String uri) {
return new File(getServletContext().getRealPath(uri));
}
};
}
...
}

Listing 11 contains the servlet's parameters, which are specified in the web.xml file. The Cache-Control header has nothing to do with the script cache. Both headers will be part of the HTTP responses returned by the servlet. The no-cache value will tell the browser not to cache the servlet's response, which should be treated as text/plain.

Listing 11. The web.xml file
<web-app ...>

<servlet>
<servlet-name>JSServlet</servlet-name>
<servlet-class>jsee.servlet.JSServlet</servlet-class>
<init-param>
<param-name>Cache-Control</param-name>
<param-value>no-cache</param-value>
</init-param>
<init-param>
<param-name>Content-Type</param-name>
<param-value>text/plain</param-value>
</init-param>
<init-param>
<param-name>Max-Cached-Scripts</param-name>
<param-value>1000</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>JSServlet</servlet-name>
<url-pattern>*.jss</url-pattern>
</servlet-mapping>

</web-app>

As you can see in Listing 11, the *.jss pattern is mapped to the servlet. This means that JSServlet will handle all requests whose URLs end with the .jss extension. When the user enters such a URL in the Web browser or clicks a .jss link, the browser sends the HTTP request to the Web server (for example, Apache), which should be configured to dispatch it to the servlet container (for example, Tomcat). If the servlet container acts as Web server as well, no extra configuration is required.

When the servlet container gets the request whose URL ends with .jss, it invokes the service() method that JSServlet inherits from javax.servlet.http.HttpServlet. This method calls either doGet() or doPost(), depending on the HTTP method of the request. Both methods are overridden by JSServlet as you'll see later in this section.

Using script contexts

Threading models for script engines

JSR-223 Scripting for the Java Platform (see Resources) defines three types of script engines:

Multithreaded engines that are capable of executing concurrent scripts that may modify variables seen by other threads
Thread-isolated engines, which are multithreaded too, but each thread has its own engine scope for keeping variables
Stateless engines, which are defined as thread-isolated engines that let the engine scope unmodified after the execution of any script
The type of script engine can be obtained with engine.getFactory().getParameter("THREADING"), which may return "MULTITHREADED", "THREAD-ISOLATED", or "STATELESS"

Each script-engine instance has a default context where you can store variables with the put() method and the output of any executed script is directed to System.out by default. In a server environment, you'll want to run concurrent scripts with each of them having its own context. The javax.script API satisfies this need, providing the ScriptContext interface and the SimpleScriptContext implementation.

Mozilla's Rhino JavaScript engine is a multithreaded engine (see the sidebar), allowing you to execute concurrent scripts that share the same context. In our case, however, you want to isolate the engine scopes and the output of the scripts running in different threads, which means you must create a new ScriptContext instance for each HTTP request.

Listing 12 shows the createScriptContext() method of the JSServlet class. This method sets the context's writer property in order to send the script's output to the writer of the response object when the script is executed. This means that everything you pass to print() or println() in your script will be included in the servlet's response.

In addition, createScriptContext() defines the following script variables with the setAttribute() method of the script context:

Table 1. Variables available in scripts that are executed by JSServlet
Script variable Description
config the javax.servlet.ServletConfig instance of the servlet
application the javax.servlet.ServletContext instance of the Web app
session the javax.servlet.http.HttpSession object
request the javax.servlet.http.HttpServletRequest object
response the javax.servlet.http.HttpServletResponse object
out the java.io.PrintWriter object that is used to output the response
factory the javax.script.ScriptEngineFactory of the script engine

The factory variable can be used to obtain information about the JavaScript engine, such as the language version or the engine version. The rest of the variables have the same roles that they have in JSP pages.

Listing 12. The createScriptContext() method of JSServlet
public class JSServlet extends HttpServlet {
...
protected ScriptContext createScriptContext(
HttpServletRequest request, HttpServletResponse response)
throws IOException {
ScriptContext scriptContext = new SimpleScriptContext();
scriptContext.setWriter(response.getWriter());
int scope = ScriptContext.ENGINE_SCOPE;
scriptContext.setAttribute("config", getServletConfig(), scope);
scriptContext.setAttribute("application", getServletContext(), scope);
scriptContext.setAttribute("session", request.getSession(), scope);
scriptContext.setAttribute("request", request, scope);
scriptContext.setAttribute("response", response, scope);
scriptContext.setAttribute("out", response.getWriter(), scope);
scriptContext.setAttribute("factory",
scriptCache.getEngine().getFactory(), scope);
return scriptContext;
}
...
}

The runScript() method (see Listing 13) gets a compiled script from the cache and calls the eval() method, passing the given script context as parameter.

Listing 13. The runScript() method of JSServlet
public class JSServlet extends HttpServlet {
...
protected void runScript(String uri, ScriptContext scriptContext)
throws ScriptException, IOException {
scriptCache.getScript(uri).eval(scriptContext);
}
...
}

Handling requests

You could simply call the above runScript() method to execute the script that is mapped to the URL of the HTTP request. In a real application, however, you'll probably want to do some initialization before running the script and some finalization after the script's execution.

It is possible to run multiple scripts, sequentially, in the same context. For example, a script could define a set of variables and functions. Then, another script could do some processing, using the variables and functions of the previous script that was executed in the same context.

The servlet's handleRequest() method (shown in Listing 14) sets the HTTP headers, runs the init.jss script, removes the context path from the request's URI, executes the script that has the obtained URI, and then runs another script named finalize.jss.

Listing 14. The handleRequest() method of JSServlet
public class JSServlet extends HttpServlet {
...
protected void handleRequest(
HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
if (cacheControlHeader != null)
response.setHeader("Cache-Control", cacheControlHeader);
if (contentTypeHeader != null)
response.setContentType(contentTypeHeader);
ScriptContext scriptContext = createScriptContext(request, response);
try {
runScript("/init.jss", scriptContext);
String uri = request.getRequestURI();
uri = uri.substring(request.getContextPath().length());
try {
runScript(uri, scriptContext);
} catch (FileNotFoundException x) {
response.sendError(404, request.getRequestURI());
}
runScript("/finalize.jss", scriptContext);
} catch (ScriptException x) {
x.printStackTrace(response.getWriter());
throw new ServletException(x);
}
}
...
}

The doGet() and doPost() methods (see Listing 15) of JSServlet call handleRequest().

Listing 15. The doGet() and doPost() methods of JSServlet
public class JSServlet extends HttpServlet {
...
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
handleRequest(request, response);
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
handleRequest(request, response);
}

}

Developing server-side scripts

This section contains several examples of server-side scripts, which show how you can get the request parameters, access the properties of your JavaBeans, and generate JSON responses.

Pre-processing and post-processing

In the previous section, you've seen that JSServlet invokes init.jss (shown in Listing 16) before executing the requested script. If you want to measure how long it takes to execute your scripts, you can store the start time into a variable as shown below.

Listing 16. The init.jss script
var debug = true;
var debugStartTime = java.lang.System.nanoTime();

Then, you can calculate the execution time in finalize.jss (see Listing 17). The time is printed as a JavaScript comment so that JSServlet can generate valid JSON responses.

Listing 17. The finalize.jss script
var debugEndTime = java.lang.System.nanoTime();
if (debug)
println("// Time: " + (debugEndTime - debugStartTime) + " ns");

More code will be added to init.jss and finalize.jss through this series.

Getting request parameters

Scripts invoked with the help of JSServlet can access request parameters with request.getParameter() and request.getParameterValues(), which return Java objects. You might prefer a shorter syntax and you might want to work with JavaScript objects instead of Java strings and arrays. This can be done very easily by adding the following lines to init.jss (see Listing 18).

Listing 18. Getting request parameters in init.jss
var param = new Object();
var paramValues = new Object();

function initParams() {
var paramNames = request.getParameterNames();
while (paramNames.hasMoreElements()) {
var name = paramNames.nextElement();
param[name] = String(request.getParameter(name));
paramValues[name] = new Array();
var values = request.getParameterValues(name);
for (var i = 0; i < values.length; i++)
paramValues[name][i] = String(values[i]);
}
}

initParams();

Let's say you request a script named ParamDemo.jss with the URL shown in Listing 19.

Listing 19. URL example for requesting a script
http://localhost:8080/jsee/ParamDemo.jss?firstName=John&lastName=Smith

In ParamDemo.jss (see Listing 20), you can get the two request parameters with param.firstName and param.lastName.

Listing 20. The ParamDemo.jss example
println("Hello " + param.firstName + " " + param.lastName);

Accessing JavaBeans

The application, session and request scopes of a Web application store bean instances, which you can obtain and replace with the getAttribute() and setAttribute() methods of ServletContext, HttpSession, and HttpServletRequest, respectively. You can also use the getBean() and setBean() functions (shown in Listing 21), which must be placed into the init.jss file so that any script can call them. The scope parameter should be one of the following strings:

"application"
"session"
"request"

Listing 21. The getBean() and setBean() functions of init.jss
function getBean(scope, id) {
return eval(scope).getAttribute(id);
}

function setBean(scope, id, bean) {
if (!bean)
bean = eval(id);
return eval(scope).setAttribute(id, bean);
}

Now say you want to keep an instance of DemoBean (see Listing 22) in the session scope.

Listing 22. The DemoBean.java example
package jsee.demo;

public class DemoBean {
private int counter;

public int getCounter() {
return counter;
}

public void setCounter(int counter) {
this.counter = counter;
}

}

The BeanDemo.jss script (shown in Listing 23) imports the package containing the JavaBean with importPackage(Packages.jsee.demo). Then, the script tries to get the bean instance from the session scope with getBean(). If the bean is not found, BeanDemo.jss creates the object and places it into the session scope with setBean(). At the end, the script increments and prints the bean's counter property.

Listing 23. The BeanDemo.jss example
importPackage(Packages.jsee.demo);
var bean = getBean("session", "demo");
if (!bean) {
bean = new DemoBean();
setBean("session", "demo", bean);
}
bean.counter++;
println(bean.counter);

If you import a package that starts with java, javax, org, edu, com, or net, you don't have to use the Packages prefix in importPackage(). You may also import individual classes with importClass().

Returning JSON responses

Listing 24 shows an example that generates a JSON response containing some information about the JavaScript engine and the script's URI. The example uses the JavaScript syntax to create the json object whose source code is obtained as a String with the toSource() method.

Listing 24. The JsonDemo.jss example
var json = {
engine: {
name: String(factory.engineName),
version: String(factory.engineVersion),
threading: String(factory.getParameter("THREADING"))
},
language: {
name: String(factory.languageName),
version: String(factory.languageVersion)
},
script: {
uri: String(request.requestURI)
}
};

println(json.toSource());

All Java objects, which are retrieved from the properties of factory and request in this example, must be converted to JavaScript objects so that toSource() can work properly. Listing 25 contains the script's output:

Listing 25. The output of JsonDemo.jss
({language:{name:"ECMAScript", version:"1.6"},
engine:{name:"Mozilla Rhino", threading:"MULTITHREADED",
version:"1.6 release 2"}, script:{uri:"/jsee/JsonDemo.jss"}})

Conclusion

In this article, you've learned how to compile and execute JavaScript files, using the javax.script API. You also learned how to implement an LRU cache based on java.util.LinkedHashMap, how to export Java objects as script variables, how to implement a URL-script mapping, and how to build JavaScript files that are executed on the server-side. Stay tuned for the next part of this series where you'll learn how to call remote JavaScript functions with Ajax.

Back to top

Download

Description Name Size Download method
Sample application for this article jsee_part1_src.zip 25KB HTTP
Information about download methods

Resources

Learn

JSR-223 Scripting for the Java Platform is the specification containing all the details for using scripting languages in Java applications.

The Java Scripting Programmer's Guide presents the Java Scripting API and provides more code examples.

The javax.script package contains all the classes and interfaces of the Java Scripting API.

The developerWorks Web development zone is packed with tools and information for Web 2.0 development.

The developerWorks Ajax resource center contains a growing library of Ajax content as well as useful resources to get you started developing Ajax applications today.

Get products and technologies

Mozilla Rhino is the JavaScript engine bundled with Java SE Development Kit (JDK) 6.

About the author

Andrei Cioroianu is the founder of Devsphere, a provider of Java EE development and Web 2.0/Ajax consulting services. He's been using Java and Web technologies since 1997 and has over 10 years of professional experience in solving complex technical problems and managing the full life cycle of commercial products, custom applications, and open-source frameworks. You can reach Andrei through the contact form at www.devsphere.com.

Close [x]

Report abuse help
Report abuse

Thank you. This entry has been flagged for moderator attention.

Close [x]

Report abuse help
Report abuse

Report abuse submission failed. Please try again later.

Close [x]

developerWorks: Sign in

IBM ID:
Need an IBM ID?
Forgot your IBM ID?

Password:
Forgot your password?
Change your password

Keep me signed in.

By clicking Submit, you agree to the developerWorks terms of use.

The first time you sign into developerWorks, a profile is created for you. Select information in your profile (name, country/region, and company) is displayed to the public and will accompany any content you post. You may update your IBM account at any time.

All information submitted is secure.

Close [x]

Choose your display name

The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Display name:(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

All information submitted is secure.

Rate this article

Average rating (22 votes)

1 star1 star
2 stars2 stars
3 stars3 stars
4 stars4 stars
5 stars5 stars

Comments

Add comment:

Sign in or register to leave a comment.

Note: HTML elements are not supported within comments.

Notify me when a comment is added1000 characters left

Total comments (1)
Excellent article - precise and to the point.
Is it possible to provide an insight into performance with script engine? Similar tasks can be performed by various technologies and in order to adopt a technology, it would help to see how a scripting solution using JS would perform as compared to a native Java solution. For AJAX applications benefits of having JS modules run on server side are tremendous - Security (not sending sensitive data to browser), Overcome hard to solve cross-browser problems, Reduce latencies by eliminating browser-server trips - and at the same time delegating processing to browsers thereby achieving resposive UI, massive scalability. What remains to be seen is how much can we really push to the server without bogging it down. Obviously, answers to lot of these questions depends on - what is your app. However, a some commonly used realistic scenario breakdown w.r.t. performance will certainly help in adopting these technologies.

Posted by J D on 12 December 2009Report abuse
Back to top

Table of contents

Using the javax.script API
Building a script runner
Developing server-side scripts
Conclusion
Download
Resources
About the author
Comments
Next steps from IBM

Create rich Internet applications using WebSphere Portal Express Web 2.0 technologies.

Try: WebSphere Portal Express
Article: Get started using Ajax and WebSphere Portal Express
Tutorial: Quickly build a an Ajax-enabled WebSphere Portal Express Web application
Demo: Architecture, design, and construction using the IBM Rational Software Delivery Platform: AJAX
Buy: WebSphere Portal Express
Dig deeper into Web development on developerWorks

Overview
New to Web development
Open source projects
Technical library (articles, tutorials, training, and more)
Forums
Events
IBM SmartCloud trial. No charge.

Unleash the power of hybrid cloud computing today!

Public and private solutions in one trial.

Special offers

Trial software offers

Print this page
Share this pageFollow developerWorks
About
Help
Contact us
Submit content
Feeds
Report abuse
Terms of use
IBM privacy
IBM accessibility
Faculty
Students
Business Partners

Form Submit as JSON

2013-06-03T01:29:00.001-07:00

This is the basic html script

<h2>Form</h2>
<form action="" method="post">
<label>Hello</label>
First Name:<input type="text" name="Fname" maxlength="12" size="12"/> <br/>
Last Name:<input type="text" name="Lname" maxlength="36" size="12"/> <br/>
Gender:<br/>
Male:<input type="radio" name="gender" value="Male"/><br/>
Female:<input type="radio" name="gender" value="Female"/><br/>
Favorite Food:<br/>
Steak:<input type="checkbox" name="food[]" value="Steak"/><br/>
Pizza:<input type="checkbox" name="food[]" value="Pizza"/><br/>
Chicken:<input type="checkbox" name="food[]" value="Chicken"/><br/>
<textarea wrap="physical" cols="20" name="quote" rows="5">Enter your favorite quote!</textarea><br/>
Select a Level of Education:<br/>
<select name="education">
<option value="Jr.High">Jr.High</option>
<option value="HighSchool">HighSchool</option>
<option value="College">College</option></select><br/>
Select your favorite time of day:<br/>
<select size="3" name="TofD">
<option value="Morning">Morning</option>
<option value="Day">Day</option>
<option value="Night">Night</option></select>
<p><input type="submit" /></p>
</form>
<h2>JSON</h2>
<pre id="result">
</pre>

Here is javascript

$.fn.serializeObject = function()
{
var o = {};
var a = this.serializeArray();
$.each(a, function() {
if (o[this.name] !== undefined) {
if (!o[this.name].push) {
o[this.name] = [o[this.name]];
}
o[this.name].push(this.value || '');
} else {
o[this.name] = this.value || '';
}
});
return o;
};

$(function() {
$('form').submit(function() {
$('#result').text(JSON.stringify($('form').serializeObject()));
return false;
});
});

You can see it

http://jsfiddle.net/sxGtM/3/

Consuming JSON Strings in SQL Server

2013-05-28T23:08:00.003-07:00

"The best thing about XML is what it shares with JSON, being human readable. That turns out to be important, not because people should be reading it, because we shouldn't, but because it avoids interoperability problems caused by fussy binary encoding issues.

Beyond that, there is not much to like. It is not very good as a data format. And it is not very good as a document format. If it were a good document format, then wikis would use it."

Doug Crockford March 2010

This article describes a TSQL JSON parser and its evil twin, a JSON outputter, and provides the source. It is also designed to illustrate a number of string manipulation techniques in TSQL. With it you can do things like this to extract the data from a JSON document:

Select*from parseJSON('{
  "Person":

  {

     "firstName": "John",

     "lastName": "Smith",

     "age": 25,

     "Address":

     {

        "streetAddress":"21 2nd Street",

        "city":"New York",

        "state":"NY",

        "postalCode":"10021"

     },

     "PhoneNumbers":

     {

        "home":"212 555-1234",

        "fax":"646 555-4567"

     }

  }

}

')

And get:

...or you can do the round trip:

DECLARE @MyHierarchy JSONHierarchy
INSERT INTO @myHierarchy

select * from parseJSON('{"menu": {

  "id": "file",

  "value": "File",

  "popup": {

    "menuitem": [

      {"value": "New", "onclick": "CreateNewDoc()"},

      {"value": "Open", "onclick": "OpenDoc()"},

      {"value": "Close", "onclick": "CloseDoc()"}

    ]

  }

}}')

SELECT dbo.ToJSON(@MyHierarchy)

To get:

{
"menu" :   {

  "id" : "file",

  "value" : "File",

  "popup" :   {

    "menuitem" :   [

        {

        "value" : "New",

        "onclick" : "CreateNewDoc()"

        },

        {

        "value" : "Open",

        "onclick" : "OpenDoc()"

        },

        {

        "value" : "Close",

        "onclick" : "CloseDoc()"

        }

      ]

    }

  }

}

Background

TSQL isn’t really designed for doing complex string parsing, particularly where strings represent nested data structures such as XML, JSON, YAML, or XHTML.

You can do it but it is not a pretty sight; but why would you ever want to do it anyway? Surely, if anything was meant for the 'application layer' in C# or VB.net, then this is it. 'Oh yes', will chime in the application thought police, 'this is far better done in the application or with a CLR.' Not necessarily.

Sometimes, you just need to do something inappropriate in TSQL.

There are a whole lot of reasons why this might happen to you. It could be that your DBA doesn’t allow a CLR, for example, or you lack the necessary skills with procedural code. Sometimes, there isn't any application, or you want to run code unobtrusively across databases or servers.

I needed to interpret or 'shred' JSON data. JSON is one of the most popular lightweight markup languages, and is probably the best choice for transfer of object data from a web page. It is, in fact, executable JavaScript that is very quick to code in the browser in order to dump the contents of a JavaScript object, and is lightning-fast to populate the browser object from the database since you are passing it executable code (you need to parse it first for security reasons - passing executable code around is potentially very risky). AJAX can use JSON rather than XML so you have an opportunity to have a much simpler route for data between database and browser, with less opportunity for error.

The conventional way of dealing with data like this is to let a separate business layer parse a JSON 'document' into some tree structure and then update the database by making a series of calls to it. This is fine, but can get more complicated if you need to ensure that the updates to the database are wrapped into one transaction so that if anything goes wrong, then the whole operation can be rolled back. This is why a CLR or TSQL approach has advantages.

"Sometimes, you just
need to do something
inappropriate in TSQL..."

I wrote the parser as a prototype because it was the quickest way to determine what was involved in the process, so I could then re-write something as a CLR in a .NET language. It takes a JSON string and produces a result in the form of an adjacency list representation of that hierarchy. In the end, the code did what I wanted with adequate performance (It reads a json file of 540 name\value pairs and creates the SQL hierarchy table in 4 seconds) so I didn't bother with the added complexity of maintaining a CLR routine. In order to test more thoroughly what I'd done, I wrote a JSON generator that used the same Adjacency list, so you can now import and export data via JSON!

These markup languages such as JSON and XML all represent object data as hierarchies. Although it looks very different to the entity-relational model, it isn't. It is rather more a different perspective on the same model. The first trick is to represent it as a Adjacency list hierarchy in a table, and then use the contents of this table to update the database. This Adjacency list is really the Database equivalent of any of the nested data structures that are used for the interchange of serialized information with the application, and can be used to create XML, OSX Property lists, Python nested structures or YAML as easily as JSON.

Adjacency list tables have the same structure whatever the data in them. This means that you can define a single Table-Valued Type and pass data structures around between stored procedures. However, they are best held at arms-length from the data, since they are not relational tables, but something more like the dreaded EAV (Entity-Attribute-Value) tables. Converting the data from its Hierarchical table form will be different for each application, but is easy with a CTE. You can, alternatively, convert the hierarchical table into XML and interrogate that with XQuery.

JSON format.

JSON is designed to be as lightweight as possible and so it has only two structures. The first, delimited by curly brackets, is a collection of name/value pairs, separated by commas. The name is followed by a colon. This structure is generally implemented in the application-level as an object, record, struct, dictionary, hash table, keyed list, or associative array. The other structure is an ordered list of values, separated by commas. This is usually manifested as an array, vector, list, or sequence.

"Using recursion in TSQL is
like Sumo Wrestlers doing Ballet.
It is possible but not pretty."

The first snag for TSQL is that the curly or square brackets are not 'escaped' within a string, so that there is no way of shredding a JSON 'document' simply. It is difficult to differentiate a bracket used as the delimiter of an array or structure, and one that is within a string. Also, interpreting a string into a SQL String isn't entirely straightforward since hex codes can be embedded anywhere to represent complex Unicode characters, and all the old C-style escaped characters are used. The second complication is that, unlike YAML, the datatypes of values can't be explicitly declared. You have to sniff them out from applying the rules from the JSON Specification.

Obviously, structures can be embedded in structures, so recursion is a natural way of making life easy. Using recursion in TSQL is like Sumo Wrestlers doing Ballet. It is possible but not pretty.

The implementation

Although the code for the JSON Parser/Shredder will run in SQL Server 2005, and even in SQL Server 2000 (with some modifications required), I couldn't resist using a TVP (Table Valued Parameter) to pass a hierarchical table to the function, ToJSON, that produces a JSON 'document'. Writing a SQL Server 2005 version should not be too hard.

First the function replaces all strings with tokens of the form @Stringxx, where xx is the foreign key of the table variable where the strings are held. This takes them, and their potentially difficult embedded brackets, out of the way. Names are always strings in JSON as well as string values.

Then, the routine iteratively finds the next structure that has no structure contained within it, (and is, by definition the leaf structure), and parses it, replacing it with an object token of the form '@Objectxxx', or '@arrayxxx', where xxxis the object id assigned to it. The values, or name/value pairs are retrieved from the string table and stored in the hierarchy table. Gradually, the JSON document is eaten until there is just a single root object left.

The JSON outputter is a great deal simpler, since one can be surer of the input, but essentially it does the reverse process, working from the root to the leaves. The only complication is working out the indent of the formatted output string.

In the implementation, you'll see a fairly heavy use of PATINDEX. This uses a poor man's RegEx, a starving man's RegEx. However, it is all we have, and can be pressed into service by chopping the string it is searching (if only it had an optional third parameter like CHARINDEX that specified the index of the start position of the search!). The STUFF function is also a godsend for this sort of string-manipulation work.

IF OBJECT_ID (N'dbo.parseJSON') IS NOT NULL

  DROP FUNCTION dbo.parseJSON

GO

CREATE FUNCTION dbo.parseJSON( @JSON NVARCHAR(MAX))

RETURNS @hierarchy table

(

  element_id int IDENTITY(1, 1) NOT NULL, /* internal surrogate primary key gives the order of parsing and the list order */

  parent_id int, /* if the element has a parent then it is in this column. The document is the ultimate parent, so you can get the structure from recursing from the document */

  object_id int, /* each list or object has an object id. This ties all elements to a parent. Lists are treated as objects here */

  name nvarchar(2000), /* the name of the object */

  stringvalue nvarchar(4000) NOT NULL, /*the string representation of the value of the element. */

  valuetype nvarchar(100) NOT null /* the declared type of the value represented as a string in stringvalue*/

)

AS

BEGIN

   DECLARE

     @firstobject int, --the index of the first open bracket found in the JSON string

     @opendelimiter int,--the index of the next open bracket found in the JSON string

     @nextopendelimiter int,--the index of subsequent open bracket found in the JSON string

     @nextclosedelimiter int,--the index of subsequent close bracket found in the JSON string

     @type nvarchar(10),--whether it denotes an object or an array

     @nextclosedelimiterChar CHAR(1),--either a '}' or a ']'

     @contents nvarchar(MAX), --the unparsed contents of the bracketed expression

     @start int, --index of the start of the token that you are parsing

     @end int,--index of the end of the token that you are parsing

     @param int,--the parameter at the end of the next Object/Array token

     @endofname int,--the index of the start of the parameter at end of Object/Array token

     @token nvarchar(4000),--either a string or object

     @value nvarchar(MAX), -- the value as a string

     @name nvarchar(200), --the name as a string

     @parent_id int,--the next parent ID to allocate

     @lenjson int,--the current length of the JSON String

     @characters NCHAR(62),--used to convert hex to decimal

     @result BIGINT,--the value of the hex symbol being parsed

     @index SMALLINT,--used for parsing the hex value

     @escape int --the index of the next escape character

   /* in this temporary table we keep all strings, even the names of the elements, since they are 'escaped'

    * in a different way, and may contain, unescaped, brackets denoting objects or lists. These are replaced in

    * the JSON string by tokens representing the string

    */

   DECLARE @strings table

   (

     string_id int IDENTITY(1, 1),

     stringvalue nvarchar(MAX)

   )

   /* initialise the characters to convert hex to ascii */

   SELECT

     @characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',

     @parent_id = 0;

   /* firstly we process all strings. This is done because [{} and ] aren't escaped in strings, which complicates an iterative parse. */

   WHILE 1 = 1 /* forever until there is nothing more to do */

   BEGIN

     SELECT @start = PATINDEX('%[^a-zA-Z]["]%', @json collateSQL_Latin1_General_CP850_Bin); /* next delimited string */

     IF @start = 0 BREAK /*no more so drop through the WHILE loop */

     IF SUBSTRING(@json, @start+1, 1) = '"'

     BEGIN  /* Delimited name */

      SET @start = @start+1;

      SET @end = PATINDEX('%[^\]["]%', RIGHT(@json, LEN(@json+'|')-@start) collateSQL_Latin1_General_CP850_Bin);

     END

     IF @end = 0 /*no end delimiter to last string*/

      BREAK /* no more */

     SELECT @token = SUBSTRING(@json, @start+1, @end-1)

     /* now put in the escaped control characters */

     SELECT @token = REPLACE(@token, from_string, to_string)

     FROM

     (

      SELECT '\"' AS from_string, '"' AS to_string

      UNION ALL

      SELECT '\\', '\'

      UNION ALL

      SELECT '\/', '/'

      UNION ALL

      SELECT '\b', CHAR(08)

      UNION ALL

      SELECT '\f', CHAR(12)

      UNION ALL

      SELECT '\n', CHAR(10)

      UNION ALL

      SELECT '\r', CHAR(13)

      UNION ALL

      SELECT '\t', CHAR(09)

     ) substitutions

     SELECT @result = 0, @escape = 1

     /*Begin to take out any hex escape codes*/

     WHILE @escape > 0

     BEGIN

      /* find the next hex escape sequence */

      SELECT

        @index = 0, 

        @escape = PATINDEX('%\x[0-9a-f][0-9a-f][0-9a-f][0-9a-f]%', @token collateSQL_Latin1_General_CP850_Bin)

      IF @escape > 0 /* if there is one */

      BEGIN

        WHILE @index < 4 /* there are always four digits to a \x sequence  */

        BEGIN

          /* determine its value */

          SELECT

           @result =

           @result + POWER(16, @index) * (CHARINDEX(SUBSTRING(@token, @escape + 2 + 3 -@index, 1), @characters) - 1), @index = @index+1 ;

          END

          /* and replace the hex sequence by its unicode value */

          SELECT @token = STUFF(@token, @escape, 6, NCHAR(@result))

        END

      END

      /* now store the string away */

      INSERT INTO @strings

      (stringvalue)

      SELECT @token

      /* and replace the string with a token */

      SELECT @json = STUFF(@json, @start, @end + 1, '@string' + CONVERT(nvarchar(5),@@identity))

     END

     /* all strings are now removed. Now we find the first leaf. */

     WHILE 1 = 1  /* forever until there is nothing more to do */

     BEGIN

      SELECT @parent_id = @parent_id + 1

      /* find the first object or list by looking for the open bracket */

      SELECT @firstobject = PATINDEX('%[{[[]%', @json collateSQL_Latin1_General_CP850_Bin)  /*object or array*/

      IF @firstobject = 0

        BREAK

      IF (SUBSTRING(@json, @firstobject, 1) = '{')

        SELECT @nextclosedelimiterChar = '}', @type = 'object'

      ELSE

        SELECT @nextclosedelimiterChar = ']', @type = 'array'

      SELECT @opendelimiter = @firstobject

      WHILE 1 = 1 --find the innermost object or list...

      BEGIN

        SELECT @lenjson = LEN(@json+'|')-1

        /* find the matching close-delimiter proceeding after the open-delimiter */

        SELECT @nextclosedelimiter = CHARINDEX(@nextclosedelimiterChar, @json,@opendelimiter + 1)

        /* is there an intervening open-delimiter of either type */

        SELECT @nextopendelimiter = PATINDEX('%[{[[]%',RIGHT(@json, @lenjson-@opendelimiter) collate SQL_Latin1_General_CP850_Bin) /*object*/

        IF @nextopendelimiter = 0

          BREAK

        SELECT @nextopendelimiter = @nextopendelimiter + @opendelimiter

        IF @nextclosedelimiter < @nextopendelimiter

          BREAK

        IF SUBSTRING(@json, @nextopendelimiter, 1) = '{'

          SELECT @nextclosedelimiterChar = '}', @type = 'object'

        ELSE

          SELECT @nextclosedelimiterChar = ']', @type = 'array'

        SELECT @opendelimiter = @nextopendelimiter

      END

     /* and parse out the list or name/value pairs */

     SELECT @contents = SUBSTRING(@json, @opendelimiter+1, @nextclosedelimiter-@opendelimiter - 1)

     SELECT @json = STUFF(@json, @opendelimiter, @nextclosedelimiter - @opendelimiter +1, '@' + @type + CONVERT(nvarchar(5), @parent_id))

     WHILE (PATINDEX('%[A-Za-z0-9@+.e]%', @contents collateSQL_Latin1_General_CP850_Bin)) <  > 0

     BEGIN /* WHILE PATINDEX */

      IF @type = 'object' /*it will be a 0-n list containing a string followed by a string, number,boolean, or null*/

      BEGIN

        SELECT @end = CHARINDEX(':', ' '+@contents) /*if there is anything, it will be a string-based name.*/

        SELECT @start = PATINDEX('%[^A-Za-z@][@]%', ' '+@contents collateSQL_Latin1_General_CP850_Bin) /*AAAAAAAA*/

        SELECT

          @token = SUBSTRING(' '+@contents, @start + 1, @end - @start - 1),

          @endofname = PATINDEX('%[0-9]%', @token collate SQL_Latin1_General_CP850_Bin),

          @param = RIGHT(@token, LEN(@token)-@endofname+1)

        SELECT

          @token = LEFT(@token, @endofname - 1),

          @contents = RIGHT(' ' + @contents, LEN(' ' + @contents + '|') - @end - 1)

        SELECT @name = stringvalue

        FROM @strings

        WHERE string_id = @param /*fetch the name*/

      END

      ELSE

      BEGIN

        SELECT @name = null

      END

      SELECT @end = CHARINDEX(',', @contents)  /*a string-token, object-token, list-token, number,boolean, or null*/

      IF @end = 0

        SELECT @end = PATINDEX('%[A-Za-z0-9@+.e][^A-Za-z0-9@+.e]%', @contents+' 'collate SQL_Latin1_General_CP850_Bin) + 1

      SELECT @start = PATINDEX('%[^A-Za-z0-9@+.e][A-Za-z0-9@+.e]%', ' ' + @contentscollate SQL_Latin1_General_CP850_Bin)

      /*select @start,@end, LEN(@contents+'|'), @contents */

      SELECT

        @value = RTRIM(SUBSTRING(@contents, @start, @end-@start)),

        @contents = RIGHT(@contents + ' ', LEN(@contents+'|') - @end)

      IF SUBSTRING(@value, 1, 7) = '@object'

        INSERT INTO @hierarchy (name, parent_id, stringvalue, object_id, valuetype)

        SELECT @name, @parent_id, SUBSTRING(@value, 8, 5),

        SUBSTRING(@value, 8, 5), 'object'

      ELSE

        IF SUBSTRING(@value, 1, 6) = '@array'

          INSERT INTO @hierarchy (name, parent_id, stringvalue, object_id, valuetype)

          SELECT @name, @parent_id, SUBSTRING(@value, 7, 5), SUBSTRING(@value, 7, 5),'array'

        ELSE

          IF SUBSTRING(@value, 1, 7) = '@string'

          INSERT INTO @hierarchy (name, parent_id, stringvalue, valuetype)

          SELECT @name, @parent_id, stringvalue, 'string'

          FROM @strings

          WHERE string_id = SUBSTRING(@value, 8, 5)

          ELSE

           IF @value IN ('true', 'false')

             INSERT INTO @hierarchy (name, parent_id, stringvalue, valuetype)

              SELECT @name, @parent_id, @value, 'boolean'

           ELSE

              IF @value = 'null'

              INSERT INTO @hierarchy (name, parent_id, stringvalue, valuetype)

              SELECT @name, @parent_id, @value, 'null'

              ELSE

               IF PATINDEX('%[^0-9]%', @value collate SQL_Latin1_General_CP850_Bin) > 0

                 INSERT INTO @hierarchy (name, parent_id, stringvalue, valuetype)

                 SELECT @name, @parent_id, @value, 'real'

               ELSE

                 INSERT INTO @hierarchy (name, parent_id, stringvalue, valuetype)

                 SELECT @name, @parent_id, @value, 'int'       

     END /* WHILE PATINDEX */

   END /* WHILE 1=1 forever until there is nothing more to do */

   INSERT INTO @hierarchy (name, parent_id, stringvalue, object_id, valuetype)

   SELECT '-', NULL, '', @parent_id - 1, @type

   RETURN

END

GO

So once we have a hierarchy, we can pass it to a stored procedure. As the output is an adjacency list, it should be easy to access the data. You might find it handy to create a table type if you are using SQL Server 2008. Here is what I use. (Note that if you drop a Table Valued Parameter type, you will have to drop any dependent functions or procedures first, and re-create them afterwards).

-- Create the data type
IF EXISTS (SELECT * FROM sys.types WHERE name LIKE 'JSONHierarchy')

  DROP TYPE dbo.JSONHierarchy

go

CREATE TYPE dbo.JSONHierarchy AS TABLE

(

   element_id INT NOT NULL, /* internal surrogate primary key gives the order of parsing and the list order */

   parent_ID INT,/* if the element has a parent then it is in this column. The document is the ultimate parent, so you can get the structure from recursing from the document */

   Object_ID INT,/* each list or object has an object id. This ties all elements to a parent. Lists are treated as objects here */

   NAME NVARCHAR(2000),/* the name of the object, null if it hasn't got one */

   StringValue NVARCHAR(MAX) NOT NULL,/*the string representation of the value of the element. */

   ValueType VARCHAR(10) NOT null /* the declared type of the value represented as a string in StringValue*/

    PRIMARY KEY (element_id)

)

ToJSON. A function that creates JSON Documents

Firstly, we need a simple utility function:

IFOBJECT_ID (N'dbo.parseJSON')ISNOTNULL
   DROP FUNCTION dbo.JSONEscaped

GO

CREATE FUNCTION JSONEscaped ( /* this is a simple utility function that takes a SQL String with all its clobber and outputs it as a sting with all the JSON escape sequences in it.*/

  @Unescaped NVARCHAR(MAX) --a string with maybe characters that will break json

  )

RETURNS NVARCHAR(MAX)

AS

BEGIN

  SELECT  @Unescaped = REPLACE(@Unescaped, FROMString, TOString)

  FROM    (SELECT

            '\"' AS FromString, '"' AS ToString

           UNION ALL SELECT '\', '\\'

           UNION ALL SELECT '/', '\/'

           UNION ALL SELECT  CHAR(08),'\b'

           UNION ALL SELECT  CHAR(12),'\f'

           UNION ALL SELECT  CHAR(10),'\n'

           UNION ALL SELECT  CHAR(13),'\r'

           UNION ALL SELECT  CHAR(09),'\t'

          ) substitutions

RETURN @Unescaped

END

And now, the function that takes a JSON Hierarchy table and converts it to a JSON string.

IFOBJECT_ID (N'dbo.ToJSON')ISNOTNULL
   DROP FUNCTION dbo.ToJSON

GO

CREATE FUNCTION ToJSON

(

      @Hierarchy JSONHierarchy READONLY

)

RETURNS NVARCHAR(MAX)--JSON documents are always unicode.

AS

BEGIN

  DECLARE

    @JSON NVARCHAR(MAX),

    @NewJSON NVARCHAR(MAX),

    @Where INT,

    @ANumber INT,

    @notNumber INT,

    @indent INT,

    @CrLf CHAR(2)--just a simple utility to save typing!

  --firstly get the root token into place

  SELECT @CrLf=CHAR(13)+CHAR(10),--just CHAR(10) in UNIX

         @JSON = CASE ValueType WHEN 'array' THEN '[' ELSE '{' END

            +@CrLf+ '@Object'+CONVERT(VARCHAR(5),OBJECT_ID)

            +@CrLf+CASE ValueType WHEN 'array' THEN ']' ELSE '}' END

  FROM @Hierarchy

    WHERE parent_id IS NULL AND valueType IN ('object','array') --get the root element

/* now we simply iterate from the root token growing each branch and leaf in each iteration. This won't be enormously quick, but it is simple to do. All values, or name/value pairs withing a structure can be created in one SQL Statement*/

  WHILE 1=1

    begin

    SELECT @where= PATINDEX('%[^[a-zA-Z0-9]@Object%',@json)--find NEXT token

    if @where=0 BREAK

    /* this is slightly painful. we get the indent of the object we've found by looking backwards up the string */

    SET@indent=CHARINDEX(char(10)+char(13),Reverse(LEFT(@json,@where))+char(10)+char(13))-1

    SET @NotNumber= PATINDEX('%[^0-9]%', RIGHT(@json,LEN(@JSON+'|')-@Where-8)+' ')--find NEXT token

    SET @NewJSON=NULL --this contains the structure in its JSON form

    SELECT @NewJSON=COALESCE(@NewJSON+','+@CrLf+SPACE(@indent),'')

      +COALESCE('"'+NAME+'" : ','')

      +CASE valuetype

        WHEN 'array' THEN '  ['+@CrLf+SPACE(@indent+2)

           +'@Object'+CONVERT(VARCHAR(5),OBJECT_ID)+@CrLf+SPACE(@indent+2)+']'

        WHEN 'object' then '  {'+@CrLf+SPACE(@indent+2)

           +'@Object'+CONVERT(VARCHAR(5),OBJECT_ID)+@CrLf+SPACE(@indent+2)+'}'

        WHEN 'string' THEN '"'+dbo.JSONEscaped(StringValue)+'"'

        ELSE StringValue

       END

     FROM @Hierarchy WHERE parent_id= SUBSTRING(@JSON,@where+8, @Notnumber-1)

     /* basically, we just lookup the structure based on the ID that is appended to the @Object token. Simple eh? */

    --now we replace the token with the structure, maybe with more tokens in it.

    Select @JSON=STUFF (@JSON, @where+1, 8+@NotNumber-1, @NewJSON)

    end

  return @JSON

end

ToXML. A function that creates XML

The function that converts a hierarchy table to XML gives us a JSON to XML converter. It is surprisingly similar to the previous function

IF OBJECT_ID (N'dbo.ToXML') IS NOT NULL

   DROP FUNCTION dbo.ToXML

GO

CREATE FUNCTION ToXML

(

/*this function converts a JSONhierarchy table into an XML document. This uses the same technique as the toJSON function, and uses the 'entities' form of XML syntax to give a compact rendering of the structure */

      @Hierarchy JSONHierarchy READONLY

)

RETURNS NVARCHAR(MAX)--use unicode.

AS

BEGIN

  DECLARE

    @XMLAsString NVARCHAR(MAX),

    @NewXML NVARCHAR(MAX),

    @Entities NVARCHAR(MAX),

    @Objects NVARCHAR(MAX),

    @Name NVARCHAR(200),

    @Where INT,

    @ANumber INT,

    @notNumber INT,

    @indent INT,

    @CrLf CHAR(2)--just a simple utility to save typing!

  --firstly get the root token into place

  --firstly get the root token into place

  SELECT @CrLf=CHAR(13)+CHAR(10),--just CHAR(10) in UNIX

         @XMLasString ='<?xml version="1.0" ?>

@Object'+CONVERT(VARCHAR(5),OBJECT_ID)+'

'

    FROM @hierarchy

    WHERE parent_id IS NULL AND valueType IN ('object','array') --get the root element

/* now we simply iterate from the root token growing each branch and leaf in each iteration. This won't be enormously quick, but it is simple to do. All values, or name/value pairs within a structure can be created in one SQL Statement*/

  WHILE 1=1

    begin

    SELECT @where= PATINDEX('%[^a-zA-Z0-9]@Object%',@XMLAsString)--find NEXT token

    if @where=0 BREAK

    /* this is slightly painful. we get the indent of the object we've found by looking backwards up the string */

    SET@indent=CHARINDEX(char(10)+char(13),Reverse(LEFT(@XMLasString,@where))+char(10)+char(13))-1

    SET @NotNumber= PATINDEX('%[^0-9]%', RIGHT(@XMLasString,LEN(@XMLAsString+'|')-@Where-8)+' ')--find NEXT token

    SET @Entities=NULL --this contains the structure in its XML form

    SELECT @Entities=COALESCE(@Entities+' ',' ')+NAME+'="'

     +REPLACE(REPLACE(REPLACE(StringValue, '<', '&lt;'), '&', '&amp;'),'>', '&gt;')

     + '"' 

       FROM @hierarchy

       WHERE parent_id= SUBSTRING(@XMLasString,@where+8, @Notnumber-1)

          AND ValueType NOT IN ('array', 'object')

    SELECT @Entities=COALESCE(@entities,''),@Objects='',@name=CASE WHEN Name='-' THEN'root' ELSE NAME end

      FROM @hierarchy

      WHERE [Object_id]= SUBSTRING(@XMLasString,@where+8, @Notnumber-1)

    SELECT  @Objects=@Objects+@CrLf+SPACE(@indent+2)

           +'@Object'+CONVERT(VARCHAR(5),OBJECT_ID)

           --+@CrLf+SPACE(@indent+2)+''

      FROM @hierarchy

      WHERE parent_id= SUBSTRING(@XMLasString,@where+8, @Notnumber-1)

      AND ValueType IN ('array', 'object')

    IF @Objects='' --if it is a lef, we can do a more compact rendering

         SELECT @NewXML='<'+COALESCE(@name,'item')+@entities+' />'

    ELSE

        SELECT @NewXML='<'+COALESCE(@name,'item')+@entities+'>'

            +@Objects+@CrLf++SPACE(@indent)+'</'+COALESCE(@name,'item')+'>'

     /* basically, we just lookup the structure based on the ID that is appended to the @Object token. Simple eh? */

    --now we replace the token with the structure, maybe with more tokens in it.

    Select @XMLasString=STUFF (@XMLasString, @where+1, 8+@NotNumber-1, @NewXML)

    end

  return @XMLasString

  end

This provides you the means of converting a JSON string into XML

DECLARE @MyHierarchy JSONHierarchy,@xml XML

INSERT INTO @myHierarchy

select * from parseJSON('{"menu": {

  "id": "file",

  "value": "File",

  "popup": {

    "menuitem": [

      {"value": "New", "onclick": "CreateNewDoc()"},

      {"value": "Open", "onclick": "OpenDoc()"},

      {"value": "Close", "onclick": "CloseDoc()"}

    ]

  }

}}')

SELECT dbo.ToXML(@MyHierarchy)

SELECT @XML=dbo.ToXML(@MyHierarchy)

SELECT @XML

This gives the result...

<?xml version="1.0" ?>

<root>

  <menu id="file" value="File">

    <popup>

      <menuitem>

        <item value="New" onclick="CreateNewDoc()" />

        <item value="Open" onclick="OpenDoc()" />

        <item value="Close" onclick="CloseDoc()" />

      </menuitem>

    </popup>

  </menu>

</root>

(1 row(s) affected)

<root><menu id="file" value="File"><popup><menuitem><item value="New" onclick="CreateNewDoc()" /><item value="Open" onclick="OpenDoc()" /><item value="Close" onclick="CloseDoc()" /></menuitem></popup></menu></root>

(1 row(s) affected)

Wrap-up

The so-called 'impedence-mismatch' between applications and databases is, I reckon, an illusion. The object-oriented nested data-structures that we receive from applications are, if the developer has understood the data correctly, merely a perspective from a particular entity of the relationships it is involved with. Whereas it is easy to shred XML documents to get the data from it to update the database, it has been trickier with other formats such as JSON. By using techniques like this, it should be possible to liberate the application, or website, programmer from having to do the mapping from the object model to the relational, and spraying the database with ad-hoc TSQL that uses the base tables or updateable views. If the database can be provided with the JSON, or the Table-Valued parameter, then there is a better chance of maintaining full transactional integrity for the more complex updates.

The database developer already has the tools to do the work with XML, but why not the simpler, and more practical JSON? I hope these two routines get you started with experimenting with this.

Improve SQL Server query to convert arbitrary table to JSON

2013-05-28T23:05:00.002-07:00

declare @xd table (col1 varchar(max), col2 int, col3 real, colDate datetime, colNull int);

declare @i int = 0;

while @i < 10000 begin
    set @i += 1;
    insert into @xd
    select '', null, null, null, null
    union all select 'ItemA', 123, 123.123, getDate(), null
    union all select 'ItemB', 456, 456.456, getDate(), null
    union all select '7890', 789, 789.789, getDate(), null;
end;

select *
into #json_base
from (
    -- Insert SQL Statement here
    select * from @xd
) t;

declare @columns table (
    id int identity primary key,
    name sysname,
    datatype sysname,
    is_number bit,
    is_date bit);

insert into @columns(name, datatype, is_number, is_date)
select columns.name, types.name,
       case when number_types.name is not NULL
            then 1 else 0
       end as is_number,
       case when date_types.name is not NULL
            then 1 else 0
       end as is_date
from tempdb.sys.columns
join tempdb.sys.types
    on (columns.system_type_id = types.system_type_id)
left join (values ('int'), ('real'), ('numeric'),
                  ('decimal'), ('bigint'), ('tinyint')) as number_types(name)
    on (types.name = number_types.name)
left join (values ('date'), ('datetime'), ('datetime2'),
                  ('smalldatetime'), ('time'), ('datetimeoffset')) as date_types(name)
    on (types.name = date_types.name)
where object_id = OBJECT_ID('tempdb..#json_base');

declare @field_list varchar(max) = STUFF((
    select '+'',''+' + QUOTENAME(QUOTENAME(name, '"') + ':', '''')
           + '+' + case when is_number = 1
                        then 'COALESCE(LTRIM('
                                + QUOTENAME(name) + '),''null'')'
                        when is_date = 1
                        then 'COALESCE(QUOTENAME(LTRIM(convert(varchar(max), '
                                + QUOTENAME(name) + ', 126)),''"''),''null'')'
                        else 'COALESCE(QUOTENAME('
                                + QUOTENAME(name) + ',''"''),''null'')'
                   end
    from @columns
    for xml path('')),
    1, 5, '');

create table #json_result (
    id int identity primary key,
    line varchar(max));

declare @sql varchar(max) = REPLACE(
    'insert into #json_result '
  + 'select '',{''+{f}+''}'' '
  + 'from #json_base', '{f}', @field_list);

exec(@sql);

update #json_result
set line = STUFF(line, 1, 1, '')
where id = 1;

select '['
UNION ALL
select line
from #json_result
UNION ALL
select ']';

drop table #json_base;
drop table #json_result;

Here a Simple way to get json from Sql server 2008

2013-05-27T00:33:00.001-07:00

Here a Simple way to get json from Sql server 2008

1) Create and run the Procdute

CREATE PROCEDURE [dbo].[GetJSON] (
@ParameterSQL AS VARCHAR(MAX)
)
AS
BEGIN

DECLARE @SQL NVARCHAR(MAX)
DECLARE @XMLString VARCHAR(MAX)
DECLARE @XML XML
DECLARE @Paramlist NVARCHAR(1000)
SET @Paramlist = N'@XML XML OUTPUT'
SET @SQL = 'WITH PrepareTable (XMLString) '
SET @SQL = @SQL + 'AS ( '
SET @SQL = @SQL + @ParameterSQL+ ' FOR XML RAW, TYPE, ELEMENTS '
SET @SQL = @SQL + ') '
SET @SQL = @SQL + 'SELECT @XML = XMLString FROM PrepareTable '
EXEC sp_executesql @SQL, @Paramlist, @XML=@XML OUTPUT
SET @XMLString = CAST(@XML AS VARCHAR(MAX))

DECLARE @JSON VARCHAR(MAX)
DECLARE @Row VARCHAR(MAX)
DECLARE @RowStart INT
DECLARE @RowEnd INT
DECLARE @FieldStart INT
DECLARE @FieldEnd INT
DECLARE @KEY VARCHAR(MAX)
DECLARE @Value VARCHAR(MAX)

DECLARE @StartRoot VARCHAR(100); SET @StartRoot = '<row>'
DECLARE @EndRoot VARCHAR(100); SET @EndRoot = '</row>'
DECLARE @StartField VARCHAR(100); SET @StartField = '<'
DECLARE @EndField VARCHAR(100); SET @EndField = '>'

SET @RowStart = CharIndex(@StartRoot, @XMLString, 0)
SET @JSON = ''
WHILE @RowStart > 0
BEGIN
 SET @RowStart = @RowStart+Len(@StartRoot)
 SET @RowEnd = CharIndex(@EndRoot, @XMLString, @RowStart)
 SET @Row = SubString(@XMLString, @RowStart, @RowEnd-@RowStart)
 SET @JSON = @JSON+'{'

 -- for each row
 SET @FieldStart = CharIndex(@StartField, @Row, 0)
 WHILE @FieldStart > 0
 BEGIN
  -- parse node key
  SET @FieldStart = @FieldStart+Len(@StartField)
  SET @FieldEnd = CharIndex(@EndField, @Row, @FieldStart)
  SET @KEY = SubString(@Row, @FieldStart, @FieldEnd-@FieldStart)
  SET @JSON = @JSON+'"'+@KEY+'":'

  -- parse node value
  SET @FieldStart = @FieldEnd+1
  SET @FieldEnd = CharIndex('</', @Row, @FieldStart)
  SET @Value = SubString(@Row, @FieldStart, @FieldEnd-@FieldStart)
  SET @JSON = @JSON+'"'+@Value+'",'

  SET @FieldStart = @FieldStart+Len(@StartField)
  SET @FieldEnd = CharIndex(@EndField, @Row, @FieldStart)
  SET @FieldStart = CharIndex(@StartField, @Row, @FieldEnd)
 END 
 IF LEN(@JSON)>0 SET @JSON = SubString(@JSON, 0, LEN(@JSON))
 SET @JSON = @JSON+'},'
 --/ for each row

 SET @RowStart = CharIndex(@StartRoot, @XMLString, @RowEnd)
END
IF LEN(@JSON)>0 SET @JSON = SubString(@JSON, 0, LEN(@JSON))
SET @JSON = '[' + @JSON + ']'
SELECT @JSON

END

exemplo de uso:
EXEC GetJSON 'SELECT * FROM dbo.Employee_TBL'
retorno do select:
[{"UserId":"7C92EB27-DD81-498E-82CE-18192C940328","FirstName":"Bill","LastName":"Gates","Age":"45","LastLogin":"20

DynamicJsonConverter

2013-05-22T01:32:00.003-07:00

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Web.Script.Serialization;

private sealed class DynamicJsonConverter : JavaScriptConverter
{
    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        if (dictionary == null)
            throw new ArgumentNullException("dictionary");

        return type == typeof(object) ? new DynamicJsonObject(dictionary) : null;
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override IEnumerable<Type> SupportedTypes
    {
        get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { typeof(object) })); }
    }

    #region Nested type: DynamicJsonObject

    private sealed class DynamicJsonObject : DynamicObject
    {
        private readonly IDictionary<string, object> _dictionary;

        public DynamicJsonObject(IDictionary<string, object> dictionary)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");
            _dictionary = dictionary;
        }

        public override string ToString()
        {
            var sb = new StringBuilder("{");
            ToString(sb);
            return sb.ToString();
        }

        private void ToString(StringBuilder sb)
        {
            var firstInDictionary = true;
            foreach (var pair in _dictionary)
            {
                if (!firstInDictionary)
                    sb.Append(",");
                firstInDictionary = false;
                var value = pair.Value;
                var name = pair.Key;
                if (value is string)
                {
                    sb.AppendFormat("{0}:\"{1}\"", name, value);
                }
                else if (value is IDictionary<string, object>)
                {
                    new DynamicJsonObject((IDictionary<string, object>)value).ToString(sb);
                }
                else if (value is ArrayList)
                {
                    sb.Append(name + ":[");
                    var firstInArray = true;
                    foreach (var arrayValue in (ArrayList)value)
                    {
                        if (!firstInArray)
                            sb.Append(",");
                        firstInArray = false;
                        if (arrayValue is IDictionary<string, object>)
                            new DynamicJsonObject((IDictionary<string, object>)arrayValue).ToString(sb);
                        else if (arrayValue is string)
                            sb.AppendFormat("\"{0}\"", arrayValue);
                        else
                            sb.AppendFormat("{0}", arrayValue);

                    }
                    sb.Append("]");
                }
                else
                {
                    sb.AppendFormat("{0}:{1}", name, value);
                }
            }
            sb.Append("}");
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            if (!_dictionary.TryGetValue(binder.Name, out result))
            {
                // return null to avoid exception.  caller can check for null this way...
                result = null;
                return true;
            }

            var dictionary = result as IDictionary<string, object>;
            if (dictionary != null)
            {
                result = new DynamicJsonObject(dictionary);
                return true;
            }

            var arrayList = result as ArrayList;
            if (arrayList != null && arrayList.Count > 0)
            {
                if (arrayList[0] is IDictionary<string, object>)
                    result = new List<object>(arrayList.Cast<IDictionary<string, object>>().Select(x => new DynamicJsonObject(x)));
                else
                    result = new List<object>(arrayList.Cast<object>());
            }

            return true;
        }
    }

    #endregion
}


string json = ...;

var serializer = new JavaScriptSerializer();
serializer.RegisterConverters(new[] { new DynamicJsonConverter() });

dynamic obj = serializer.Deserialize(json, typeof(object));

So, given a JSON string:
{
  "Items":[
    { "Name":"Apple", "Price":12.3 },
    { "Name":"Grape", "Price":3.21 }
  ],
  "Date":"21/11/2010"
}

The following code will work at runtime:
var data = serializer.Deserialize(json, typeof(object));

data.Date; // "21/11/2010"
data.Items.Count; // 2
data.Items[0].Name; // "Apple"
data.Items[0].Price; // 12.3 (as a decimal)
data.Items[1].Name; // "Grape"
data.Items[1].Price; // 3.21 (as a decimal)

Ref

http://stackoverflow.com/questions/3142495/deserialize-json-into-c-sharp-dynamic-object?answertab=votes#tab-top

JSON Examples

2013-05-20T01:08:00.002-07:00

JSON Examples

Array
Array typically consist of number, string, boolean, or null values and can also include nested arrays and nested objects. An array's elements are comma-delimited and are contained in brackets.

var newArray = [ "Text goes here", 29, true, null ]
var otherArray = [ [...], {...} ]
console.log( newArray[2] );true
Array with objects
This array consists of comma-delimited, nested objects which ceach ontain multiple key/value pairs- also comma-delimited. These objects can be accessed using the array's variable name and an index.

var newArray = [
{ "name": "Dagny Taggart", "age": 39 },
{ "name": "Francisco D'Anconia", "age": 40 },
{ "name": "Hank Rearden", "age": 46 }
]
console.log( newArray[0].name );Dagny Taggart
Object
This object consists of several key/value pairs. These 'properties' can be accessed using the the object's variable name followed by a period and property name -or- can be accessed like an array using the property name in quotes (in place of an index).

newObject = {
"first": "Jimmy",
"last": "James",
"age": 29,
"sex": "M",
"salary": 63000,
"registered": false
}
console.log( newObject.salary );63000

console.log( newObject["salary"] );63000
Object with nested array
This object contains comma-delimited key/value pairs and a nested array. The nested array can be accessed with the object name, property or 'key' containing the array and an array index.

newObject = {
"first": "John",
"last": "Doe",
"age": 39,
"sex": "M",
"salary": 70000,
"registered": true,
"interests": [ "Reading", "Mountain Biking", "Hacking" ]
}
console.log( newObject.interests[0] );Reading

console.log( newObject["interests"][0] );Reading
Object with nested object
This object contains multiple comma-delimited key/value pairs and a nested object. To access an object within an object, property names or 'keys' can be chained together -or- property names can be used like an array in place of indexes.

newObject = {
"first": "John",
"last": "Doe",
"age": 39,
"sex": "M",
"salary": 70000,
"registered": true,
"favorites": {
"color": "Blue",
"sport": "Soccer",
"food": "Spaghetti"
}
}
console.log( newObject.favorites.food );Spaghetti

console.log( newObject["favorites"]["food"] );Spaghetti
Object with nested arrays and objects
This object is more complex and typical of what might come from an API. It contains key/value pairs, nested arrays and nested objects. Any of its elements can be accessed with a combination of the above techniques.

newObject = {
"first": "John",
"last": "Doe",
"age": 39,
"sex": "M",
"salary": 70000,
"registered": true,
"interests": [ "Reading", "Mountain Biking", "Hacking" ],
"favorites": {
"color": "Blue",
"sport": "Soccer",
"food": "Spaghetti"
},
"skills": [
{
"category": "PHP",
"tests": [
{ "name": "One", "score": 90 },
{ "name": "Two", "score": 96 }
]
},
{
"category": "CouchDB",
"tests": [
{ "name": "One", "score": 32 },
{ "name": "Two", "score": 84 }
]
},
{
"category": "Node.js",
"tests": [
{ "name": "One", "score": 97 },
{ "name": "Two", "score": 93 }
]
}
]
}
console.log( newObject.skills[0].category );PHP

console.log( newObject["skills"][0]["category"] );PHP

console.log( newObject.skills[1].tests[0].score );32

console.log( newObject["skills"][1]["tests"][0]["score"] );32

Ref http://www.jsonexample.com/#array-with-objects

8 ways to query json structures

2013-05-20T00:02:00.004-07:00

8 ways to query json structures
Do you get bored by complex JSON structure traversing to find just a bunch of matching entries ?

Here are 8 different ways to do it :
JsonSQL

JsonSQL implements SQL select statements over json structures.

Example:

jsonsql.query("select * from json.channel.items order by title desc",json);

Homepage: http://www.trentrichardson.com/jsonsql/
JSONPath

JSONPath is like XPath for JSON structures.

Example :

jsonPath( books, '$..book[(@.length-1)]')

Homepage: http://goessner.net/articles/JsonPath/
jfunk

jFunk will allow you to retrieve (and soon, manipulate) objects within complex JSON or Javascript objects. The design of the jFunk API will closely parallel the jQuery API, replicating it exactly except where the differences between DOM and Javascript make replication nonsensical

Example:

Jf("> vegetables > *[color=Orange]",Food).get();

Homepage: http://code.google.com/p/jfunk/
TaffyDB

How you ever noticed how JavaScript object literals look a lot like records? And that if you wrap a group of them up in an array you have something that looks a lot like a database table? TaffyDB is a libary to bring powerful database funtionality to that concept and rapidly improve the way you work with data inside of JavaScript.

var kelly = friends({id:2}).first();

Homepage: http://www.taffydb.com/
linq.js

linq.js - LINQ for JavaScript

var queryResult2 = Enumerable.From(jsonArray)
.Where("$.user.id < 200")
.OrderBy("$.user.screen_name")
.Select("$.user.screen_name + ':' + $.text")
.ToArray();
Homepage: http://linqjs.codeplex.com/

Homepage: http://neue.cc/reference.htm
objeq

objeq is a simple library that allows POJSO's (Plain-Old JavaScript Objects) to be queried in real-time.
var res = $objeq(data, "age > 40 && gender == 'female' -> name");
// --> Returns ['Jessica']
Homepage: https://github.com/agilosoftware/objeq
json:select()

CSS-like selectors for JSON.

.lang:val("Bulgarian") ~ .level

Homepage: http://jsonselect.org/#tryit
Javascript Array Filtering from Paul's Programming Pearls

var a = [1,2,3,4,5,6,7,8,9,10];
// return everything
a.where( "( ) => true" ) ;
--> [1,2,3,4,5,6,7,8,9,10]
// return even numbers
a.where( "( n, i ) => n % 2 == 0" ) ;
--> [2,4,6,8,10]
// query first 6 products whose category begins with 'con' using extra param and regular expression
products.where( "( el, i, res, param ) => res.length <= 6 && param.test( el.cat )", /^con/i);
// using customer table data from SQL Server's northwind database...
customers.where( "( el, i, res, param ) => el.country == param", "USA" );

Homepage: http://www.paulfree.com/28/javascript-array-filtering/#more-28

Javascript Array Filtering from Paul's Programming Pearls is currently my favorite - its extremely small footprint and blazing fast result speak for itself.

The idea behind is similar to John Resig's JavaScript Micro-Templating effort - a very simple piece of code transforming a string into a Javascript function utilizing Regexp power.

Yes, sure - there are more powerful solutions in the list. Paul's implementation prototype lacks syntax checking of the filter expression but I am sure you can handle javascript syntax checking by yourself.

At the end you must decide which one is best for your project.

Chromium debugger

2013-05-06T05:24:00.003-07:00

don't know what version of Chrome you're using. I'm using Chromium 17 and the Javascript debugger looks like this when hitting a breakpoint (emphasis mine):

Immediate window

2013-05-06T05:06:00.002-07:00

One nice feature of the Immediate Window in Visual Studio is its ability to evaluate the return value of a method particularly if it is called by your client code but it is not part of a variable assignment. In Debug mode, as mentioned, you can interact with variables and execute expressions in memory which plays an important role in being able to do this.

For example, if you had a static method that returns the sum of two numbers such as:

private static int GetSum(int a, int b)
{
return a + b;
}
Then in the Immediate Window you can type the following:

? GetSum(2, 4)
6
As you can seen, this works really well for static methods. However, if the method is non-static then you need to interact with a reference to the object the method belongs to.

For example, let’s say this is what your class looks like:

private class Foo
{
public string GetMessage()
{
return "hello";
}
}
If the object already exists in memory and it’s in scope, then you can call it in the Immediate Window as long as it has been instantiated before your current breakpoint (or, at least, before wherever the code is paused in debug mode):

? foo.GetMessage(); // object ‘foo’ already exists
"hello"
In addition, if you want to interact and test the method directly without relying on an existing instance in memory, then you can instantiate your own instance in the Immediate Window:

? Foo foo = new Foo(); // new instance of ‘Foo’
{temp.Program.Foo}
? foo.GetMessage()
"hello"
You can take it a step further and temporarily assign the method's results to variables if you want to do further evaluations, calculations, etc.:

? string msg = foo.GetMessage();
"hello"
? msg + " there!"
"hello there!"
Furthermore, if you don’t even want to declare a variable name for a new object and just want to run one of its methods/functions then do this:

? new Foo().GetMessage()
"hello"
A very common way to see the value of a method is to select the method name of a class and do a ‘Add Watch’ so that you can see its current value in the Watch window. However, once again, the object needs to be instantiated and in scope for a valid value to be displayed. This is much less powerful and more restrictive than using the Immediate Window.

Along with inspecting methods, you can do simple math equations:

? 5 * 6
30
or compare values:

? 5==6
false
? 6==6
true
The question mark ('?') is unnecessary if you are in directly in the Immediate Window but it is included here for clarity (to distinguish between the typed in expressions versus the results.) However, if you are in the Command Window and need to do some quick stuff in the Immediate Window then precede your statements with '?' and off you go.

Intellisense works in the Immediate Window, but it sometimes can be a bit inconsistent. In my experience, it seems to be only available in Debug mode, but not in design, non-debug mode.

Unfortunately, another drawback of the Immediate Window is that it does not support loops.

Practical Dependency Injection

2013-04-23T04:32:00.007-07:00

Practical Dependency Injection 101

by EFVINCENT on 05/27/2011

In this post we take a look at dependency injection (DI). Target audience is competent .NET developers, C# specifically (but VB’ers who read C# can benefit just as much), who’ve heard of DI but haven’t gotten around to figuring out how it fits in their day to day.

What is Dependency Injection

The first question that we need to address is: What is it that DI does for us? What problem is being solved? DI is about coupling; the degree to which program unit refers to other units. In .NET the units we’re typically worried about are classes, interfaces, components, and assemblies. Dependency injection facilitates reduction these interdependencies. Are DI patterns a silver bullet? Of course not. You can always write bad code regardless of patterns. That being said, if you’re already writing decent code and have good fundamentals, but are not using DI patterns, you’ve got the opportunity to take a leap forward.

How does DI reduce help reduce coupling? The easiest way to describe it is by diving directly into an example.

Example Scenario

We’ll work on a hypothetical in-house app where the Windows AD authenticates employees, and their Windows username is used to index a database with Employee information. It’s pretty common to see stuff like this happening in-house with line of business applications.

The example uses a provider pattern – all the data access will go through a data access provider, allowing us to build a simple provider that stores records in memory during this, our prototype phase. Theoretically we’d replace this as development continued with a provider that leverages persistent storage later.

Here’s the base level example program with no consideration for dependency injection:

class Program {

static void Main(string[] args) {

 

// ** Without using an DI Container approach **

 

// Create a new provider aka data access layer

var dal = new DevDataProvider();

 

// New up an employee that's supposed to represent the currently logged in user

var e = new Employee() {

WindowsUsername = "thanos\\efvincent",

EmployeeId = "0001",

FName = "Eric",

LName = "Vincent"

};

 

// Add it to the data access layer

dal.AddEmployee(e);

 

// See if the dal can find the current user

e = dal.GetCurrentEmployee();

 

Console.WriteLine(

"Current logged in person is: {0}", e == null ? "unknown" : e.FName);

 

// End

Console.Write("Press any key...");

Console.ReadKey(true);

 

}

}

 

public class DevDataProvider {

private static readonly List<Employee> EmployeeStore = new List<Employee>();

 

public Employee GetCurrentEmployee() {

var emp = EmployeeStore.FirstOrDefault(

e => e.WindowsUsername.Equals(GetCurrentUserName(), StringComparison.OrdinalIgnoreCase));

return emp;

}

 

public void AddEmployee(Employee e) {

EmployeeStore.Add(e);

}

 

public IQueryable<Employee> Employees() {

return EmployeeStore.AsQueryable();

}

 

private static string GetCurrentUserName() {

var wu = WindowsIdentity.GetCurrent();

return wu == null ? string.Empty : wu.Name;

}

}

 

public class Employee {

public string WindowsUsername { get; set; }

public string EmployeeId { get; set; }

public string FName { get; set; }

public string LName { get; set; }

}

In Main() we new up the data access layer, create a new employee, and add it to our store using the data access layer. At line 21 we ask the data access layer to retrieve the employee record for the currently logged in user. Looks pretty typical, so how can IoC help? Let’s look at the coupling here – what classes are dependent on what other classes?

Our main program depends on the DevDataProvider class, and that depends on System.Security to find the Windows username of the currently logged in user. Asking the data access layer to determine the currently logged in user isn’t the best idea, but this is blog post code created to check out dependency injection, so deal with that for the moment.

Why are these dependencies undesirable? First consider how flexible this software is. Or rather, inflexible. We created a “quick” DevDataProvider that stores stuff in a static list. As we continue to build a system, we’d have to refer to DevDataProvider from more and more classes, creating a brittle, tightly coupled system. Replacing DevDataProvider becomes more of a maintenance problem.

Next think about testability. In real life there are unit tests (there should be anyway). One reason why people find excuses not to unit test is because their code is difficult to test. In this example, if we want to test DevDataProvider.GetCurrentEmployee() we have to consider that under the covers it’s calling the Windows API to get the current username. This makes that method harder to than it needs to be.

Step One – Leveraging Interfaces

In this version, we’ve factored out an interface called IDataProvider, and one called IIdentService. The IDataProvider should be pretty obvious – but IIdentService? The idea here is to decouple from the Windows API itself. A developer should understand everywhere that the application makes contact with any external modules, including the operating system, and then consider what the repercussions of that contact are. In this example, coupling to the Windows API to get then logged in username so directly is undesirable. We want to use a service that would supply us with credentials. That way if we’re testing, we can create a fake service that provides a predictable answer, and is therefore easier to test.

Coding to an interface also allows us to radically change the behavior of the service without having to alter its dependencies. If we move to a ASP.NET environment for example, we won’t want to use the current Windows Identity, we may want to use user information from the http context.

// Interface defining an identity service

public interface IIdentService {

string GetCurrentUserName();

}

 

// Implementation of an identity service that returns the current

// logged in windows username

public class WindowsIdentService : IIdentService {

public string GetCurrentUserName() {

var wu = WindowsIdentity.GetCurrent();

return wu == null ? string.Empty : wu.Name;

}

}

 

// Interface defining a data provider service

public interface IDataProvider {

Employee GetCurrentEmployee();

void AddEmployee(Employee e);

IQueryable<Employee> Employees();

}

 

// Our development data provider now implements the interface

public class DevDataProvider : IDataProvider {

private readonly IIdentService _identService;

private static readonly List<Employee> EmployeeStore = new List<Employee>();

 

public DevDataProvider(IIdentService identService) {

if (identService == null) throw new ArgumentNullException("identService");

_identService = identService;

}

 

public Employee GetCurrentEmployee() {

var emp = EmployeeStore.FirstOrDefault(

e => e.WindowsUsername.Equals(

_identService.GetCurrentUserName(),

StringComparison.OrdinalIgnoreCase));

return emp;

}

 

public void AddEmployee(Employee e) {

EmployeeStore.Add(e);

}

 

public IQueryable<Employee> Employees() {

return EmployeeStore.AsQueryable();

}

}

We’re part of the way to where we need to be. Altering DevDataProvider to depend on the IIdentService interface frees it from a hard dependency on a particular identity implementation. The downside is we’ve made creation of the DevDataProvider a bit more complex, as we need to supply the new instance with an IIdentityService instance.

// Create a new ident service, required for the DAL

IIdentService identSvc = new WindowsIdentService();

 

// Create a new DAL

IDataProvider dal = new DevDataProvider(identSvc);

The DevDataProvider now takes a constructor parameter of type IIdentService. This is where the injection in dependency injection comes from. DevDataProvider has a dependency, but instead of hard coding it into the definition of DevDataProvider, we inject it. There are different ways of injecting dependencies, but constructor injection is very popular and works well in many, or even most cases.

The complexity of constructing instances increases when we add a simple logging service which logs information or errors messages.

// Interface defining a logging service

public interface ILogService {

void LogInfo(string msg, params object[] args);

void LogError(string msg, params object[] args);

}

 

// Implementation of a console logging service

public class ConsoleLogger : ILogService {

public void LogInfo(string msg, params object[] args) {

Console.WriteLine(

"{0} INFO: {1}", DateTime.Now,

string.Format(msg, args));

}

 

public void LogError(string msg, params object[] args) {

Console.WriteLine(

"{0} ERROR: {1}", DateTime.Now,

string.Format(msg, args));

}

}

The ILogService is implemented by a simple console logger. Now both the WindowsIdentService and the DevDataProvider can leverage the logger. They’re both modified to have ILogService instance injected via their respective constructors.

// Implementation of an identity service that returns the current

// logged in windows username

public class WindowsIdentService : IIdentService {

private readonly ILogService _logSvc;

 

public WindowsIdentService(ILogService logSvc) {

if (logSvc == null) throw new ArgumentNullException("logSvc");

_logSvc = logSvc;

}

 

public string GetCurrentUserName() {

var wu = WindowsIdentity.GetCurrent();

var un = wu == null ? string.Empty : wu.Name;

_logSvc.LogInfo("Identified current user as: {0}", un);

return un;

}

}

 

// Our development data provider now implements the interface

public class DevDataProvider : IDataProvider {

private readonly IIdentService _identService;

private readonly ILogService _logSvc;

private static readonly List<Employee> EmployeeStore = new List<Employee>();

 

public DevDataProvider(IIdentService identService, ILogService logSvc) {

if (identService == null) throw new ArgumentNullException("identService");

if (logSvc == null) throw new ArgumentNullException("logSvc");

_identService = identService;

_logSvc = logSvc;

}

 

public Employee GetCurrentEmployee() {

var un = _identService.GetCurrentUserName();

var emp = EmployeeStore.FirstOrDefault(

e => e.WindowsUsername.Equals(un,

StringComparison.OrdinalIgnoreCase));

if (emp == null) _logSvc.LogInfo("Current employee {0} not found", un);

return emp;

}

 

public void AddEmployee(Employee e) {

EmployeeStore.Add(e);

_logSvc.LogInfo("Added employee with id {0}", e.EmployeeId);

}

 

public IQueryable<Employee> Employees() {

return EmployeeStore.AsQueryable();

}

}

Now the services are getting more robust and they’re not tightly coupled to each other, they refer only to interfaces of the services they depend on. Main() however, where construction is going on, is getting messy.

static void Main(string[] args) {

 

// ** Without using an DI Container approach **

 

// Create a new logging service, required for uh.. everything

ILogService consoleLog = new ConsoleLogger();

 

// Create a new ident service, required for the DAL

IIdentService identSvc = new WindowsIdentService(consoleLog);

 

// Create a new DAL

IDataProvider dal = new DevDataProvider(identSvc, consoleLog);

Finally we’re at the point where we can see the benefit of an dependency injection container. One thing about DI containers is that they’re already written. Several mature, robust, open-source DI containers exist. We’ll use AutoFac, because that’s what I’ve been using lately. We include AutoFac using NuGet.

// Create a singleton dependency injection container

private static readonly IContainer Container = ConfigureContainer();

 

// Configure the container

static IContainer ConfigureContainer() {

// This is how AutoFac works. Other DI containers have similar

// mechanisms for configuring the container

var bld = new ContainerBuilder();

 

// Register the types that implement the interfaces that are required

// for injection. Note that we have robust control over lifetime, in

// this case ILogService and IIdentService will be singletons, and

// IDataProvider will provide a new instance each time it's requested

bld.RegisterType<ConsoleLogger>().As<ILogService>().SingleInstance();

bld.RegisterType<WindowsIdentService>().As<IIdentService>().SingleInstance();

bld.RegisterType<DevDataProvider>().As<IDataProvider>();

return bld.Build();

}

 

static void Main(string[] args) {

 

// ** Using an IoC Container approach **

var dal = Container.Resolve<IDataProvider>();

We’ve created a static instance of IContainer (an AutoFac DI container). When we start the app we configure the container, which fundamentally consists of mapping the interfaces to concrete types that will be injected. For example, line 14 specifies that when there’s a need for an instance of ILogService, we will create an instance of ConsoleLogger. It further says that the DI container should use a SingleInstance() of ConsoleLogger. This has the effect of making ConsoleLogger a singleton. In our example, both the WindowsIdentService and the DevDataProvider will be handed the same instance of ConsoleLogger.

The magic happens when we call Container.Resolve<IDataProvider>(). The container determines what concrete class to create, and it looks for any dependencies in the constructor. It will see that to build a DevDataProvider, it needs an ILogService and an IWindowsIdentService, it will recursively resolve those as well.

These are the basics of dependency injection. Even in this simple example, it should be obvious that the components and classes that we can create can be designed with very low coupling and cohesion using this technique. There are anti-patterns for using DI as well. You should endeavor to practice this technique, do research and learn the most effective uses; there’s plenty of material out there.

I hope this example was helpful. Next post I’ll extend this sample by looking at testing, and mock objects, and how DI injection can make testing far easier.

Source code samples can be found at this bitbucket repository.

Update: Follow up post – Dependency Injection, Testing, and Mocking

ShareThis

Tagged as: AutoFac, basics, C#, CSharp

{ 1 trackback }

A Taste of Dependency Injection, Testing, and Mocking: 06/02/2011 at 1:46 pm

{ 4 comments… read them below or add one }

Sivakumar M 12/19/2011 at 1:07 am: Thanks for your post. It is a simple good practical example for anyone to relate to their daily work.
Kamal 12/07/2012 at 1:20 pm: Its a simple and easy to understand article. Well explained!!!!
Gary 01/31/2013 at 4:27 pm: good job thanks!
Martix 03/20/2013 at 5:03 pm: nice and clean article, thanks

Practical Dependency Injection 101

2013-04-23T04:32:00.003-07:00

Practical Dependency Injection 101

by EFVINCENT on 05/27/2011

What is Dependency Injection

How does DI reduce help reduce coupling? The easiest way to describe it is by diving directly into an example.

Example Scenario

Here’s the base level example program with no consideration for dependency injection:

class Program {

static void Main(string[] args) {

 

// ** Without using an DI Container approach **

 

// Create a new provider aka data access layer

var dal = new DevDataProvider();

 

// New up an employee that's supposed to represent the currently logged in user

var e = new Employee() {

WindowsUsername = "thanos\\efvincent",

EmployeeId = "0001",

FName = "Eric",

LName = "Vincent"

};

 

// Add it to the data access layer

dal.AddEmployee(e);

 

// See if the dal can find the current user

e = dal.GetCurrentEmployee();

 

Console.WriteLine(

"Current logged in person is: {0}", e == null ? "unknown" : e.FName);

 

// End

Console.Write("Press any key...");

Console.ReadKey(true);

 

}

}

 

public class DevDataProvider {

private static readonly List<Employee> EmployeeStore = new List<Employee>();

 

public Employee GetCurrentEmployee() {

var emp = EmployeeStore.FirstOrDefault(

e => e.WindowsUsername.Equals(GetCurrentUserName(), StringComparison.OrdinalIgnoreCase));

return emp;

}

 

public void AddEmployee(Employee e) {

EmployeeStore.Add(e);

}

 

public IQueryable<Employee> Employees() {

return EmployeeStore.AsQueryable();

}

 

private static string GetCurrentUserName() {

var wu = WindowsIdentity.GetCurrent();

return wu == null ? string.Empty : wu.Name;

}

}

 

public class Employee {

public string WindowsUsername { get; set; }

public string EmployeeId { get; set; }

public string FName { get; set; }

public string LName { get; set; }

}

Step One – Leveraging Interfaces

// Interface defining an identity service

public interface IIdentService {

string GetCurrentUserName();

}

 

// Implementation of an identity service that returns the current

// logged in windows username

public class WindowsIdentService : IIdentService {

public string GetCurrentUserName() {

var wu = WindowsIdentity.GetCurrent();

return wu == null ? string.Empty : wu.Name;

}

}

 

// Interface defining a data provider service

public interface IDataProvider {

Employee GetCurrentEmployee();

void AddEmployee(Employee e);

IQueryable<Employee> Employees();

}

 

// Our development data provider now implements the interface

public class DevDataProvider : IDataProvider {

private readonly IIdentService _identService;

private static readonly List<Employee> EmployeeStore = new List<Employee>();

 

public DevDataProvider(IIdentService identService) {

if (identService == null) throw new ArgumentNullException("identService");

_identService = identService;

}

 

public Employee GetCurrentEmployee() {

var emp = EmployeeStore.FirstOrDefault(

e => e.WindowsUsername.Equals(

_identService.GetCurrentUserName(),

StringComparison.OrdinalIgnoreCase));

return emp;

}

 

public void AddEmployee(Employee e) {

EmployeeStore.Add(e);

}

 

public IQueryable<Employee> Employees() {

return EmployeeStore.AsQueryable();

}

}

// Create a new ident service, required for the DAL

IIdentService identSvc = new WindowsIdentService();

 

// Create a new DAL

IDataProvider dal = new DevDataProvider(identSvc);

The complexity of constructing instances increases when we add a simple logging service which logs information or errors messages.

// Interface defining a logging service

public interface ILogService {

void LogInfo(string msg, params object[] args);

void LogError(string msg, params object[] args);

}

 

// Implementation of a console logging service

public class ConsoleLogger : ILogService {

public void LogInfo(string msg, params object[] args) {

Console.WriteLine(

"{0} INFO: {1}", DateTime.Now,

string.Format(msg, args));

}

 

public void LogError(string msg, params object[] args) {

Console.WriteLine(

"{0} ERROR: {1}", DateTime.Now,

string.Format(msg, args));

}

}

// Implementation of an identity service that returns the current

// logged in windows username

public class WindowsIdentService : IIdentService {

private readonly ILogService _logSvc;

 

public WindowsIdentService(ILogService logSvc) {

if (logSvc == null) throw new ArgumentNullException("logSvc");

_logSvc = logSvc;

}

 

public string GetCurrentUserName() {

var wu = WindowsIdentity.GetCurrent();

var un = wu == null ? string.Empty : wu.Name;

_logSvc.LogInfo("Identified current user as: {0}", un);

return un;

}

}

 

// Our development data provider now implements the interface

public class DevDataProvider : IDataProvider {

private readonly IIdentService _identService;

private readonly ILogService _logSvc;

private static readonly List<Employee> EmployeeStore = new List<Employee>();

 

public DevDataProvider(IIdentService identService, ILogService logSvc) {

if (identService == null) throw new ArgumentNullException("identService");

if (logSvc == null) throw new ArgumentNullException("logSvc");

_identService = identService;

_logSvc = logSvc;

}

 

public Employee GetCurrentEmployee() {

var un = _identService.GetCurrentUserName();

var emp = EmployeeStore.FirstOrDefault(

e => e.WindowsUsername.Equals(un,

StringComparison.OrdinalIgnoreCase));

if (emp == null) _logSvc.LogInfo("Current employee {0} not found", un);

return emp;

}

 

public void AddEmployee(Employee e) {

EmployeeStore.Add(e);

_logSvc.LogInfo("Added employee with id {0}", e.EmployeeId);

}

 

public IQueryable<Employee> Employees() {

return EmployeeStore.AsQueryable();

}

}

static void Main(string[] args) {

 

// ** Without using an DI Container approach **

 

// Create a new logging service, required for uh.. everything

ILogService consoleLog = new ConsoleLogger();

 

// Create a new ident service, required for the DAL

IIdentService identSvc = new WindowsIdentService(consoleLog);

 

// Create a new DAL

IDataProvider dal = new DevDataProvider(identSvc, consoleLog);

// Create a singleton dependency injection container

private static readonly IContainer Container = ConfigureContainer();

 

// Configure the container

static IContainer ConfigureContainer() {

// This is how AutoFac works. Other DI containers have similar

// mechanisms for configuring the container

var bld = new ContainerBuilder();

 

// Register the types that implement the interfaces that are required

// for injection. Note that we have robust control over lifetime, in

// this case ILogService and IIdentService will be singletons, and

// IDataProvider will provide a new instance each time it's requested

bld.RegisterType<ConsoleLogger>().As<ILogService>().SingleInstance();

bld.RegisterType<WindowsIdentService>().As<IIdentService>().SingleInstance();

bld.RegisterType<DevDataProvider>().As<IDataProvider>();

return bld.Build();

}

 

static void Main(string[] args) {

 

// ** Using an IoC Container approach **

var dal = Container.Resolve<IDataProvider>();

I hope this example was helpful. Next post I’ll extend this sample by looking at testing, and mock objects, and how DI injection can make testing far easier.

Source code samples can be found at this bitbucket repository.

Update: Follow up post – Dependency Injection, Testing, and Mocking

ShareThis

Tagged as: AutoFac, basics, C#, CSharp

{ 1 trackback }

A Taste of Dependency Injection, Testing, and Mocking: 06/02/2011 at 1:46 pm

{ 4 comments… read them below or add one }

Sivakumar M 12/19/2011 at 1:07 am: Thanks for your post. It is a simple good practical example for anyone to relate to their daily work.
Kamal 12/07/2012 at 1:20 pm: Its a simple and easy to understand article. Well explained!!!!
Gary 01/31/2013 at 4:27 pm: good job thanks!
Martix 03/20/2013 at 5:03 pm: nice and clean article, thanks

Decoding Asp.net , Asp.net MVC, SQL Server ,Firebird,Jquery,JavaScript

Using C# 4.0 and dynamic to parse JSON

String to Json

Evaluating JavaScript code from C#

Parent Child in MVC

html elements find all css

Database to Object

Form Submit as JSON

Consuming JSON Strings in SQL Server

Background

JSON format.

The implementation

ToJSON. A function that creates JSON Documents

ToXML. A function that creates XML

Wrap-up

Improve SQL Server query to convert arbitrary table to JSON

Here a Simple way to get json from Sql server 2008

DynamicJsonConverter

JSON Examples

8 ways to query json structures

Chromium debugger

Immediate window

Practical Dependency Injection

Practical Dependency Injection 101

What is Dependency Injection

Example Scenario

Step One – Leveraging Interfaces

Meta

Practical Dependency Injection 101

Practical Dependency Injection 101

What is Dependency Injection

Example Scenario

Step One – Leveraging Interfaces

Meta