I was completely unaware of the SQL Server “ghost records” until recently I’ve started using a table in SQL Server database to temporarily store and then delete generated PDF documents as part of a nightly job. Because of a large amount of data being processed (inserted and then deleted) few days later our DBA realized that the database data files started growing in a rhythm of 10GB per day without any apparent reasons.

What is a Ghost Record

“Ghost Records” are records that have been logically but not physically deleted from the leaf level of an index. Such a delete operation never physically removes records from pages but it only marks them as having been deleted, or ghosted!

Ghost Records have been introduced as a performance optimization that makes the delete operations quicker. Rolling back delete operations are quicker because the only things that needs to happen is to un-mark the records as being deleted/ghosted, instead of having to reinsert the deleted records.

Ghost Records removal

There are several ways of cleaning out the ghost records, among which :

1. If a new record that has the same key value as the deleted record is re-inserted in a table
2. The Ghost cleanup task (scheduled to run once every 5 seconds)
3. If the page needs to be split, the ghost records will be handled

In my case, because the database in question is SQL Server 2005, the most effective way of cleaning up the database was:

1. Drop and recreate the table (very ugly!)
2. Shrink the database
3. Rebuild indexes
4. Recompile all of the stored procedures (for quicker response time after shrinking)

The recommended way to do this is to rebuild indexes on table that has problems, but for unknown reason this didn’t work properly for me.

How to find out about ghost records

SELECT	ghost_record_count ,
        version_ghost_record_count , 
        *
FROM	sys.dm_db_index_physical_stats(DB_ID('DATABASE_NAME_HERE'),
        OBJECT_ID('TABLE_NAME_HERE'), NULL, NULL, 'DETAILED')

Columns: ghost_record_count and version_ghost_record_count will indicate a number of ghost records associated with the given database table.

Final thoughts

The topic is quite deep and unfortunately not so well documented, so I collected some useful urls that could be of benefit posted below.
I think that it worth trying and checking if your database is affected by this, especially if you see the database growing for unknown reason.

Further reads:

1. http://blogs.msdn.com/b/sqlserverstorageengine/archive/2006/06/23/644607.aspx
2. http://www.sqlservergeeks.com/articles/sql-server-bi/14/ghost-records-in-sql-server-now-whats-that
3. http://www.sqlskills.com/blogs/paul/inside-the-storage-engine-ghost-cleanup-in-depth/
4. http://sqlserverpedia.com/blog/sql-server-service-internals-and-architecture/164/

After quite a long time there is a small update on the Google DataTable .NET Wrapper library.

For those who are new to the library please check the two previous posts:

• How to use the Google DataTable .Net Wrapper Library
• What’s new in Google DataTable .NET Wrapper v3.0.0

What is new?

First of all I would like to thank Tom Ziesmer who has substantially contributed the code and ideas (suggestiongs) of this minor release.

IEnumerable converter to DataTable

Tom was very kind to contribute his code for the new extension method.
The extension method is mainly responsible for transforming any kind of IEnumerable object into the Google.DataTable.Net.Wrapper.DataTable object.
It equally works with anonymous as with strongly typed kind of IEnumerable objects.

The example below is showing how to use the new extension method that is part of the new namespace Google.DataTable.Net.Wrapper.Extension

var list = new[]
                {
                    new {Name = "Dogs", Count = 5},
                    new {Name = "Cats", Count = 2}
                };

var json = list.ToGoogleDataTable()
               .NewColumn(new Column(ColumnType.String, "Name"), x => x.Name)
               .NewColumn(new Column(ColumnType.Number, "Count"), x => x.Count)
               .Build()
               .GetJson();

this generates the following output:

{
"cols": [
	    {"type": "string", "id": "Name"},
	    {"type": "number", "id": "Count"}
	],

"rows": [
	    {"c": [{ "v": "Dogs" }, {"v": 5}]},
	    {"c": [{ "v": "Cats" }, {"v": 2}]}
	]
}

The NewColumn method offers a great way of customizing the output. But in case there is an object that is already “ready” to be used then the same result can be obtained by not calling the “NewColumn” method at all

var list = new[]
                {
                    new {Name = "Dogs", Count = 5},
                    new {Name = "Cats", Count = 2}
                };

var json = list.ToGoogleDataTable()
               //.NewColumn(new Column(ColumnType.String, "Name"), x => x.Name)
               //.NewColumn(new Column(ColumnType.Number, "Count"), x => x.Count)
               .Build()
               .GetJson();

produces the following output, which is substantially the same as the one above.

{
"cols": [
		{"type": "string","id": "Name", "label": "Name" },
		{"type": "number","id": "Count","label": "Count"}
	],
"rows": [
		{ "c": [{"v": "Dogs"},{"v": 5}]},
		{ "c": [{"v": "Cats"},{	"v": 2}]}
	]
}

System.Data.DataTable extension method

As shown in the below example, a new extension method for System.Data.DataTable has been introduced. This is mainly a wrapper to the existing SystemDataTableConverter, but is just handier to use.
This code demonstrate it’s usage:

using (var sysDt = new System.Data.DataTable())
{
    sysDt.Columns.Add("firstcolumn", typeof(string));
    sysDt.Columns.Add("secondcolumn", typeof(int));
    sysDt.Columns.Add("thirdcolumn", typeof(decimal));
    sysDt.Locale = CultureInfo.InvariantCulture;

    var row1 = sysDt.NewRow();
    row1[0] = "Ciao";
    row1[1] = 10;
    row1[2] = 2.2;
    sysDt.Rows.Add(row1);

    var dataTable = sysDt.ToGoogleDataTable();    
    
    var json = dataTable.GetJson();
}

How to install

To download or consult the latest source code please visit the project’s CodePlex page or install it directly from Visual Studio by using Nuget

Contribute

This project is open for contribution and new ideas, so you are very welcome to contact me!

Software Development is so many things; to have a good start creativity, passion and methodology have to be a perfect match.

While the creativity and the passion are subjective and personal, the methodology is something that can be learnt, developed, enhanced and shared. Like mathematics, it can be seen as an universal language.

Principles

When developing software there are some best-practices and principles that should be followed so that every software developer should be able to read and understand the application quite quickly.
In general, the principles, when applied, should be able to (and not only)

1. minimize maintenance requirements
2. minimizes costs
3. promote usability and extensibility
4. promote testability and correctness of the application

Some of the key principles are as follows:

Separation of concerns

Expressed in a simple sentence: “Divide your application into distinct sections with as little overlap in functionality as possible.”. Easy to say, difficult to achieve.
Separation of Concerns is one of the fundamental tenants in object oriented programming and, when applied correctly, promotes loose coupling and high cohesion, which are two very important principles to be aware of.

Separating the application into several layers, is already a good start, but then one should also follow the same principle into each of the layers. Presentation layer shouldn’t do what Data Access Layer does and vice-versa. For instance Domain Driven Design helps and promotes the separation of concerns.

Single Responsibility principle

The term was introduced by Robert C. Martin. Martin defines a responsibility as a reason to change, and concludes that a class or module should have one, and only one, reason to change.

In the (very simple) example below it is pretty much clear that the GetCustomerById() shouldn’t be par of the Person class.

public class Person
{
    public Person GetPersonById(){/*...*/}
    public Customer GetCustomerById(){/*...*/}
}

This should be a much better design:

public class Person
{
    public Person GetPersonById(){/*...*/}
}

public class Customer
{
    public Customer GetCustomerById(){/*...*/}
}

Principle of Least Knowledge

(also known as the Law of Demeter or LoD).

A component or object should not know about internal details of other components or objects.

Example:

//this should be avoided:
    customer.wallet.totalMoney;
    customer.apartment.bedroom.mattress.totalMoney;
    customer.apartment.kitchen.kitchenCabinet.totalMoney;

//instead this could be an idea of usage.
    customer.GetPayment(/*...*/)

Check this amazing paper that explains in detail what is the Law of Demeter all about.

Don’t repeat yourself (DRY)

You should only need to specify intent in one place. When the DRY principle is applied successfully, a modification of any single element of a system does not require a change in other unrelated elements. Additionally, elements that are logically related all change predictably and uniformly, and are thus kept in sync.

Minimize upfront design

This principle is sometimes known as YAGNI (“You ain’t gonna need it”) and it’s about designing only what is strictly necessary in order to achieve the goal.
A good example is the incremental development, where the system get’s enriched “on going” rather than planned (heavily) upfront, as during the application lifecycle the requirements often change too often.
In Agile development, you can avoid big design upfront (BDUF). If your application requirements are unclear, or if there is a possibility of the design evolving over time, avoid making a large design effort prematurely.

Final Thoughts

As usually, I just scratched the surface of the issue and there are many more items to add, but that could be part of another post.
I invite you to read about the above concepts as it would improve your application.

In one of my earlier posts I tried to describe what kind of attributes a leader should have to be successful, and in this post I would like to go a big further and try to define what should make an IT project a success.

Wikipedia says that

In project management a project consists of a temporary endeavor undertaken to create a unique product, service or result.

By reading the above definition, there are two ingredients that define a project:

1. A project is a temporary action, therefore every project has a start and an end.
2. It has an output: product, service or a result

A perfect project

Let’s start with some statistics:

This chart data is based upon The Standish Group report. The Standish Group is a Massachusetts-based consultancy responsible for publishing the CHAOS reports since 1994. The reports are based on studies of IT projects and track the success, challenged and failure outcomes of each project.

It’s not hard to see that in average, since 1994 “only” ~27% of all the project is successful. In other words, there is a higher chance that your project is not going to be successful than that it would. Which is scary.

Project Management

Usually, a project is run by a project manager and the typical project manager has lots of responsibility and very little authority, which implies that the person that runs the project in cannot fully control it. A project plan in this circumstances can but not necessarily does represent the reality.
Under these conditions, to run and to achieve a successful outcome can be really challenging.

So, what would be the common project “attributes” that would make project “a success”?

There is a list of goals that every project would need to meet in order to be a success:

1. Meet the business requirements
2. Deliver and maintain on schedule
3. Delivered and maintained within budget, and
4. Deliver the expected business value and return on investment.

Needless to say that one has to work really hard in order to achieve all the objectives. In order to achieve the points of the above list, there are some best-practices* should be followed and that could help the positive outcome of the project.

1. Clear and clearly articulated goals
2. Comprehensive, long-term, planning, when possible
3. Early definition of deliverable quality criteria
4. Active executive support with a shared vision throughout the project’s life
5. Carefully planned implementation
6. Concise, consistent, complete, and unambiguous business and technical requirements
7. Realistic estimates and schedules
8. Early risk analysis and ongoing risk management
9. Planning for business process change management
10. Proactive issue resolution
11. Stakeholder involvement throughout the life cycle
12. Defined and consistently executed change management to minimize scope increases
13. A skilled Project Manager experienced in the execution of project management best practices
14. Standard software infrastructure
15. Execution of a formal system development methodology (such as the State’s System Development Life Cycle)
16. A competent team
17. Commitment to success

The above points are taken from the Marylend’s Department of Technology and could be downloaded by following this link.

Agile Project Management

An alternative to the “classical” project management is ,now not so new, agile project management, that I really believe is the “right thing” if adopted correctly. I am mentioning the Agile Project Management as I believe that is more suitable for a modern and a dynamic way of managing projects, at least when it comes to the IT industry, where I’ve got most of my experience.

In one sentence, if that’s even possible, what is the definition of the agile project management:

Agile project management is a value-driven approach that allows Project Managers to deliver high-priority, high-quality work–and look like rock stars to their stakeholders. It’s nothing like the plodding, costly and error-prone approach to project management, which has delivered inconsistent results for years…

Agile Project Management reduces complexity by breaking down the many months long cycle of building requirements for the whole project, building the entire product and then testing to find hundreds of product flaws. Instead, small usable segments of the software product are specified, developed and tested in manageable, two to four week cycles.
– Source: http://www.versionone.com/agile-project-management/

So, instead of having long running projects, with an unknown outcome, let’s have smaller chunks of perfectly managed iterations that would lead to a higher degree of success.

Unfortunately, I couldn’t find any reference on internet that would judge what is the degree of success of the agile projects alone, but eventually this will be published by some research companies. Please let me know if you find some!

Final thoughts

In this post I’ve mentioned the principal points that would make a project successful, together with a list of best-practices that, if followed correctly, could lead to a project success. Unfortunately, historically and statistically there are higher chances that the project fails and hopefully with new techniques (agile!?) this could be avoided, or to some degree improved. What do you think about it?

Only few years ago I was not such a big fan of Object-Relational mapping tools (ORM), but now I have to admit that when starting a new project I’m always thinking whether it makes sense to use it or not.

Compared to “traditional” coding techniques, Object-Relational mapping often reduces the amount of code that needs to be written, but I would add as well that a new kind of problems arise too, especially in some more complex scenarios. So particular attention should be taken on the cost/benefit side, like for anything else.

What is an Object-Relational Mapper

Let’s start with a simple definition.

Object-relational mapping (ORM, O/RM, and O/R mapping) in computer software is a programming technique for converting data between incompatibletype systems in object-oriented programming languages. This creates, in effect, a “virtual object database” that can be used from within the programming language.
–Wikipedia

List of things to consider

There are many things that one should consider before adopting a particular library. Here is perhaps a short list of questions to be answered before choosing:

1. Is it free (and open source) or commercial
2. What is the support given by the company or the community?
3. Does it have an active community?
4. Can it handle enterprise class ORM problems?
5. Does it support LINQ?
6. What databases does it support out of the box?
7. A part direct table access, does it support querying of views, stored procedure or functions?
8. Is there any caching mechanism?
9. Does it support lazy-loading?
10. Does it support batching mode (updating many items at once)?

ORM Mapping Costs

As mentioned earlier, there are some costs to consider when adopting an ORM. Please consider the following:

Needless Repetition

Usually the table structure and table relations are stored both in the DB and in the ORM mapping files. This can cause a maintenance problem as one need to make sure that both versions of the meta-data don’t get out of sync. So, every change on the database usually means recompiling the application.

Mapping itself

Mapping it is not always a trivial task. Because of the “Object-relational impedance mismatch” there could be issues in transforming the database structure in the object oriented compatible way.

Performance problems

As the ORM tool is usually generating the SQL code to be executed on the database, this queries are often not fully optimized, and often could be rewritten in a much more optimized way if written manually. I mentioned often, as this is not always the case. Usually this can be solved by instead of querying the table directly, to query some specialized views that could optimize some code.

Microsoft.NET ORM tools

There is a quite big list of ORM tools, and here I am mentioning the ones I believe are among the most important ones.
I personally have experience with the Entity Framework and NHibernate, and I would leave the tough job of choosing one to you directly.

Microsoft’s Entity Framework

Entity Framework (EF) is an free and open source object-relational mapper that enables .NET developers to work with relational data using domain-specific objects. It eliminates the need for most of the data-access code that developers usually need to write.
Entity Framework allows you to create a model by writing code or using boxes and lines in the EF Designer. Both of these approaches can be used to target an existing database or create a new database.
Entity Framework is actively developed by the Entity Framework team which is assigned to the Microsoft Open Tech Hub and in collaboration with a community of open source developers.

Linq To SQL

LINQ to SQL is a free component of .NET Framework version 3.5 that provides a run-time infrastructure for managing relational data as objects.
In LINQ to SQL, the data model of a relational database is mapped to an object model expressed in the programming language of the developer. When the application runs, LINQ to SQL translates into SQL the language-integrated queries in the object model and sends them to the database for execution. When the database returns the results, LINQ to SQL translates them back to objects that you can work with in your own programming language.

I would personally not use Linq to Sql as it seems that not much effort is placed into enhancing the current technology.

Nhibernate

NHibernate is a free object-relational mapping (ORM) solution for the Microsoft .NET platform: it provides a framework for mapping an object-oriented domain model to a traditional relational database. Its purpose is to relieve the developer from a significant portion of relational data persistence-related programming tasks. NHibernate is free as open source software that is distributed under the GNU Lesser General Public License. NHibernate is a port of the popular Java O/R mapper Hibernate to .NET.

DataObjects.Net

DataObjects.Net is a commercial persistence and object-relational mapping framework for Microsoft.NET. It allows developers to define persistent objects as well as business logic directly in C#, Visual Basic or F#. The persistent objects can be retrieved by LINQ queries. Persistent data can be stored in SQL Servers. In contrast to many other ORM frameworks the database model is generated and maintained automatically.
It supports most of the mainstream databases.

Telerik’s OpenAccess ORM

OpenAccess ORM is Telerik’s free object-relational mapping tool that will generate the data access layer for your applications after just a few mouse clicks. All you have to do is to create the data model of your application and the tool will do the rest!
OpenAccess ORM supports: Database-First (Reverse) Mapping, Model-First (Forward) Mapping, Round-Trip (Mixed Mode) Mapping, Code Only Mapping (Fluent API), Mapping Stored Procedures, Views and Tables.
It supports most of the mainstream databases (Microsoft SQL Server, Oracle, Sybase, MySql, PostgreSQL, Firebird,…

BLToolkit

Business Logic Toolkit is a set of components to simplify .NET application development. BLToolkit is provided as source code that you can use “as is” or customize for your applications. It is written in C# and compatible with .NET Frameworks 3.5 and 4.0, Silverlight 4, and Mono.

LBLGen Pro

LBLGen Pro is a data-access solution.
You use the LLBLGen Pro Designer to create the entity/domain model, define the mappings and generate source-code for one of the four supported O/R mapping frameworks: Entity Framework, NHibernate, Linq to SQL or the LLBLGen Pro Runtime Framework.
You use the generated source-code combined with the O/R mapping framework of your choice to access your database and consume the data in that database.

When, for whatever reason, you have to change the O/R mapper for your project, you can simply switch the chosen target framework in the LLBLGen Pro designer, re-generate code and you’re done (give or take some minor changes if the newly chosen O/R mapper doesn’t support a feature the old one does). Of course your own code has to be migrated, but your entity model, mappings and the like all stay the same.

LinqConnect

LinqConnect is a commecial, fast, lightweight, and easy to use LINQ to SQL-compatible ORM solution, supporting SQL Server, Oracle, MySQL, PostgreSQL, and SQLite. It allows you to use efficient and powerful data access for your .NET Framework, Metro, Silverlight, or Windows Phone applications supporting Code-First, Model-First, Database-First or mixed approaches.
nqConnect was developed closely to LINQ to SQL and retains full compatibility with it. Interface of the LinqConnect classes is compatible with LINQ to SQL ones. If you are a LINQ to SQL developer, you don’t need to learn much and can start developing with LinqConnect immediately.

Unlike LINQ to SQL, LinqConnect is an actively developed and supported product, and it offers a number of benefits over LINQ to SQL. It supports more database servers, more development platforms, more LINQ features, more mapping kinds, provides better performance, etc.

Wrap it Up

There is a large number of ORM implementations for Microsoft.NET and is not always easy to choose the right one. We have seen that even the fact of using an ORM tool has some additional costs when it comes to the application design and maintenance.
All in all, I see in general more positive than negative aspects, once the learning curve and familiarity with the tool is not the problem.

Please suggest or comment what is your experience with the ORM tools, and why would you would(n’t) use one?

Recently I have participated to a couple of discussions about whether the triggers or stored procedures should be used or not in a “real” project, so I decided to write this post to express my point of view. This said, I warn you, there is no a “right” answer, but most probably a “pro” and “cons” about anything written in this post.

An old problem

There are more than a handful of developers who are not really clear (from the architectural point of view) when to use triggers, views, stored procedures,etc… let’s just call this “database logic”.
Being so easy to change, and so close to the data, one is really tempted to go to the “source” and start coding. 

I think that conceptually all developers agree with “using the right tool for the right job” rule, but when it comes to put this law into a practice, then is where all the problems begin.

I think that in general there are three types of developers:

• Database oriented developers: Usually this is someone that is very familiar with the database and thinks that the database is not merely a repository, but as well the place where to put all the logic.
• Code oriented developers: Would place everything outside the database (code, ORM, etc..). Usually this is a developer that is in love with ORM mappers, either because this is a trend or simply because don’t like working with SQL, because SQL is an old thing, isn’t it?
• Pragmatic developers: A thinker that applies the knowledge in order to get the best out of the two worlds.

Which of the three groups best describes you?

If you are reading this article you are a good candidate to become a pragmatic programmer or perhaps a black-belt programmer with a Mission:

and I would add another point: to create a perfect architecture.

Layered architecture to the resque

Before start answering the original question, I have to mention the layered architecture. There are many types of applications out there, but it’s possible to have some sort of a formally accepted layers, otherwise we are going to have a monolithic application.

There are many ways of naming those layers depending to who are you talking too, but in general we may distinguish the following:

A multilayered (software) architecture is using different layers for allocating the responsibilities of an application. share this quote on twitter

Presentation Layer

The presentation layer provides the application’s user interface (UI). Typically, this involves the use of Desktop/Mobile GUI (Windows Forms, IPhone/Android Shells etc..) or Web UI (ASP.NET, ASP.NET MVC, HTML,..) technologies for browser-based interaction.

Business Layer

The business layer implements the business functionality of the application. The domain layer is typically composed of a number of components implemented using one or more programming languages. These components may be augmented with distributed component solutions other kind of workflow orchestration.

Data Layer

The data layer provides access to external systems such as databases. When talking about Microsoft.NET the primary .NET technology involved at this layer is ADO.NET, but there are many other possibilities like using ORM mappers (Microsoft Entity Framework, NHibernate, etc..) or some other kind of “lightweight” database access libraries like PetaPoco, Massive, or others…

Database

A repository of data.

Various types of architectures.

As we have seen above, there are several layers usually used within one application, and each layer has its own responsibility. The hearth of the application is the “Business Layer” because this is something that gives the meaning to the application.
Unfortunately things are not that easy, because, yes, we may layer our application, but not every application is layered in the same way.

Let’s simply name a few typical kind of applications:

1. Client-Server applications: Usually this kind of application should contain all of the layers described above, but there are several variations depending on the complexity of the application. The point is that the database is running on a separate server from the GUI itself.
2. Reporting applications: Usually simply display the data to the user in forms of reports. Typically here we can find the Presentation layer, but the business layer usually would stay in the database directly
3. Web Application: A web application could be seen as a Client-Server application because at it’s heart is executing the code on the server and the database would be typically on another server.

Scalability

The definition of the scalability is:

A characteristic of a system, model or function that describes its capability to cope and perform under an increased or expanding workload. A system that scales well will be able to maintain or even increase its level of performance or efficiency when tested by larger operational demands.

I really like this topic, and I think that is really important when it comes to the decision of putting the important part of the logic in the database.

In general, RDBMS databases are not scalable!

Why RDBMS are not scalable?

Let’s put it this way: The CAP theorem states that a distributed (i.e. scalable) system cannot guarantee all of the following properties at the same time:

1. Consistency
2. Availability
3. Partition tolerance

RDBMS systems guarantee consistency. That’s why a standard RDBMS cannot scale very well: it won’t be able to guarantee availability. And what good is a database if you can’t access it?

Database pioneer and researcher Michael Stonebraker co-wrote a paper that discusses the limitations of traditional database architectures. RDBMS scale up with more expensive hardware, but have difficulty scaling out with more commodity hardware in parallel. He contends that the BigData era requires multiple new database architectures that take advantage of modern infrastructure and optimize for a particular workload.

You may see straightforward one big limitation of the databases itself, as in some larger applications those can become a bottleneck, especially in the newest era of computing (see big data, social platforms like twitter, Facebook, google, that are mainly not using RDBMS’s for keeping their data)…

What is the alternative?

The alternative for some enterprise applications, is to have very well separated layers, and well separated tiers, that would be designed for scalability.

As shown in the diagram below:

Adding new “Web services” by increasing a number of servers where the most of calculations (business logic) would be placed, we remove the burden from the database that would be then able to do what it does best, collect and store the data in an consistent way, otherwise if we would put the calculation logic in the database, that would need to server thousands of concurrent transaction, this would soon be unusable.

That’s why it is very common to have the “reading” database separated from the “writing” database as shown in the image below.

Final Thoughts

I think I just gave you an idea of why I think that the database should not contain business logic. This is based on my experience working on some large applications, where i see that the database becomes more increasingly a bottleneck and after some time it is really hard to detach and refactor the logic to some other layers, as there is another not written rule of “don’t change it if it works”. I am sure there is ton of people that doesn’t think it in this way (please comment this post then!), and there are tons of other reasons that would go against what described here. You decide ultimately!
Let me know what do you think?

When choosing Juniper certification exams based on career advancement goals, there are a couple of things you need to keep in mind. The first is that Juniper exams are sequential in nature. In other words, you must work your way through exams from the associate level up in order to build your expertise and meet prerequisite requirements for more advanced testing options through the organization.

The second point of importance in career advancement professional certification exam selection is to choose a certification path that will meet your current and your future goals. An Juniper exam that validates your level of expertise and your knowledge base for your current position is the first step in working toward a promotional opportunity or a new job in your field of focus. By demonstrating and documenting our current level of competency you make yourself a more valuable employee – both for your current employer and prospective employers.

From there, choosing the Juniper certification exam that’s best for advancing your career depends on your reason for pursuing testing. In other words, if you’re simply looking to validate your overall competencies in your role, then you’ll want to focus on the role-based exams offered through Juniper. However, if you’re concerned about validating your technology or product specific knowledge and skills for your current position or to achieve a promotion or other career advancement, you’ll want to review the testing options in your focus area.

Whichever exam or exams you choose to complete, spend the appropriate time studying to promote strong performance on your first attempt. Exam prep studies can include everything from formal training courses to self study tutorials to the use of practice exams, like those offered by providers like TestsLive (click here), for example.

Today I run into a problem of finding out when was the last time a specific Stored Procedure (SP) has been changed.

Obviously, there are different ways to find out, but in this post I would like to introduce some of the possible solutions by using your lovely MS SQL Server Management studio query window. I hope you will find this info useful.

Introduction

Generally there are two ways to retrieve information about database objects. By using either the Sys or INFORMATION_SCHEMA schemas.

So, let’s start by saying that usually you would be too busy to look into the internal SQL Server system tables/views, but it worth mentioning that this is possible, and for sure you would like to get all this information in a really easy way.

Sys.* objects

Objects in this schema contains everything you need to know about the database, indeed, this gives us a direct view on SQL Server internal structure. Sys schema contains so called “System views”. Be aware that there is a large number of system views, and is out of scope of this post to list them all. Anyway, here listed are a couple of “System views” that you will be most probably looking into:

etc… I am sure you got the idea.

What you would probably like to know is how the SQL Server stores the “type” information about the particular object. Please find out the following list:

• C: Check constraint
• D: Default constraint
• F: Foreign Key constraint
• L: Log
• P: Stored procedure
• PK: Primary Key constraint
• RF: Replication Filter stored procedure
• S: System table
• TR: Trigger
• U: User table
• UQ: Unique constraint
• V: View
• X: Extended stored procedure

Information Schema

I am sure you will find very usefull the usage of INFORMATION_SCHEMA that contains a number of VIEWS to the internal database objects. The INFORMATION_SCHEMA is much more user friendly, but gives less information. Here below is a list of some views that INFORMATION_SCHEMA contains (total of 20 views):

etc… again, you got the idea.

So, let’s finally start doing some queries:

How to retrieve the Create and Modify date for a stored procedure

SELECT name, create_date, modify_date
FROM sys.objects
WHERE type = 'P' -- Stored Procedure
OR type = 'V' -- View

you may obtain the same thing by using the following query:

SELECT SPECIFIC_NAME, CREATED, LAST_ALTERED
FROM INFORMATION_SCHEMA.ROUTINES

How to retrieve the list of a Stored Procedure Parameters

SELECT sys.parameters.name, so.name , so.*
FROM sys.parameters
INNER JOIN sys.objects so ON so.object_id = sys.parameters.object_id
WHERE so.name = ''

you may obtain the same thing by using the following query:

SELECT PARAMETER_NAME, SPECIFIC_NAME, Data_Type
FROM INFORMATION_SCHEMA.Parameters
WHERE SPECIFIC_NAME = ''

Conclusion

As you have seen, it is really easy to retrieve information about your database objects. This post was just to give an introduction on the subject, so I leave the tough work of discovering all the beauties of the SQL Server internals to you

If you, like me, are using Subversion as your primary Version System and want to embed the SVN revision number directly in the assembly, but don’t know how, this post will try to explain it.

What do you need?

Before proceeding any further, you would need to download the following two packages (free!)

• MSBuild Community Tasks
• Subversion 1.7.8 (Windows 64/32-bit)

What is the process to follow

In the explanation I assume the build process is made out of a Build Server (Hudson, Bamboo, Team City, or others..) but exactly the same process applies if the compilation is done manually.

In the image above, I am showing two different steps:

1. Developer, committing the code in the SVN repository
2. In my case, a Continuous Integration server that compiles the project. Steps that the Build Service has to perform are:
   • Download the latest version of the source code
   • Change the AssemblyInfo.cs file with the Repository Revision number. I will show how to do this, just keep reading.
   • Compile the solution.

It’s pretty much clear and simple to follow this steps.

Preprocessing the AssemblyInfo.cs in MsBuild

The main point of the whole process in the building (compilation) of the project.
The following MsBuild Target will help you with the “pre-processing”, which means, changing the AssemblyInfo.cs file before the code is compiled. In this way we are able to embed the revision number.

Two tasks are used from the MsBuild Community Tasks

• SvnVersion
• FileUpdate

so on top of your MsBuild file you would need to include the following declaration:

<UsingTask TaskName="SvnVersion" 
           AssemblyFile="MSBuild.Community.Tasks.dll"/>
                  
<UsingTask TaskName="FileUpdate"
           AssemblyFile="MSBuild.Community.Tasks.dll"/>

and use this target to be executed BEFORE the main compilation.
For brevity I am including only the Target itself, as your build process could vary.

<!-- ******************************
@@ PRE-BUILD PROCESSING
@@ Sets the revision version for the assemblies.
*********************************** -->
<Target Name="PreBuild">             
  <ItemGroup>
      <!-- find all the AssemblyInfo.cs files in the solution-->
      <AssemblyInfoFiles 
               Include="$(BuildPath)\*\Properties\AssemblyInfo.cs"/>
  </ItemGroup>
       
  <PropertyGroup>
      <SVNToolPath><!--Path to the svnVersion.exe--></SVNToolPath>
  </PropertyGroup>
       
  <!-- Getting the revision number from svn by using the svnVersion-->       
  <SvnVersion LocalPath="$(BuildPath)" ToolPath="$(SVNToolPath)" >
      <Output TaskParameter="Revision" PropertyName="Revision" />
  </SvnVersion>
  <Message Text="Revision: $(Revision)"/>

  <!--uploading the AssemblyInfo.cs files-->
  <FileUpdate Files="@(AssemblyInfoFiles)"
              Regex='(d+).(d+).(d+).(d+)'
              ReplacementText="$1.$2.$3.$(Revision)" />
</Target>

Pretty much simple. Isn’t it?
In my case the revision number is 5683 and you may see the end result in the picture below:

Conclusion

I believe that this is a very effective and simple way of including the revision number directly in the assembly, which makes the revision tracking simpler overall.
If you think there are other and more effective ways, please let me know!

Since 2001 Syncfusion provides the broadest range of enterprise-class software components and tools for the Microsoft .NET platform, so it’s not a surprise that as a Software Consultant several times in my working career I had to deal with their libraries and components which usually were reliable, good quality and easy to use.

That said, this blog post is not about their components, as there are plenty of information out there, but about what Syncfusion introduced in May 2012, which is what they call Succinctly Series, and in particular about the book called ASP.NET MVC 4 Mobile Web Site by Lyle Luppes

Let’s start from the beginning by introducing what Succinctly Series is all about and the best thing would be to directly take a quote from the Syncfusion blog:

While a lot of information on application development is available on the internet and in books, that information is becoming harder to digest. If you do not enjoy reading several 500+ page books, or scouring the web for relevant blog posts and articles, you have come to the right place.
Syncfusion publishes the Succinctly series concise technical books that target developers working on the Microsoft platform. Each book is around 100 pages and is guaranteed to enlighten you on the topic of interest. Download a copy, get a cup of your favorite beverage, and enjoy!

Isn’t that great? Syncfusion is offering for free high quality books that are condensed and go “straight to the point”, which saves long hours of reading that none of us really have.

ASP.NET MVC 4 Mobile Web Sites Succinctly

The book that I particularly liked as it goes beyond the classical “let’s develop in ASP.NET MVC framework” is the ASP.NET MVC 4 Mobile Web Site Succinctly by Lyle Luppes, that describes how developers that are currently using ASP.NET MVC 3 can move to MVC 4 with minimal effort.
I firmly believe that this book will offer you a great help when deciding about how to make a website with MVC 4 that can handle the unique challenges presented by mobile and desktop clients.
Needless to say that the code samples are freely downloadable.

Who should be interested in reading this book?

This book is for developers who are currently using Microsoft ASP.NET and MVC to create websites, and who are interested in creating websites that play nicely with mobile devices.

Purpose?

It‘s designed to be a quick read for developers and to help them understand the concepts they need to know to improve their websites when it comes to dealing with mobile devices.

Table of Contents

1. I Love MVC 4!
2. Why a Book about Mobile-Friendly Websites?
3. Designing Mobile-Friendly Websites
4. Building an MVC Mobile Website
5. Making It Mobile-Friendly
6. Making It Look Good
7. Using Mobile Device Meta Tags
8. Tips and Tricks
9. Enhancing Performance
10. Still Using MVC 3?
11. Conclusion

Conclusion

If you are a ASP.NET MVC developer I strongly advise you to take a look at this book and perhaps to other great content that Syncfusion offers. As I started working on my new, side project, www.linktotweet.com I will definitively start applying some code found in the book in order to build a more mobile friendly version.
Pleaset let me know what do you think about the book and would you advise it to others?

When exposing a WCF service and hosting it on IIS6, most probably you are going to get the error shown in the image below, where the address of the WSDL location is not properly exposed to the end clients.

As the following WSDL gets created (shown in the picture below), the consequence of this is that de-facto you are not able to expose your service to your clients without manually sending them the WSDL and correcting the location of the schema for the exposed types.

How to fix this?

Mainly, there are two ways of fixing this:

1. Changing the web.config file (works only for .NET 4 and above)
2. Tweaking the IIS for version of .NET 3 and 3.5

Web Config change

Changing the web.config would work only for the .NET v4 and above, as Microsoft introduced a fix for this.
You should simply add the part as part of your serviceBehaviors/behavior and magically this is going to work.

<behaviors>
    <serviceBehaviors>
        <behavior name="name of your behaviour">
            <useRequestHeadersForMetadataAddress>
                <defaultPorts>
                    <add scheme="https" port="443" />
                </defaultPorts>
            </useRequestHeadersForMetadataAddress>
        </behavior>
    </serviceBehaviors>
<behaviors>

IIS Change

The reason this problem happens in IIS 6 is because IIS 6 doesn’t expose the header name for the TSL/SSL (https) based web sites and therefore WCF is (was) not aware of the header that the web site where the WCF is hosted, responds to.

In order to fix this, you should run the admin script to change your web site bindings, as this cannot be done anywhere else in the IIS Admin gui.

Script that changes the IIS binding:

cscript.exe //nologo %systemdrive%\inetpub\adminscripts\adsutil.vbs set W3SVC//SecureBindings ":443:website.com"

To check if this really worked, change the set to get:

cscript.exe //nologo %systemdrive%\inetpub\adminscripts\adsutil.vbs get W3SVC//SecureBindings ":443:website.com" 

Conclusion

I really hope that this info will be on your help as made me and my team spend quite a lot of time into finding out the solution. In our case the .NET 4 saved us from modifying directly the IIS bindings.

Recently I started working on my side-hobby-project on the linktotweet.com web site, and one of the functionality I want to offer to site members is the possibility to track the statistics, and more precisely the location of their visitors. In other words, I need to translate the IP address to an actual location.

While this is almost a trivial task for whoever is using the Google Analytics (like I do) that tracks the visitors, implementing it yourself is actually not such a trivial thing. Ok, it is not that complex too

IP to Location database

The first thing to find out is where to get this IP to Location data from!
Mainly there are two possibilities.

1. Use a third party web service that will translate the ip to a given location
2. Implement your own solution. Meaning, hosting the data on own servers.

I chose to go with the second approach. While there are really many providers around, I wanted to use the most precise and free database. After many days of searching and trying out the solution, I came to the DB-IP.com provider. DB-IP.com is offering some free databases among their commercial versions… My choice was the “IP address to city”, which is really enough for the first version of the site.

Importing tool

While on the DB-IP.com there is a version of the code written in PHP that would import the database I wanted to create something on my own, and I’ve created a command line tool ZORAN.DB.IP.Importer and have published it on git hub as a free download.

How to run the application?

1. Download the free database from this location http://www.db-ip.com/db/download/city. The database comes in the CSV format.
2. Setup the Connection String in the ZORAN.DB-IP-Importer.exe.config file to point to the Microsoft SQL Server database. This is done by changing the value of the connection string named “DB_IP”
3. Once again, in the file ZORAN.DB-IP-Importer.exe.config, enter the path to the CSV file by changing the value of the AppSettings value “db-ip-file-path”
4. Run the two provided scripts dbip_city.sql and dbip_city_stage.sql against your database. This will create two tables (staging and the “live” table). Obviously this should be done only once , the first time you use the application.
5. Run the application.

Yes, but how does it work?

In order to avoid any complex management of the inserts and updates of the already existing data, I’ve chosen the approach of the staging table and the “live” table.

The importing process operations are as follows:

1. Read the CSV file
2. Truncate the data from the “Staging” table
3. Load the data from the CSV file to the “Staging” table
4. In a transaction, move all the data from the “staging” table to the “live” table.

Licence

http://www.apache.org/licenses/LICENSE-2.0

External tools

This project uses the external library CsvHelper which binaries are in this repository. For more info please visit the official site at https://github.com/JoshClose/CsvHelper

Downloads

Download the first version of the compiled application from ZORAN.DB-IP-Importer_v1.0.0.zip

If you think you need any help with the tool please let me know.

Google DataTable .NET Wrapper library got its third version (v3.0.0). In this post I will highlight the changes.

For basic information about the library check a previous post of how to use the Google DataTable .Net Wrapper Library

To download or consult the source code please visit the project’s CodePlex page or install directly from Visual Studio by using Nuget

Custom object properties

Version 3.0.0 mainly brings a unified way of managing custom properties that could be attached to the Column, Row or Cell objects. Of course, depending of the chart type you are using, those will be supported or not.

The (breaking) change here is that instead of having a simple String property (previously known as Properties), now a List type have been introduced for all the above three types of objects.

Let’s see what would be a very common usage:

DataTable dt = new DataTable();

var row = dt.NewRow();

//Previously you had to manually format the output for the JSON string....
row.Properties = "\"style\": \"border:1\", \"cssStyle\": \"mystyle\"";

//Now you can use a much more user friendly....
row.AddProperty(new Property("style", "border:1"));
row.AddProperty(new Property("cssStyle", "mystyle");

As the same kind of logic has been used for Cell, Column and Row, the output is exactly the same in all the cases (the “p:” part). This is an example of the JSON returned for the above Row example…

"rows" : 
[
	{
		"c" : [{"v": new Date(2013, 0, 7), "f": "Year"}, {"v": 0}], 
		"p" : {"style" : "border:1", "cssStyle" : "myStyle"}
	}
]

PropertyMap

In order to achieve this, I’ve introduced a very simple class called Property that would hold the values for a single entry.

public class Property
{
    public Property(string name, string value)
    {
        Name = name;
        Value = value;
    }

    public string Name { get; set; }

    public string Value { get; set; }
}

//and the signature for the objects is now...
public class Cell //Column and Row
{
//....
    public IEnumerable<Property> PropertyMap
    {
        get { return _propertyMap; }
    }

    public Property AddProperty(Property p)
    {
        _propertyMap.Add(p);
        return p;
    }

    public void RemoveProperty(Property p)
    {
        _propertyMap.Remove(p);
    }
//.... omitted for brevity
}

SystemDataTableConverter

This version introduced a new functionality implemented as a new type called SystemDataTableConverter which enables the conversion from the widely known Ado.NET System.Data.DataTable into our DataTable. This obviously gives a possibility to return a JSON string and it is very handy as a large amount of projects stilly use the System.Data.DataTable as the mean of transferring data.

How to use the converter

The following code is an example of how to use the converter:

System.Data.DataTable sysDt = new System.Data.DataTable();
sysDt.Columns.Add("firstcolumn", typeof(string));
sysDt.Columns.Add("secondcolumn", typeof(int));
sysDt.Columns.Add("thirdcolumn", typeof(decimal));

var row1 = sysDt.NewRow();
row1[0] = "Ciao";
row1[1] = 10;
row1[2] = 2.2;
sysDt.Rows.Add(row1);

var dataTable = SystemDataTableConverter.Convert(sysDt);
string jsonString = dataTable.GetJson();

this would be the output for the above code:

{
"cols": 
    [
	{"type": "string" ,"id": "firstcolumn" ,"label": "firstcolumn" }, 
	{"type": "number" ,"id": "secondcolumn","label": "secondcolumn"},
	{"type": "number" ,"id": "thirdcolumn" ,"label": "thirdcolumn" }
    ], 
"rows" : 
    [
	{
            "c" : [ {"v": "Ciao"}, {"v": 10}, {"v": 2.2} ]
        }
    ]
}

so, without any effort your existing DataTable will get serialized into JSON needed by the Google Javascript library.

Column Role attribute

As it is stated in the google datatable documentation at the following link Google DataTable Roles, Column object should support the “Role”.

This version implements a new attribute for the Column, called indeed, Role.

Let’s see an example:

var column = new Column(ColumnType.String);

//please not the ColumnRole.Annotation 
column.Role = ColumnRole.Annotation;

Role is a string, and I’ve simply created a helper class ColumnRole that implements as attributes the currently available values that DataTable Column supports.
this is absolutely a valid code instead:

var column = new Column(ColumnType.String);
column.Role = "annotation";

Serialization of the Date() values

The way of how the DateTime and Date type columns are serialized is changed slightly. In the earlier version indeed columns of Date and Datetime were not properly serialized, so this is a bug fix.

While this would work when you are directly passing the literal string to the Javascript dataTable

 {c:[{v: 'c'}, {v: 3.0, f: 'Three'}, {v: new Date(2010, 3, 30, 0, 31, 26)}]}

it won’t work if you return a JSON in such a format, as JSON doesn’t support such a notation, so you should use instead

 {c:[{v: 'c'}, {v: 3.0, f: 'Three'}, {v: "Date(2010, 3, 30, 0, 31, 26)"}]}

the difference is the new keyword and the quotes around the value.

Final Thoughts

Please test out the new version and let me know if there are issues or if there are things that you would like to see in the new version by contacting me or leaving a comment either here or on the CodePlex web site.

In the previous post I’ve described how to use the library and what are the main characteristics. For sure there is more to come and follow up, so stay tuned.

In this post, I would like to describe the big performance improvements made in the meantime, as I was not fully happy with the serialization performance in the first version.

As I have just submitted a new version of the source code as part of the change-set 18219 I would like to show you here some statistics regarding both object creation and serialization of those objects in JSON format expressed with concrete numbers.

Let’s start with some statistics

The following three charts show the creation and serialization of 1 million rows with the previous (v1) and current (v2) version of the Google DataTable .Net Wrapper library. I have run the same benchmark code 5 times in order to obtain more or less some sort of a significant average time. So, in all charts you see the time expressed in milliseconds for each of the runs.

Object Creation

Values in the below chart (smaller values are better) show that the new version improves quite a lot the object creation speed. The average time spent for creating objects for 5 runs in Version 1 was 3123 milliseconds while in the Version 2 it has been reduced to 2209 milliseconds, which is about 44% of speed improvement.

The code used for this benchmark:

DataTable dt = new DataTable();
var columnYear = new Column(ColumnType.Number, "Year");
var columnCount = new Column(ColumnType.String, "Count");

dt.AddColumn(columnYear);
dt.AddColumn(columnCount);

int ONE_MIO_ROWS = 1000000;

for (int i = 0; i < ONE_MIO_ROWS ; i++)
{
    var row = dt.NewRow();
    row.AddCellRange(new Cell[]
        {
        new Cell() {Value = 2012, Formatted = "2012"},
        new Cell() {Value = 1, Formatted = "1"}
    });
        
    dt.AddRow(row);
}

Object Serialization

In the first version of the library most of the time spent was to shape and obtain the correct object model. This is not yet perfect as by following the Google specification, the Property Map should be expressed as a NameValue pair, while in the library this is expressed as a simple string. This is definitively one additional thing to be changed in the future, but let’s speak about the present:)

I’m really proud to say that the average speed improvement is about 183%. Serializing to JSON 1 million rows now takes in average 2291 milliseconds in comparison to the previous 6467 milliseconds.

Overall improvement

If we sum up all together both the serialization and the object creating we will get the overall improvement of 114%. From the average of 9590 milliseconds in the first version we have doubled the speed to 4500 milliseconds, as you may see here below.

What has been changed?

Now the most interesting part. What has been changed in order to get (for me) so impressive speed improvement?

Here is a list of code changes:

StringBuilder vs StreamWriter (MemoryStream)

In the first version, in order to concatenate strings, that then would become the serialized Json, I used StringBuilder with few Extensions in order to “append” data in some specific cases, like if the property was null etc…
I’ve seen that the performance could have been improved if MemoryStream and StreamWriter combination vs StingBuilder were used. I’ve conducted some extra tests, and I have to say that theoretically the performance improvements would have been minimal, but as the goal was to squeeze as much milliseconds as possible i have anyway chosen to go with this approach.

So the code now looks something like this:

public string GetJson()
{
    string rowsJson;
    using (var ms = new MemoryStream())
    {
        var sw = new StreamWriter(ms);

        //... concatenating strings here.. omitted for brevity
        sw.Flush();
        ms.Position = 0;
        
        using (var sr = new StreamReader(ms))
        {
            rowsJson = sr.ReadToEnd();
            sr.Close();
        };
    }

    return "{" + rowsJson + "}";
}

In addition to this, I tried not to call the StreamWriter.Write() as less as possible, so any time I had a predefined string I would put it into one Write() call.

example:

StringWriter sw = new StringWriter(stream);

//don't do this
sw.Write("rows");
sw.Write("[");
sw.Write("...");

//do this
sw.Write("rows [ ...");

Using for(...) rather than foreach

foreach is a great syntactic sugar, and I have to admit that I always tend to use it in almost every application I write. It’s very easy to write and to understand and it makes the code prettier.
In general, “The for-loop is faster than the foreach-loop if the array must only be accessed once per iteration.“.
I usually access the variable only once per iteration, so for loop was working better for me.

Inline Code

In general, I tend to follow the good object oriented design where every object has it’s own role and behavior. But, I’ve noticed that instead of accessing the code by calling a function of the object itself, for instance Row.GetJson(), when calling everything inline in one function, the speed would improve. I didn’t have too much time to analyze how much indeed the difference was, but one thing is for sure, now the code is much more difficult to read

General small changes

Here and there I’ve seen several bottlenecks, and code that could be improved, so that instead of always calculating certain values (that are known) to reuse the cached ones etc…

Final thoughts

It was really a joy working on the performance improvements. The amount of things that one can discover during the process is incredible. A lot of things that one would consider “fast” suddenly becomes slow once a deeper analysis has been made.
One very important thing that I always follow is that the performance improvement is always left as a last thing to do because you really never know how long would it take, and usually this means that the original design is going to be a bit reconsidered. I personally consider a good design and maintainability of the code one of the most important things, the “really fast software” sometimes makes sense to spend time into, but sometimes don’t.
Happy coding.

As I have just published the Google DataTable .Net Wrapper project on CodePlex, the following post intends to be a quick introduction on the rationale on why this project has been created and its implementation.

Quick Project Background

While working on the implementation of the www.linktotweet.com web site, which is one of my side projects, I had to choose a way of displaying charts in order to show the statistics. I mainly had two options, either to return an image, that would be fully generated server side, or to use a bit of a different way and use one of the existing JavaScript libraries and generate those charts directly in the client’s browser.

As I wanted to free up the server resources from generating images at runtime, and to be honest, haven’t had experience with javascript charting libraries, I’ve chosen to go with the JavaScript approach. Among a large number of JavaScript libraries I’ve chosen the “Google Chart Tools”. Google Chart Tools is one of the most extensive libraries of charts on the web. It supports both HTML5 or SVG rendered charts. One of the good points of the Google Chart Tools is that is as well compatible with the iOS and Android. In any case, all the information about the Google Charts can be directly consulted on the official project page.

Why the Google DataTable .NET Wrapper?

As in my case of a web site project, there are mainly two ways that Google Chart Tools library uses to handle the data that would be later displayed:

1. Data, directly generated, client side, on the page, which means directly in the JavaScript.
2. Data prepared and then retrieved, i.e: by using a Ajax call, from the server

Let’s see both examples of how this can be done by looking at the client, JavaScript side:

Generating a chart with data generated directly on the client

In this example, the data has been generated directly in the JavaScript (the data.addRows(...) part. This is pretty much easy, but somehow cumbersome if you need to generate and return some complex dynamic data.

// Load the Visualization API and the piechart package.
google.load('visualization', '1.0', {'packages':['corechart']});

// Set a callback to run when the Google Visualization API is loaded.
google.setOnLoadCallback(drawChart);

// Callback that creates and populates a data table,
// instantiates the pie chart, passes in the data and
// draws it.
function drawChart() {

// Create the DataTable directly in the javascript.
var data = new google.visualization.DataTable();
data.addColumn('string', 'Topping');
data.addColumn('number', 'Slices');
data.addRows([
		['Mushrooms', 3],
		['Onions', 1],
		['Olives', 1],
		['Zucchini', 1],
		['Pepperoni', 2]
	]);

// Set chart options
var options = {'title':'How Much Pizza I Ate Last Night',
			   'width':400,
			   'height':300};

// Instantiate and draw our chart, passing in some options.
var chart = 
new google.visualization.PieChart(document.getElementById('chart_div'));
chart.draw(data, options);
}

Using Ajax in order to get the server side generated data

In this, second, JavaScript example, the data has been generated on the server and Ajax has been used to retrieve data from a RESTful service. In order to achieve this, a reference to jQuery needs to be added to the page.

// Load the Visualization API and the piechart package.
google.load('visualization', '1', {'packages':['corechart']});
      
// Set a callback to run when the Google Visualization API is loaded.
google.setOnLoadCallback(drawChart);

function drawChart() {
	var jsonData = $.ajax({
		url: "/Statistics/GetStatisticsForChart?messageCode=SomeCodeHere",
		dataType: "json",
		async: false
	}).responseText;

	// Create our data table out of JSON data loaded from server.
	var data = new google.visualization.DataTable(jsonData);

	// Instantiate and draw our chart, passing in some options.
	var chart = 
new google.visualization.ColumnChart(document.getElementById('chart_div'));
	chart.draw(data, { width: 400, height: 240 });
}

for more info on this particular usage, please check the google site.

Server Side generated content

When retrieving data from the server, the data transfer format has to be expressed in JSON and in order to generate a Google Charts compatible DataTable format, a specific “schema” has to be used. Below is an example of a DataTable that Google Chart Tools understand, and expressed in JSON.

{
  "cols": 
	[
	  {"id":"", "label":"Topping", "pattern":"", "type":"string"},
	  {"id":"", "label":"Slices",  "pattern":"", "type":"number"}
	],
  "rows": 
	[
	  {"c":[{"v":"Mushrooms", "f":null}, {"v":3,"f":null}]},
	  {"c":[{"v":"Onions",    "f":null}, {"v":1,"f":null}]},
	  {"c":[{"v":"Olives",    "f":null}, {"v":1,"f":null}]},
	  {"c":[{"v":"Zucchini",  "f":null}, {"v":1,"f":null}]},
	  {"c":[{"v":"Pepperoni", "f":null}, {"v":2,"f":null}]}
	]
}

Google DataTable .Net Wrapper to the rescue

Are you willing to manually generate the above JSON code for every single case? I wasn’t and therefore I created, what I called, Google DataTable .NET Wrapper, that could simplify drastically the Json generation by following a full POCO lightweight object model.

Let’s see it in action

using Google.DataTable.Net.Wrapper;

private DataTable GetDataTableJson()
{
    DataTable dt = new DataTable();

    //Act -----------------
    dt.AddColumn(new Column(ColumnType.Number, "Year"));
    dt.AddColumn(new Column(ColumnType.String, "Count"));

    var row1 = dt.NewRow();
    var row2 = dt.NewRow();

    row1.AddCellRange(new[] {new Cell(2012, "2012"), new Cell(150, "150")});
    row2.AddCellRange(new[] {new Cell(2013, "2013"), new Cell(100, "100")});

    dt.AddRow(row1);
    dt.AddRow(row2);

    return dt.GetJson();
}

would result in the following generated JSON

{
  "cols": 
	[
	  {"type": "number", "id": "Year"}, 
	  {"type": "string", "id": "Count"}
	], 
  "rows": 
	[
	  {"c": [{"v": "2012", "f": "2012"}, {"v": "150", "f": "150"}]}, 
	  {"c": [{"v": "2013", "f": "2013"}, {"v": "100", "f": "100"}]}
	]
}

Wrapping it all together

As you may see in the above example, the Google DataTable .Net Wrapper is a simple library that contains several classes:

1. DataTable
2. Column
3. Row
4. Cell

and that gives a great way of expressing the data in a strongly typed way, by offering the possibility to export the Json data in exactly the format that the Google Chart Library needs. This will make you avoid writing any specific code in order to transform your object data into JSON format.
Objects are lightweight and made very simple, so this should affect in any way the performance of your application.

What comes next?

There are still some unfinished things, as the “full” Google DataTable support. As the Google library supports a lot of different scenarios, especially when it comes to what Google calls “Property Map”, where additional data could be added to the Cell or the DataTable itself. For the time being this has been implemented as a single string, when in reality should be more a List of NameValue pair objects.

Project page

1. Download the latest version of the source code
2. Download the library

Get the library directly from NuGet:

or get more information by following the NuGet library page: https://nuget.org/packages/Google.DataTable.Net.Wrapper

References:

• http://my.opera.com/tagawa/blog/list-of-javascript-charting-libraries
• http://javascripted.me/top-5-free-javascript-chart-libraries.html
• Google Charts DataTable Reference

In the last few days I was intensively working with MsBuild, as I had to automate the building and deployment of 3 projects to a large amount of environments. In order to achieve this, an obvious choice was to use the MsBuild, which in my opinion is a great framework that perfectly fits with the .NET world. Obviously there is a learning curve, but once mastered it’s really a joy to use.

MsBuild is primarily made of Targets and Tasks. Especially Tasks have a function to enable and enrich the MsBuild platform, and the great deal is that everyone can write a Task and extend the pre-existing functionalities.

Popular extensions

MsBuild is very easy to extend, and there are two very important sources with tons of already written and ready to use Tasks. In case you are interested, feel free to download from the below links, as both are free to use and maintained by the community. There you will find Tasks such as Zip, SVN integration, SQL Server integration, and so on…

1. Microsoft’s MSBuild ExtensionPack
2. MSBuild Community Tasks

Using and integrating the above libraries goes beyond this post.

Creating own tasks

There are mainly two ways of creating tasks by:

1. Implementing and compiling an ITask interface: That’s it creating a class that would implement ITask interface. In order to integrate this into the MSBuild script file, one would need to specify a path to the compiled assembly that needs to be deployed together with the script.
2. Implementing an inline task.

While there are many posts in internet related to the MSBuild task creating by implementing the ITask interface, in this post I would love to concentrate on Inline tasks.
In the .NET Framework version 4, you can create tasks directly in the project file. You do not have to create a separate assembly to host the task. This makes it easier to keep track of source code and easier to deploy the task. The source code is integrated into the script itself.

I’ve created a very simple Tasks that is responsible for deleting files, given a list of files to be deleted.
So, let’s start with explaining a skeleton of an inline task:

I think that is kind of useless to go through the implementation of the task as it is really trivial. Looping through the list of files received as the FilesToDelete parameter, and filling a list of deleted items.

Here is what an Inline Task looks like:

<UsingTask TaskName="DeleteFiles" 
           TaskFactory="CodeTaskFactory"
           AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">

<ParameterGroup>
  <FilesToDelete    ParameterType="System.String[]" 
                    Required="true" 
                    Output="false"/>
  <IgnoreErrors     ParameterType="System.Boolean"  
                    Required="true" 
                    Output="false"/>
  <ShowErrors       ParameterType="System.Boolean" 
                    Required="true" 
                    Output="false"/>
  <DeletedFiles     ParameterType="System.String[]" 
                    Output="true" />
</ParameterGroup>

<Task>
  <Using Namespace="System.Collections.Generic" />
  <Using Namespace="System.IO" />
  
  <Code Type="Fragment" Language="cs">
	<![CDATA[
	List<string> DeletedFilesList = new List<string>();
	
	if(this.FilesToDelete!=null && this.FilesToDelete.Count()>0)
	{
	  foreach(string file in this.FilesToDelete)
	  {
		try
		{
		  if(File.Exists(file))
		  {
			File.Delete(file);
			DeletedFilesList.Add(file);
		  }
		}
		catch(Exception exc)
		{
		  if(this.ShowErrors == true)
		  {
			Console.WriteLine("Deleting file " + file 
                            + " failed because of " + exc.ToString());
		  }

		  if(this.IgnoreErrors == false)    
		  {
			break;
		  }
		}
	  }
	}
	this.DeletedFiles =  DeletedFilesList.ToArray();
	]]>
  </Code>  
</Task>
</UsingTask>

Integration

Using the above created inline task is pretty much straightforward. As shown here below, we simply need to create a tag with the task name, send parameters, and get back the output, if any.

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" 
         ToolsVersion="4.0">

  <UsingTask> ... here goes the above implementation ... </UsingTask>

  <!-- Creating the target, as we would do usually -->
  <Target Name="DemoDeleteFiles" >
    <Message Text="Starting execution of the DemoDeleteFiles..."/>
    <ItemGroup>
      <FileToDelete Include="E:\svn\trunk\xxx.txt"/>
      <FileToDelete Include="E:\svn\trunk\xxx1.txt"/>

    </ItemGroup>

    <!-- Simply create an element with the same name 
         of the inline task created in the previous example -->
    <DeleteFiles FilesToDelete="@(FileToDelete)"
                 ShowErrors="true"
                 IgnoreErrors="false">
      
      <!--Define the output...-->
      <Output TaskParameter="DeletedFiles"
              ItemName="FilesSuccessfulyDeleted"/>
      
    </DeleteFiles>

    <!--Showing the output on the screen-->
    <Message Text="Files deleted: @(FilesSuccessfulyDeleted)"/>
  </Target>
</Project>

Save the full content in a file called myfile.build and execute it from the command line

Behind the scenes

When executing the task, the MSBuild Code Factory will implement a task as follows and compile it before usage. Te below example is exactly the script generated for the above defined inline task.
Things to note:

1. Input and output parameters are exposed as public properties
2. Execute method contains the logic written in the inline task

The full source code:

//-------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.18010
//
//     Changes to this file may cause incorrect behavior and will be lost 
//     if the code is regenerated.
// </auto-generated>
//-------------------------------------------------------------------------

namespace InlineCode
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Text;
    using System.Linq;
    using System.IO;
    using Microsoft.Build.Framework;
    using Microsoft.Build.Utilities;


    public class DeleteFiles : Microsoft.Build.Utilities.Task
    {

        private bool _Success = true;

        public virtual bool Success
        {
            get
            {
                return _Success;
            }
            set
            {
                _Success = value;
            }
        }

        private string[] _FilesToDelete;

        public virtual string[] FilesToDelete
        {
            get
            {
                return _FilesToDelete;
            }
            set
            {
                _FilesToDelete = value;
            }
        }

        private bool _IgnoreErrors;

        public virtual bool IgnoreErrors
        {
            get
            {
                return _IgnoreErrors;
            }
            set
            {
                _IgnoreErrors = value;
            }
        }

        private bool _ShowErrors;

        public virtual bool ShowErrors
        {
            get
            {
                return _ShowErrors;
            }
            set
            {
                _ShowErrors = value;
            }
        }

        private string[] _DeletedFiles;

        public virtual string[] DeletedFiles
        {
            get
            {
                return _DeletedFiles;
            }
            set
            {
                _DeletedFiles = value;
            }
        }

        public override bool Execute()
        {

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

            if (this.FilesToDelete != null && this.FilesToDelete.Count() > 0)
            {
                foreach (string file in this.FilesToDelete)
                {
                    try
                    {
                        if (File.Exists(file))
                        {
                            File.Delete(file);
                            DeletedFilesList.Add(file);
                        }
                    }
                    catch (Exception exc)
                    {
                        if (this.ShowErrors == true)
                        {
                            Console.WriteLine("Deleting file " + file
                            + " failed because of " + exc.ToString());
                        }

                        if (this.IgnoreErrors == false)
                        {
                            break;
                        }
                    }
                }
            }
            this.DeletedFiles = DeletedFilesList.ToArray();

            return _Success;
        }
    }
}

Final Thoughts

I’ve learned about inline tasks while working on the above mentioned project and it turned out to be a great functionality as I didn’t want to fragment my script. Indeed I find Inline tasks are really great if you want to keep the MSBuild project script file external-reference free.
Per se, inline tasks are not more or less powerful than implementing c# Tasks, but I would say that inline tasks give us a bit less freedom i.e. in case we need to create some methods to be reused, or creating inline classes.

This is the second post of the series about how to load dynamically external content to a html page by using jQuery AJAX capabilities. If you want to know how to use the load() method please check the previous post.

There are mainly 4 ways of how jQuery library enables the AJAX requests, and this article covers the second one in the list.

1. using the load() function
2. using the get() function
3. using the post() function
4. using the ajax() function

Using the get() function

The get() method is responsible of loading the data from the server using a HTTP GET request. In reality, this method is an alternative version of the ajax() method that we are going to explore more in one of the next posts. In other words, get() hides the “complexity” of the ajax() method.

The signature of the get() method is as follows:

and it is a bit more complex that the previously seen load() method. The important thing to note here is that the url is the only mandatory argument.

• data: string that is sent with the request. this could be a query string for instance.
• success: is a callback function if the request will be successful.
• dataType: is the dataType expected to be returned: xml, json, script, or html.

a very interesting difference between the previously seen load() method and get(), is that the get() acts as a global function (indeed $.get() shows that), while the load() method on the other hand, is attached to a element.

Example of get() by using xml format

The example below shows how to dynamically retrieve xml data from another page, this could be a static page like in my case for this example, of a Web Service returning some xml dynamically. It doesn’t really make any difference.

In the example below, the javascript will load the data from xml_data.asp page, and if successful, execute the callback function. The whole logic is inside the callback itself. In the callback we parse the XML retrieved and displays an alert with the content of the name property.

$("#loadContent").click(function () {
    $.get('xml_data.asp', function(data) {
        var xml = $.parseXML(data),
        $xml = $(xml),
        $name = $xml.find("name");
        alert("Value retrieved from xml is: " + $name.text());
    });
});

Content of the mentioned xml_data.asp file is as follows

<?xml version="1.0" ?>
<customer>
	<name>John</name>
	<surname>Doe</surname>
</customer>

Try it live:

Example of get() by using json

The same example by using the before mentioned json format. get() method automatically recognizes the json data and returns a serialized object.
The content of the json_data.asp is as follows (this corresponds exactly to the previous xml example, but just in json notation).

{"customer":{
  "name": "John",
  "surname": "Doe"  
  }
}

The following is the javascript that would load the json data from json_data.asp file, and show the value of the customer’s “name” property.
Please note that “json” has been specified as the dataType parameter. Values returned are automatically serialized to json, as you may see the data is directly accessible via data.customer.name.

$("#loadContent").click(function () {
    $.get('json_data.asp', function(data) {
         alert("Value retrieved from json is: " + data.customer.name);
    }, 'json');
});

Try it live:

as you may see, the only difference between the xml and json versions is how we handle the data inside the callback function.

jQuery.getJSON method

jQuery contains another “shortcut” in order to simplify the execution of the json based data with the json specific method which signature is:

in reality, there is no difference between the previous get() a part the fact that we don’t need anymore to specify the dataType as we did previously.

$("#loadContent3").click(function () {
    $.getJSON('json_data.asp', function(data) {
         alert("Value retrieved from json is: " + data.customer.name);
    });
});

Try it live:

Short Conclusion

get() method offers a fairly simple way of dynamically getting xml and json data. It represents a simplified version of the ajax() call, which makes it fairly easy to use and to understand.

Stay tuned as in the next post we will see how to use the post() method.

This is the first post of the series about how to load dynamically external content to a html page by using jQuery AJAX capabilities.

If you are new to AJAX, please check this short introduction

on the other side

jQuery supports JSON, XML, HTML data formats, and supports both GET and POST methods, has an excellent cross browser support and all this is done by using a fairly simply API. All this makes jQuery a very powerful tool for a client side web developer.
As I won’t explain the basics of jQuery, in order to understand it better, please visit the jquery.com web site.

4 ways of performing AJAX calls

There are mainly 4 ways of how jQuery library enables the AJAX requests, and this covers only the first one.

1. using the load() function
2. using the get() function
3. using the post() function
4. using the ajax() function

Using the load() function

As stated on the jQuery web site, this method is the simplest way to fetch data from the server.

load() method signature is as follows:

where only the url parameter is the mandatory one, while the data and callback are optional. If the callback is specified, then this function will be executed after the call is completed, so there is a possibility to perform additional, post loading code.

In order to demonstrate how this works, below is provided an example, a static html page, that would load dynamically the content from another page into a div.

In the below example please note the following:

1. jquery script library is automatically downloaded from the jquery.com web site. This is a handy way of not hosting the library directly on your site as the jquery.com is highly optimized and the content download is really fast. you may opt for other sites offering the same functionality.
2. When the “loadContent” button is clicked, a function is attached to the event, and the load() function will be called.
3. The content of the external “Content.html” file will be loaded, if available, inside the div id="success"
4. In case of an error, the callback function will make sure that the content of the div id="error" will contain the error message

Content of the Index.html page:

<html>
<head>
    <script src="http://code.jquery.com/jquery-latest.js"></script>
</head>
<body>

    <input type="button" id="loadContent" value="Load" />

    <div id="success"></div>

    Error response:
    <div id="error"></div>

    <script>
    $("#loadContent").click(function () {

        $("#success").load("Content.html", function (response, status, xhr) {
            if (status == "error") {
                var msg = "Sorry but there was an error: ";
                $("#error").html(msg + xhr.status + " " + xhr.statusText);
            }
        });

    });       
    </script>
</body>
</html>

content of the “Content.html” page

<html>
<body>
    <h2>Title</h2>
    <p>
        Lorem ipsum dolor sit amet, consectetur adipiscing elit. 
        Praesent tristique mi in nulla lacinia imperdiet. 
        Nulla at tellus leo, porta viverra lectus. Mauris ac 
        purus vehicula lorem bibendum sodales id sodales 
        lorem. Donec tincidunt felis ac purus facilisis vulputate.
        Proin convallis interdum leo a ultrices. Cras neque ligula, 
        vestibulum nec venenatis vel, molestie non tortor. Ut tempor 
        risus ut diam dignissim nec adipiscing erat suscipit.
    </p>
</body>
</html>

the result, after pressing the load button will be:

Conclusion

In the next post I will describe the get() method, and provide a concrete example of usage.

Microsoft WCF framework is the Microsoft (de-facto) platform for developing SOAP Web Services. Even though in the latest .NET 4 version there are many improvements like: simplified configuration and better support for REST web services type, personally I have a love-hate relationship with it because I believe that is not the easiest platform to work on, especially when it comes to the configuration.

Dependency Injection

One of the first things that I had to deal with when creating the service was the support for IoC. In our specific case, as my team and I are familiar with and we already have a number of libraries written for Microsoft Unity Framework, that was our primary choice.

As there are many way of implementing the dependency injection in WCF, I found, what I believe one of the easiest ways of supporting IoC, without really writing any code. Our main choice was the Unity.WCF library that can be downloaded freely from the CodePlex site.

Unity.WCF

Taken from the Unity.WCF codeplex web site:

Unity.WCF is a library that allows the simple integration of Microsoft’s Unity IoC container with WCF. This project includes a bespoke InstanceProvider that creates a child container per client connection and disposes of all registered IDisposable instances once the connection is terminated.

Unity.WCF implements out of the box the support for Microsoft Unity and after installing the package through Nuget, you will be immediately ready to use and inject objects to your service. For the complete reference of how to do so, please check here

REST with Microsoft WCF

Microsoft WCF is a good platform to work when building SOAP based web services, it doesn’t shine when it comes to the implementation of REST Web Services. Actually Microsoft has recently released the ASP.NET Web Api framework that is build with only thing in mind, creating RESTful services. So, in general, it is strongly advised NOT to use WCF with REST as the full attention, and hence support and attention for future improvements, will be moved to the new ASP.NET Web Api framework.

I have recently described in one of the posts What technology to use when building Web Services in Microsoft.NET?, so check it out.

So, even after the above explanation, if your choice is to use Microsoft WCF for building RESTful services, and if you want the same support for dependency injection, you may still use Unity.WCF but you need to do some changes, that I am going to show in the next chapter.

Implementing a RESTful Web Service in Microsoft WCF

One of the differences when building the RESTful service is that it should be (but not necessarily) hosted in the WebServiceHost class rather than on the ServiceHost. The WebServiceHost class is a derived class from ServiceHost and it is specifically tailored for the RESTful services.

Unfortunately Unity.WCF at the time of writing doesn’t support out of the box the support for the WebServiceHost, as internally uses the ServiceHost to host any type of service.

In order to get over this “limitation” we need to extend Unity.WCF, and it is pretty much straightforward. We will accomplish this by implementing two new classes that internally would use the infrastructure already offered by Unity.WCF, and that would be used to host the REST Web Service through WebServiceHost:

1. UnityWebServiceHost that mimics the existing Unity.WCF’s UnityServiceHost and
2. UnityWebServiceHostFactory that mimics the existing UnityServiceHostFactory

UnityWebServiceHostFactory

Note: This class inherits from WebServiceHostFactory.

public abstract class UnityWebServiceHostFactory : WebServiceHostFactory
{
    protected abstract void ConfigureContainer(IUnityContainer container);

    protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses)
    {
        var container = new UnityContainer();

        ConfigureContainer(container);

        return new UnityWebServiceHost(container, serviceType, baseAddresses);
    }
}

UnityWebServiceHost

Note, this class inherits from WebServiceHost

public class UnityWebServiceHost : WebServiceHost
{
    public UnityWebServiceHost(IUnityContainer container, Type serviceType, params Uri[] baseAddresses)
        : base(serviceType, baseAddresses)
    {
        if (container == null)
        {
            throw new ArgumentNullException("container");
        }

        ApplyServiceBehaviors(container);

        ApplyContractBehaviors(container);

        foreach (var contractDescription in ImplementedContracts.Values)
        {
            var contractBehavior =
                new UnityContractBehavior(new UnityInstanceProvider(container, contractDescription.ContractType));

            contractDescription.Behaviors.Add(contractBehavior);
        }
    }

    private void ApplyContractBehaviors(IUnityContainer container)
    {
        var registeredContractBehaviors = container.ResolveAll<IContractBehavior>();

        foreach (var contractBehavior in registeredContractBehaviors)
        {
            foreach (var contractDescription in ImplementedContracts.Values)
            {
                contractDescription.Behaviors.Add(contractBehavior);
            }
        }
    }

    private void ApplyServiceBehaviors(IUnityContainer container)
    {
        var registeredServiceBehaviors = container.ResolveAll<IServiceBehavior>();

        foreach (var serviceBehavior in registeredServiceBehaviors)
        {
            Description.Behaviors.Add(serviceBehavior);
        }
    }
}

RestBootstrapper

RestBootstrapper is a class that will be used to configure our dependency injection code, and the facto, the Service1.svc should point to this file, as shown below:

public class RestBootstrapper: UnityWebServiceHostFactory
{
    protected override void ConfigureContainer(IUnityContainer container)
    { 
        //your configuration goes here...
        container.RegisterType<IService1, Service1>()
            .RegisterType<IDataRepository, DataRepository>();
    }
}

Service1.svc

<%@ ServiceHost Language="C#" Debug="true" 
                Service="REST.Web.Service.Service1" 
                CodeBehind="Service1.svc.cs"
                Factory="REST.Web.Service.RestBootstrapper" %>

web.config file

Obviously from the web.config point of view, if we want to host the service in IIS, the web.config should be configured as follows:

<system.serviceModel>

  <!--Configuration of the services exposed by this host.-->
  <services>
    <service name="REST.Web.Service.Service1">
      <endpoint address=""
                binding="webHttpBinding"
                bindingConfiguration="webBinding"
                behaviorConfiguration="poxBehavior"
                contract="REST.Web.Service.IService1"/>
    </service>
  </services>

  <!-- BEHAVIORS -->
  <behaviors>
    <endpointBehaviors>
      <!-- plain old XML -->
      <behavior name="poxBehavior">
        <webHttp helpEnabled="true" automaticFormatSelectionEnabled="true"/>
      </behavior>      
    </endpointBehaviors>
  </behaviors>

  <!--BINDINGS-->
  <bindings>
    <webHttpBinding>
      <binding name="webBinding"/>
    </webHttpBinding>
  </bindings>

  <serviceHostingEnvironment multipleSiteBindingsEnabled="true"
                              aspNetCompatibilityEnabled="false">
  </serviceHostingEnvironment>
</system.serviceModel>

Conclusion

Unity.WCF is a really easy to use library and offers out of the box support for dependency injection on WCF. Actually, there are other libraries by the same author for MVC, etc, so you might check this out. Support for REST through WebServiceHost is not supported, but as shown above, it is very easy to achieve.

I hope that you enjoyed this article, if so, please consider writing a comment in case you think there are improvements to be done or in case there are alternative or easier ways of achieving this.

Microsoft Visual Studio 2012 comes with a large amount of new features and improvements in almost all areas. The changes introduced in the “unit testing” and generally “testing” area are very significative.
I’ve read the following sentence in one of the Microsoft slides and I couldn’t agree more:

Architecture

Microsoft was working on making the testing framework extensible, indeed it allow us to use other testing frameworks such as xUnit.net and Nunit, something that in the past, in order to have something built into Visual Studio we had to use external plugins such as Resharper or others. All this can be seen in the below picture that depicts the current Microsoft Visual Studio Unit Test Platform that is in fact a Unit Test Runners-Runner. Yes, the responsibility of this layer is to run the third party unit test runners and it is supposed to be the “glue” between the user and the actual underlying unit testing framework.

Test Explorer

Visually, the most important addition to the Visual Studio Unit testing is the so called Test Explorer

Test explorer supports a number of features (as illustrated in the picture) such as:

• Search: it is possible to search within the test names and execute only those displayed in the search
• Red-Green bar: Bar at the top of the window will display if the tests have been failed (red) or if everything have run smoothly.
• Most important tests will be shown first (at the top)
• Timings: Each tests has the duration so we can see quickly how long it takes for a test to execute and fix it if it runs slowly.
• Shows tests from any framework.
• Run details: there are details being shown in the bottom part that will tell why the test failed or other information.

Code Coverage

Code coverage is a measure used in software testing. It describes the degree to which the source code of a program has been tested.

In the picture below you may see how the information are displayed directly in Visual Studio showing which part of the code haven’t been covered tested (in red) with a number of statistics around it.

Previously in order to see such number of statistics we had to use third party tools such as NCover, JetBrains dotCover or others.

Isolating code for better testing

There is another improvement named VS11 Fakes framework that lets us isolate almost anything in .NET. There are two flavors of fakes:

• Stubs: concrete implementations of interfaces or abstract classes. VS offers an easy way of creating stubs something that we previously had to do manually or using third part frameworks such as Moq, or others. It is not fully a replacement but a good start.
• Shims: run-time interception lets you replace calls, even those from the .NET Base Class Library.

Check this and this videos if you like to see how to use the new Visual Studio 2012 fakes framework.

Fakes and shims visually represented:

(c) Microsoft.com

Continous Testing

Continous testing in Visual Studio 2012 gives a possibility of continuously running the tests withing the solution. It helps you with the way you do TDD by taking care of all compiling and testing in the background to help you work more efficiently.

This framework could potentially replace the third party tools such as ContinousTest, NCrunch, or others.

Conclusion

Visual Studio 2012 has a list of improvements that will make the unit testing simpler and effective. The number of features is quite large so I encourage you further check and experience it by yourself. As I haven’t had the time to fully try all the above explained items, I am not yet sure if the above listed features would replace the other third party frameworks, but this is already a good step forward. Microsoft is showing us that it is moving into the right direction.