Following the suggestion from Scott and Jeff, I decide to have ELMAH implemented in my current ASP.NET application as well. The whole progress is really straightforward and painless. Most of the work is to modify the application’s web.config file.

• Download the latest version of bin, currently 1.0 version, from project’s web site, hosted on Google code.
• Based on the version of your ASP.NET application, reference the corresponding Elmah.dll from the subfolder. You might need to reference SQLite.dll if you need to use SQLLite for the log storage.
• Modify the Web.config based on the sample Web.config file coming with the sample. You can check it from here as well.

That is it! Then you can find the unhandled exception by access http://yourwebsite/elmah.axd. You will see the error page is something like

From what I see so far, ELMAH is

• Easy to implement and set it up
• Flexible to offer multiple log storage providers, including SQL Server, SQLLite, Oracle, XML, and In-memory.
• Readable, the log is formatted in a HTML table, which can be also export to CVS file and be queried by Microsoft’s Log Parser tool.
• Reliable, it provides multiple notification channels, including Email, RSS and even Tweet.

Just as Jeff Atwood said in his blog above, the main purpose of setting up ELMAH in our application is to find out the accurate, valuable and real time “feedback” of the applications we built automatically.

Happy coding, till next time!

One the of the tips I heard to become a productive developer is to use mouse as few as possible, put the fingers on the keyboard.

Mouse clicking is sort of distraction from we are doing. Combining with any of the launcher tool, such as Slickrun, you will find you can definitely accomplish your work faster, more effectively and a lot fun!

Don’t try to memorize all of them at once. When you feel you need to use mouse, just do some search to see if any shortcut available. Here is the list I am using a lot as a .NET developer (visual studio and Resharper, of course!)

Here are some of the window-based shortcuts I collected and use very often. Hope it will help.

• Visual Studio shortcut keys
• Resharper shortcut keys (visual studio schema)
• Window common shortcut keys
• Web browser common Shortcut keys
• Firefox shortcut keys
• Microsoft IE shortcut keys
• Microsoft Excel shortcut keys
• Microsoft Word shortcut keys

Visual Studio Shortcut Keys

Basic Windows shortcut keys

Web Browser common shortcut Keys

Mozilla Firefox shortcut Keys

Internet Explorer Shortcut

Microsoft Excel

Microsoft Word

I had a lot of fun to read Tomas Petricek’s article, "Concepts behind the C# 3.0 language". Instead of listing all of the new syntax changes as most of other tutorials, Tomas shed some lights on the details about influence of the development of C# 3.0 from other languages, especially how Functional programming plays in C# 3.0. Actually, Lambda Expression and LINQ are really part of that.

So what is functional programming? Quote from Wikipedia:

"Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data. It emphasizes the application of functions, in contrast with the imperative programming style that emphasizes changes in state.^[1] "

So what it really tells us? I think the main point is "function is data" which means function can be use to be passed as an parameter or returned argument or modified as any other data in our application. Do we gain benefit for that? Sure, we do.

1. Functional programming can help model data operation. Here is the sample:

1 private static long Watch<T>(Action<T> act, T arg)
2 {
3         Stopwatch watch = new Stopwatch();
4         watch.Start();
5         act(arg);
6         watch.Stop();
7         return watch.ElapsedMilliseconds;
8 }

This Watch function is totally decoupled with the Action, which could be "reading the data from database", or "processing the data from a file". It leads a clean design that Watch function and the Action function can be tested separately.

2. Parallel programming. If you have been worked on Multi-thread programming. You know how hard it is. The limitation of imperative language like C# focuses on the state change. But functional programming is passing function as argument as we mentioned above. The state actually is only closed in the function boundary. So there is no other thread can access that data. Microsoft has released PLINQ, a parallel programming add-on to current .NET framework 3.5. It will be a huge benefit for any .NET who will take advantage of multi-processor computers.

So far, so good, right? from next one, I will illustrate the functional programming features in C# 3.0. Definitely will show more code. Please stay tune.

My previous blog is about using DTO in UI/Presenter layers. Just studying Nhibernate source code now, I find a very interesting approach to populate DTO object directly from Nhibernate with Criteria and Projections.
Here is the code:

   1:  IList resultWithAliasedBean = s.CreateCriteria(typeof(Enrolment))

   2:   .CreateAlias("Student", "st")

   3:   .CreateAlias("Course", "co")

   4:   .SetProjection(Projections.ProjectionList()

   5:   .Add(Projections.Property("st.Name"), "studentName")

   6:   .Add(Projections.Property("co.Description"), "courseDescription")

   7:  )

   8:  .AddOrder(Order.Desc("studentName"))

   9:  .SetResultTransformer(NHibernate.Transform.Transformers
  10.  .AliasToBean(typeof(StudentDTO)))

  11:  .List();

The Element and StudentDTO is simple enough.

   1:          [Serializable]

   2:      public class Enrolment

   3:  

   4:          private Student student;

   5:          public virtual Student Student

   6:          {

   7:              get { return student; }

   8:              set { student = value; }

   9:          }

  10:  

  11:          private Course course;

  12:          public virtual Course Course

  13:          {

  14:              get { return course; }

  15:              set { course = value; }

  16:          }

  17:  

  18:          private long studentNumber;

  19:          public virtual long StudentNumber

  20:          {

  21:              get { return studentNumber; }

  22:              set { studentNumber = value; }

  23:          }

  24:  

  25:          private string courseCode = string.Empty;

  26:          public virtual string CourseCode

  27:          {

  28:              get { return courseCode; }

  29:              set { courseCode = value; }

  30:          }

  31:  

  32:          private short year;

  33:          public virtual short Year

  34:          {

  35:              get { return year; }

  36:              set { year = value; }

  37:          }

  38:  

  39:          private short semester;

  40:          public virtual short Semester

  41:          {

  42:              get { return semester; }

  43:              set { semester = value; }

  44:          }

  45:  

  46:          public override bool Equals(object obj)

  47:          {

  48:              Enrolment that = obj as Enrolment;

  49:              if (that == null)

  50:                  return false;

  51:              return studentNumber == that.StudentNumber && courseCode.Equals(that.CourseCode);

  52:          }

  53:  

  54:          public override int GetHashCode()

  55:          {

  56:              return courseCode.GetHashCode();

  57:          }

  58:      }

  59:  public class StudentDTO

  60:      {

  61:          private string studentName;

  62:          private string courseDescription;

  63:  

  64:          public StudentDTO() { }

  65:  

  66:          public string Name

  67:          {

  68:              get { return studentName; }

  69:          }

  70:  

  71:          public string Description

  72:          {

  73:              get { return courseDescription; }

  74:          }

  75:      }

What we can do is to retrieve StudentDTO from Presenter by querying from Repository. Code is elegant and beautiful. How sexy NHibernate is!!

DTO (Data Transfer Object)is a very common used pattern in enterprise applications. Martin Fowler also documented it in his class book “Pattern Enterprise Application Architecture“. In the meanwhile, DTO is also a very famous “Anti-Pattern”. The pure OO purist think DTO is a devil. It is so easy to build. The object become nothing but a simple data container, which represent the data in the tables instead of the real domain objects. The business logic embedded in the application is going to shift from middle domain logic tier to tables, most of time spreaded among the stored procedures, which is leading to a unmaintainable solution.

So should we give up DTO totally in our application design? Absolutely not, in the other end, I find DTO still useful especially in UI and UI process layers. For example, we have a complex searching page to find customer by first name, last name, SSN, address, phone, email, and so on. those information may stay in different domain objects. It is also very hard to design a method with a very long list of parameters, not just ugly but also unmaintainable. My approach is to design DTO object pass data between UI and UI process (Presenter or Controller). Then access the service objects, and domain objects from presenter/controller. So I can design domain entity with the interfere from the special requirement of UI. Again it is important to implement MVP pattern to protect the domain object, which is also one of the important principles I heard from DDD: don’t leak business logic out of the domain object layer.

I read a story today which make me falling into deep thinking…

“During the space race back in the 1960’s, NASA was faced with a major problem. The astronaut needed a pen that would write in the vacuum of space. NASA went to work. At a cost of $1.5 million they developed the “Astronaut Pen”. Some of you may remember. It enjoyed minor success on the commercial market.

The Russians were faced with the same dilemma. They used a pencil. “

from here.

Inspired by Eric Even’s excellent book, Domain Driven Design,
I have been studying and using domain driven design for a while. There have a lot of advantages offered by implementing DDD in enterprise applications. I will continue to blog what I learned from DDD later. Among those advantage, one of the most important is to clearly lay out the resposibilites for the classs in the doma layer, such as Entity, Value Object, Service, Repository and Fractory. There has a question always in my mind that if we have move application operations to service class. What methods we need to implement for Entity class? We are trying to avoid AnemicDomainModel. So how do we design our Entity class? Here comes the answer:

“The best definition of “domain object” I’ve found in literature is in Chapter
11 of TimHoward’s book TheSmalltalkDevelopersGuideToVisualWorks
pp.379-381:

“a domain object is a logical container of purely domain
information, usually represents a logical entity in the problem domain space …
In general, domain objects should know how to
recognize which [of their]
references indicate aggregation and which ones indicate association
copy
themselves
maintain business logic
compare themselves to other domain
objects of the same type
facilitate other objects that choose to print or
display them
conduct tests on their domain information”
To this list I
would add
identify themselves
validate themselves
–RandyStafford
I would also
add
domain objects direct their persistence
there may be collections of
Domain objects
domain object may contain references to other domain objects
(this is assumed by the first one above).
–Fritz Schenk “

Quote from http://c2.com/cgi/wiki?DomainObject

Currntly I am working on a NAnt script to update all of our open source project source. Basically I need to use checkout and update taskes for SVN and CVS. Using and is smooth, if you have the lastest Subversion (currently 1.4.2) installed . But and will cause issues since it seems that cannot work nicely with . I got a problem that I cannot successfully login to the server. After done some research, here is the workaround.
1. Dowonload the lastest CVSNT.
2. Put cvs.exe into the Nant bin folder.
3. Turn attribute “usesharpcvslib” to false.
Example:

Jeremy has organized his best posts in the last three years. Please check it out frm there. I think I have learned a lot from Jeremy’s postes. Great stuff include MVP pattern, TDD (Test-Driven Development), Mock Object, Depencency Injection, and so on. Every single post from his is worth reading. By the way, just happen to know he is goint to write a book. It must be a MUST READ.

Jean-Paul Boodhoo from ThoughtWorks has published an excellent article regarding how to implement MVP (Model-View-Presenter) pattern in ASP.NET. It acutally has very similar implementation I am using currently. The only difference is I declear event in the view, so that ASP.NET page use event to notify the presenters, which makes more loosely coupled between ASP.NE page and presenter. I also use DTO (Data Transfer Object) to pass the data through. Although DTO seems as a Core J2EE Pattern, I still have a concern to use it extensively, becasue DTO is totally against the Object-Oriented principals. It promotes a FLAT object, a really value object. Since I have developed my domain objects with NHibernate/Castle ActiveRecord, it duplicates the efforts as well. The main purpose of using DTO is to utilize the ASP.NET databinding features. Paul Wilson seems to work on a solution to map domain objects to UI. It seesm very intertesting. But I have not seen any sample code yet. Anybody has a better solution?