data-access-layer

What is actually better? Having classes with complex queries responsible to load for instance nested objects? Or classes with simple queries responsible to load simple objects? With complex queries you have to go less to database but the class will have more responsibility. Or simple queries where you will need to go more to database. In this case however each class will be responsible for loading one type of object. The situation I'm in is that loaded objects will be sent to a Flex application (DTO's). The general rule of thumb here is that server roundtrips are expensive (relative to how

In separate data access & business logic layer, can I use Entity framework classes in business layer? EDIT: I don't think I will need to swap out the data access layer from my business logic in the future (i.e. will be SQL Server), however I will for the UI layer. Therefore the question is more meant to be are there any major issues with using EF classes for me in the business layer? Seems like there would be less plumbing code. Typically, the "best practice" approach would be something like this: in your Data layer, you have EF entities that get loaded from and stored back to the database in

I'm interested in perceived "best practice", tempered with a little dose of reality here. In a web application, do you allow your web tier to directly access the DAL, or should it go through a BLL first? I'm talking specifically of scenarios where there's no "business logic" really involved -- such as a simple query : "Fetch all customers with surname of 'Atwood'". Scenarios where there's any kind of logic absolutely are gonna go through the BLL, so lets call that moo . While you could encapsulate this method inside a BLL object, it seems to be somewhat pointless when often the signature will

I am actually stuck in 3-tier structure. I surfed the internet and found two terminologies "Database Abstraction Layer" & "Data Access Layer". What are the differences between the two? Lotus Notes My understanding is that a data access layer does not actually abstract the database, but rather makes database operations and query building easier. For example, data access layers usually have APIs very similar to SQL syntax that still require knowledge of the database's structure in order to write: $Users->select('name,email,datejoined')->where('rank > 0')->limit(10); Data abstraction layers are

I know these questions have been asked before, I'll start by listing a few of them (the ones I've read so far): IEnumerable vs IQueryable List, IList, IEnumerable, IQueryable, ICollection, which is most flexible return type? Returning IEnumerable<T> vs. IQueryable<T> IEnumerable<T> as return type https://stackoverflow.com/questions/2712253/ienumerable-and-iqueryable Views with business logic vs code WPF IEnumerable<T> vs IQueryable<T> as DataSource IEnumerable<T> VS IList<T> VS IQueryable<T> What interface should my service return? IQueryable, IList, IEnumerable? Should I return IEnumerable<T>

I'm near the beginning of a new project and (gasp!) for the first time ever I'm trying to include unit tests in a project of mine. I'm having trouble devising some of the unit tests themselves. I have a few methods which have been easy enough to test (pass in two values and check for an expected output). I've got other parts of the code which are doing more complex things like running queries against the database and I'm not sure how to test them. public DataTable ExecuteQuery(SqlConnection ActiveConnection, string Query, SqlParameterCollection Parameters) { DataTable resultSet = new DataTable

I am thinking about using transactions in 2-tier WPF (or windows forms) applications in following way: We can begin new transaction when we open new form for editing data, edit and persist changes transparently in this transaction. Then we can click "OK" button and commit transaction, or "Cancel" button and rollback it. If we want to open another dialog window with this data, we can use nested transactions. The question is: Is this way of using transactions acceptable or not? I know that there are a lot of different ways to implement such logic, but I'd like to list advantages and