Today, I have begun working on one of my app framework projects, wherein I am brushing up on all the required skills to write a good application framework. Basically, I would say an application framework is a one-time investment with long-term returns. This means that if you write a good framework initially, then you can smartly focus on business requirements at the later part. So, basically any application framework involves the following points.
- General Naming conventions.
- Data Access Design.
- DI Technique, say Ninject, Structure Map and so on.
- Error-Handling and Logging Events.
- Security Infrastructure.
- UI Design.
- Client-side/Server-side Validations.
- Many more can be listed, but these are basics.
But, for developing them, you need to have a good implementation knowledge of the following points.
- SOLID Principles
These principles have helped me a lot. They are not just rules to be followed blindly, but I have found the reasoning behind them and now trying to make clean code that is easy to understand and testable in the long run.
- Design Patterns
Certain types of problems always occur in software development. For these scenarios, we have design patterns. Getting a hold on design patterns is something that only comes with practice. You won't be able to memorize and recognize even the core set of patterns immediately, but over time you will recognize them.
- Test Driven Development
Make it a habit! It not only helps to test the code, but it also helps me in designing the code. That's a big advantage that many people overlook. It also gives me confidence, that the class I am creating does exactly what it is supposed to do and nothing more. Test Driven Development also makes sure that the new features added in your application will not break the existing ones, if all the tests ran expectedly.
- Resharper
Resharper is essential for doing C# development in my opinion. Out of the box, it will suggest many little things that can help improve your code. It helped me in learning LINQ by offering to convert tedious long code into elegant LINQ expressions and it finally convinced me that "var" isn't always evil.
- Lambda expressions
These are essential when working with C# . They're a bit hard to grasp at first, but they bring very interesting re-use possibilities and many APIs leverage them heavily.
- Generics
It's an older C# feature that is still important to learn. It opens up new avenues for creating clean, extensible and reusable classes.
- Structure Map
One of the biggest changes at the moment that totally changed how one codes. Now, when I realize a class I am working on that needs some other service to fulfil its responsibilities, I simply create a new service interface and add it to my class's constructor. This makes my development much easier.
- LINQ
Make LINQ a habit as well. Most of the times for complex queries, I use LINQPAD or refer to the MSDN LINQ samples.
- Moq
Mocking frameworks allow you to configure stubs or fakes that you can substitute for dependencies while testing your classes. Moq is one of my favorites for its fluent, lambda-based syntax. Of course this piece also I always try to use as much as possible.
So, these were a few things, in my opinion, that an expert developer should have.