Restructuring my application

Question

I am handling a project which needs restructuring set of projects belonging to a website. Also it has tightly coupled dependency between web application and the dependent project referenced. Kindly help me with some ideas and tools on how the calls could be re factored to more maintainable code.

The main aspect is that there are calls to apply promotion (promotion class has more than 4 different methods available) consumed from various functions, which could not be stream lined easily.

Kindly help me here with best practices.

Sorry guys- i could not share much code due ot restriction, but hope the below helps

My project uses N-Hibernate for data access Project A- web project - aspx and ascx with code behind Project B- Contains class definition consumed by project C (data operation class) Project C - Business logic with saving to database methods (customer, order, promotion etc.)

The problem is with project C - which i am not sure if it does too many things or needs to be broken down.But there are already many other sub projects.

Project C supports like saving details to DB based on parameters some of the class methods in this calls the promotion based on some condition, I would like to make things more robust - sample code below

Project -C Class - OrderLogic

public void UpdateOrderItem(....)
{
....
....
...
}
Order order = itm.Order;
promoOrderSyncher.AddOrderItemToRawOrderAndRunPromosOnOrder(itm, ref order);
orderItemRepository.SaveOrUpdate(itm);

So just like the above class the promotion is called from may other places, i would like to streamline this calls to promotion class file. So i am looking for some concepts.

Sharing your research helps everyone. Tell us what you've tried and why it didn’t meet your needs. This demonstrates that you’ve taken the time to try to help yourself, it saves us from reiterating obvious answers, and most of all it helps you get a more specific and relevant answer! Also see [how to ask](http://stackoverflow.com/questions/how-to-ask) — CoderDennis, Apr 18 '15 at 15:56
Stackoverflow is about code. Share your code with us and we might be able to give some feedback on that. Besides that, one of the most important design patterns that I use in my code is [this one](https://www.cuttingedge.it/blogs/steven/pivot/entry.php?id=91). — Steven, Apr 18 '15 at 16:16

score 1 · Accepted Answer · answered Apr 18 '15 at 19:15

Most important in any project, especially web projects that often need to communicate with a persistent layer is to leverage dependency injection.

But before you do that, you need to make sure that the classes that provide services to communicate with the database all have an interface. Typically these classes are called data access objects (DAO). So, you'd have something like:

public class UserDao : IUserDao
{
     public User GetUserById(int id)
     {
        ...
     }
}

As a rule of thumb, for these data access objects, if they contain conditional logic then you should probably refactor that out into a more business oriented service (class). It's best that your interface to the database contain has little logic as possible. It has to be thin because this layer is hard to unit tests because of its dependency on the database.

Once you've done this, use a dependency injection container and register IUserDao and its implementation.

Now, moving forward, you'll be able to create unit tests that completely mocks that database by mocking the UserDao implementation.

May I suggest:

Microsoft Unity for dependency injection
FakeItEasy for unit testing mocking framework

Other fine ones:

Castle Windsor (DI)
Ninject (DI)
RhinoMocks (unit test - mocking framework)

Good luck! Hope it helps.

score 1 · Answer 2 · answered Apr 19 '15 at 13:35

I strongly suggest not to start restructuring your application without a strong knowledge of SOLID principles and dependency injection. I did this mistake and now I have an application full of service locator (anti)pattern implementations that are not making my life simpler than before.

I suggest you to read at least the following books befor starting:

http://www.amazon.com/Agile-Principles-Patterns-Practices-C/dp/0131857258 (for SOLID principles)

http://www.manning.com/seemann/ (for .NET dependency injection)

http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052

A possible strategy is not refactoring just for the sake of it, but consider refactoring only the parts that are touched more than others. If something is working and nobody is going to change it there's no need to refactor it, it can be a loss of time.

Good luck!

Restructuring my application

2 Answers2