Should I transform Entity (Persistent) objects to DTO objects?

Question

My project is layered as follows: -

DAL (Entity) --> BLL (DTO) --> ApplicationComponent (ViewModel).

There will be multiple components of application (ApplicationComponent) which will access BLL. Components include windows services, web services, web API and MVC controller.

I am transforming NHibernate Entity objects to DTO objects while passing them from DAL to BLL. While passing this state to ApplicationComponent, BLL again converts it to ViewModel.

This helps me separate the concerns and how data is handled in each layer. I am not in favour of returning NHibernate Entity object to view for following reasons: -

• Data get exposed to UI that I want to hide (or only expose if needed) like passwords, user type, permission etc.
• On references/joins, NHibernate executes additional queries when property is accessed which nullify the use of lazy loading.
• Unnecessary data exposed to user (of Entity) creates confusion and gap for bugs.
• Persistence implementations leaking into BLL/UI. Entity is not designed for UI. It cannot serve UI in all cases.
• We use attributes on DTO properties for user input validation which looks odd with Entity.

I am facing following problems with this approach: -

• Biggest and obvious problem is redundant objects with same functionality.
• I have to write mapper methods in each layer to transform object. This could be minimized by using AutoMapper or something similar; but it does not fully resolve problem.

Questions: -

• Is this an over separation and should be avoided (at least minimized)?
• If this approach is correct, I do not see any simple way to fully bypass two problems I stated above. Please suggest.
• If this approach is incorrect, please suggest corrections.

References: -

1. Link1 suggests to transfer Entity object to view which in my understanding not a good idea.

2. Link2 suggests to map Entity with DTO that I am already in agreement.

3. Link3 does not help.

4. Link4 suggests using something like auto mapper tools which is ok. But it still does not solve the problem completely.

5. Link5 is great post. It explains why those should be separate which I am in agreement. It does not comment on how to minimize the overhead caused by it.

6. Link6 is not helpful again.

Edit 1:

I just read this excelent answer which suggests use Entity as is in UI if possible. It still does not apply to most of my project.

Edit 2:

Another excellent post suggest to go on mapping two way as I am doing now. It still does not suggest a way to minimize overhead.