Serdar EMIRCI Blog ASP.NET C# T-SQL Java

Difference between Mocks and Stubs.

There are nowadays two terms that are used by the developers : 'stub' and 'mock'. As I found in

the article of Martin Fowler 'Mocks Aren't Stubs', he is using the vocabulary of Gerard

Meszaros's book, where there is the division into : 'dummy', 'fake', 'stub' and 'mock' points.

I'll metnion only what 'dummy' and 'fake' are, and I'll try to concentrate over 'mock' and

'stub'. So 'dummy' objects as Thesaurus says represents a copy, figure, form, model in its mean.

In reallity passing to developper language, the goal of dummy objects is to be passed, in this

sence the general use of dummy objects is to fill parameter lists. I should metion that 'dummy'

objects do not have their working implementation. If we are speaking about 'fake' objects, than

from the beginning we must emphasize that these type objects have their implementations, an

important point of distinguishing here is that 'fake' objects are not used for production, they

represent something like an alternate route, timesaving method. For example an SQLLite database

represents a 'fake' object.
In the following part of this article I'll try to concentrate on two important concepts: 'stub'

and 'mock'. Many often confuse these terms speaking about them as about the same thing. From the

conceptual point of view they both represent methodologies that share some common things. I

thinks there is also an historical motivation of the confusion between them: from the first

appeared the therm 'stub' and it was used for a long period of time, when in some communities

appeared and started to be used the them of 'mock'. On the first glance they are suitable to

accomplish the same things. I can caracterize a 'mock' as an imitation or make-believe, and a

'stub' as a dock. The 'mock' object request the behavior check, while 'stub' is for state check.

The 'mock' represents an object that englobes a specification of expectations for the calls it is

expected to receive, while 'stub' represents preserved answers to requests that are made during

the test ( as a rule, the 'stub' does not respond to smth else that's programmed especially for

the test).

We'll examine an example of using 'mock' and 'stub' in the same scenario and we'll get deeper

into discussion based on some code. So we have the situation that based on the number of users on

a portal, the owner of the portal receives an sms on his mobile phone to be informed about the

event. Let's assume that at 100.000 visitors he gets a message about this. We'll use Rhino Mocks

and NUnit for our testing purposes.

Class Msg - a simple CLR object that encapsulates the message to be send via SMS:

public class Msg
{
private string message;
public Msg(string message)
{
this.message = message;
}

public string Message
{
get
{
return message;
}
set
{
message = value;
}
}
}

Interface IServiceSMS contains the method Send() for sending the SMS:

using TheDiff.BusinessObjects;

namespace TheDiff.Interfaces
{
public interface IServiceSMS
{
bool Send(Msg msg);
}
}

Class for tests MockTests:

using Rhino.Mocks;
using NUnit.Framework;
using TheDiff.BusinessObjects;
using TheDiff.Interfaces;

namespace TheDiff
{
[TestFixture]
public class MockTests
{
private IServiceSMS serviceSMS;
[SetUp]
public void SetUp()
{
serviceSMS = MockRepository.GenerateMock();
}

[Test]
public void Mocker()
{
var msg = new Msg("Online users are 100.000!");
serviceSMS.Expect(x => x.Send(msg)).Return(true);
var wasSent = serviceSMS.Send(msg);
Assert.IsTrue(wasSent);
serviceSMS.VerifyAllExpectations();
}

}
}

Class for tests StubTests:

using Rhino.Mocks;
using NUnit.Framework;
using TheDiff.BusinessObjects;
using TheDiff.Interfaces;

namespace TheDiff
{
[TestFixture]
public class StubTests
{
private MockRepository mocks;
private IServiceSMS serviceSMS;
[SetUp]
public void SetUp()
{
mocks = new MockRepository();
serviceSMS = mocks.Stub();
}

[Test]
public void Stuber()
{
var msg = new Msg("Online users are 100.000!");

using (mocks.Record())
{
SetupResult.For(serviceSMS.Send(msg)).Return(true);
}
var wasSent = serviceSMS.Send(msg);
Assert.IsTrue(wasSent);
}

}
}

Best .NET ORM Tool

My Considerations

Until now I used some custom orm tool (written by me), it was working with stored procedures, because my idea is that the best optimization you may accomplish in sql code. But now as the project increased and its fonctionality has blow up, I realise that in the future must be used some more adapted orm for supporting Domain Model and Data Mapper, with wich can be used in a more simple fashion the concepts of Unit of Work, Repositories etc. I indeed fell the necessity to pass to this kind of aproach because Transaction Script approach that I used in conjuction with Data Mapping leads in hard maintenace problems when in enterprise application you have sophisticated workflows and transactions to be performed.

I spent some time searching through the existing ORM Mappers (commercial and not only), of course my idea was to find a free mapper, but if another commercial tool is more powerful in the sence that it offer more access in using the enterprise patterns and it's more flexible, than it can be used instead.

My decision was in favor of NHibernate. First of all it's ported from java environment and has proven its viability over the years and the multitude of serios projects based on it. Of course we can describe different pros and cons of using it, and other OPRMs such as SubSonic or LBLGEN. But in fact with some more or less effort the things are pretty well done with NHibernate. Second of all it's not as complicated as it seems at first glance, you'll discover that at first examples that you'll do with it. Third it offers very clean and separated approach to perform the necessary operations, I was excited of the granularity that it offers comparing to other similar tools.

I dislike the fact that more and more vendors try to make their ORMs more simple to use by not allowing the developper to dive into some subtle things that in the end lead to optimisations, that's crucial for serios applications. From my point of view the best approach are stored procedures, because you may fine tune their granularity as you wish, but from the maintenace point of view it's not the best solution. After this approach the best one will be this NHibernate. During surfing the web you can find different tests on the efficiency of this tool compared to other such as EntityFramework and LINQ. I can emphasize that in practically all cases NHibernate generates less sql code than those mentioned. NHibernate is the most closely to pure ADO.NET efficiency. That's why I recommend it.

Performance Tests

Next I'll show you the results of some tests:

The results of the tests several unusual. First, I ran the queries of each test in one set and looked at Query cost for each query, which is about the whole set.

In the first test, I got the following results:

Classic ADO.NET - 15%
LINQ 2 SQL = 48%
Entity Framework - 23%
Active Record (NHibernate) - 15%

The interesting thing here is that LINQ 2 SQL is indeed slowerthan the request performed by EntityFramework.

In the second test, I have a complex query with joins for LINQ 2 SQL:

Complex queries with joins - 24%
A set of simple queries - 76%

As you can see, one request has won, it's not surprising. However, in general, we can say that in terms of databases losses are not as lazy loading too long.

The third test was for EntityFramework:

Complex queries with joins - 19%
A set of simple queries - 71%

As you can see, the results are practically similar.

The forth test was for NHibernate:

Complex queries with joins - 8%
A set of simple queries - 92%

So now you can see by yourself and make some base ideas on how it is.
List of .NET ORM Tools

Next I'll give a list with good .NET ORM Tools, and you may compare them by yourself:

Domain Driven Design

I want to mention SharpArhitecture project. This represents a solid architectural foundation for rapidly building maintainable web applications leveraging the ASP.NET MVC framework with NHibernate.

What I want here is to show some advantages/disadvantages and the points of interested that I faced up. So when analysing the possibilities that this code offers, I discovered that :

1) NHibernate validation is not suitable for a series of scenarious that mostly enterprise level applications require. Let's assume that we have the following scenario: there is the entity 'case' and this entity should be introduced (inserted) in our system by the worker with position 'Secretary'. The Secretary shoul introduce only the CaseName. Later the worker that is in position 'President' should alter the case and set the number.

public class Case
{
public virtual int Id { get { return id; } }

[NotEmpty, NotNull]
public virtual string CaseName { get ; set ; }

[Email]
public virtual string Email { get ; set ; }

[Min(20000, Message="The number should be greater than 20000!")]
public int Nr{ get ; set ; }

///...
}

In the scenario described above we better have also 2 validation scenarious. It's a simple case, but assume that when creating the record the number should be greater than 20000 and when updating the record the Number should be less 2000. Of course non-sense here, but assume it's a custom scenario. Than in this case the NHibernate validators are not suitable for accomplishing the validation.

I solved this issue by eliminationg the Nhibernate validators and pass to FluentValidation framework. Now I have different validator classes for different scenaious. It's more flexible approach and gives the power of more deep validation.

The advantage is considerable we don't tie the validation to the entity. We have in my case:

public class Case
{
public virtual int Id { get { return id; } }

public virtual string CaseName { get ; set ; }

public virtual string Email { get ; set ; }

public int Nr{ get ; set ; }

///...
}

and some classes for validation with structure similar to:

public class CaseValidator:AbstractValidator

{

public CaseValidator(){}

RuleFor(x=>x.CaseName).NotEmpty();

RuleFor(x=>x.CaseName).NotNull();

//..

}

that have different set of rules for validation that meets my custom scenarious.

What is C#? Windsor CT

C# is a new programming language introduced by Microsoft. This article, excerpted from Sams Teach Yourself C# in 21 Days provides an overview of what C# is and why it is important.

Have you heard of C# (pronounced See-Sharp)? It would not be unusual if you didn't know a lot about the language. Released to the public in June 2000, C# has not been around for very long.

C# is a new language created by Microsoft and submitted to the ECMA for standardization. This new language was created by a team of people at Microsoft led by Anders Hejlsberg . Interestingly, Hejlsberg is a Microsoft Distinguished Engineer who has created other products and languages, including Borland Turbo C++ and Borland Delphi. With C#, they focused on taking what was right about existing languages and adding improvements to make something better.

C# is a powerful and flexible programming language. Like all programming languages, it can be used to create a variety of applications. Your potential with C# is limited only by your imagination. The language does not place constraints on what you can do. C# has already been used for projects as diverse as dynamic Web sites, development tools, and even compilers.

C# was created as an object-oriented programming (OOP) language. Other programming languages include object-oriented features, but very few are fully object-oriented. In my book you can learn how C# compares to some of these other programming languages. My book also covers what it means to use an object-oriented language as well as the details of doing object-oriented programming with C#.
Why C#?