Sounds like it is not possible. But it is! This package contains everything you need to develop applications in as little as 33 days, distilled into 6 major sections, providing you with a complete, 360-degree development platform.
All working together to create amazing solutions.
Let's look at each of the 6 sections.
Explore all 23 Gang of Four (GoF) patterns and harness the power of the very best patterns in your own projects. Which ones? Hint: Factory, Strategy, Facade, and Builder might just be included.
You are getting three versions of each GoF pattern: structural, real-world, and .NET optimized.
With Dofactory .NET you have these patterns available at your fingertips -- anytime you need them.
Head First Design Patterns is a whimsical Java design pattern book that has taken the community by storm. With Dofactory .NET you have access to optimized C# versions of these fun design patterns.
Enterprise Design Patterns focus on data access and performance. Learn to develop scalable enterprise solutions with patterns like Repository, Unit of Work, Active Record, Data Mapper, and many more.
Explore these enterprise architecture patterns in a real-world setting with an Enterprise style reference solution. Discover where in the stack each pattern is best used for maximum benefit.
Explore this family of 3 architectural patterns: MVC, MVP, and MVVM. Understand their differences, their similarities, and then optimize your applications around the appropriate model.
Design Patterns 2.0 has arrived! Launch your applications, and your career, to greater heights with modern patterns like CQRS, Cache, Low-Code, Low-Query, ActionModel, and Lazy Injection.
Meet the new architecture that is almost no architecture. There is so little code, and it's so clean. And with so much functionality it's hard to believe it's even possible. But it is. Experience rapid development like never before.
The Ultra-Clean™ Architecture suggests how and where you write your business code, but you're always free to do it your own way. There is never a lock-in or conflict. So refreshing -- and so liberating.
Drive productivity by partitioning your projects into distinct modules. We call them vertical slices. Modules help separate your code so you can make changes without affecting other code. Modules are a core concept in the Ultra-Clean™ Architecture.
Low-code is like power programming. In a few minutes you can accomplish what would have taken hours, or even days, before. Just be forwarned: the low-code experience can be exhilarating.
Low-query is an pattern that reduces page queries down to a single database query without table joins. Increase performance and simplify your code with queries that are super easy on the database.
Write 50% less code with low-code and low-query techniques. Build a light-weight codebase that is simple and effective. The results? Rapid development, fewer bugs, and faster to market. Brilliant.
Learn to design solutions without friction between the layers. Simplify your design by merging the domain model and data model into a single model. No duplication. No impedence mismatch. Full stack has never been so simple.
Start your design with CRUD actions followed by Ancillary actions. With those two steps your design is functionally complete, meaning, users have full control over their records which they love.
With DX you learn simple application design concepts that make your solutions absolutely simple and intuitive to use. Consistency and predictability are going to be a hallmark of your app designs.
Code Excellence™ redefines clean code and code quality. Learn how to structure your projects, areas, controllers, views, and classes for a better, cleaner codebase.
Code discoverability measures how many clicks it takes to locate a particular file, class, or interface. CX optimizes your codebase by drastically reducing the number of clicks.
With CX you'll learn the principles, patterns, and practices of writing clean code. Clean code bring clarity to your code -- and your brain. Your productivity as a .NET developer will never be the same.
Experience speed-of-development like never before. App Factory will guide you through each stage of development and help you deliver applications in as little as 33 days.
Focus on your application requirements rather than on the plumbing with a gallery of ready-to-use custom components. Examples include authentication, caching, identity, logging, Excel import/export, user management, and more.
App Factory offers a day-by-day schedule, for a total of 33 days, with clear instructions for each phase. There is even time allocated for special or unusual requirements if your application requires those as well.
As a .NET developer you spend most of your day in Visual Studio. It's your home and you want your home to be as comfortable as possible.
Unfortunately, standard Visual Studio projects aren't very inviting. They are awkward to navigate with too many folders and subfolders for Controllers, Models, and Views. Not very homey.
Dofactory .NET fixes this with a project structure that you can call 'home'. As a first step, there is just one project in a solution, and this project has just 4 main folders.
Their names have been carefully chosen -- Areas, Code, Domain, and Data. Not only are they short and descriptive, they're also sorted by frequency of use.
The heat map below shows that the most frequently used folders are at the top (the red and reddish ones). This is perfect, because those folders are also the easiest to access.
Expanding the Areas folder we see the application's modules.
This app has 18 modules, one in each Area. But these are no ordinary Areas. They are FlatAreas, that is, Areas without subfolders. A FlatArea has all its files in a single folder including controllers, models, and views.
With a structure like this, your work is easier and much more enjoyable. Let's look at the Users module as an example.
You won't leave this folder when working on User pages. All files are at your fingertips.
Notice that views and model files have the same name, for example, Detail.cs and Detail.cshtml, Edit.cs and Edit.cshtml, and others. These files are sorted by name and each pair appears side by side. Just ideal!
This application is low-code. What does this mean?.
Let's look at the UsersController. Just 38 lines of code for the entire controller!
The controller has two groups of action methods: CRUD and Ancillary (see comments above). CRUD stands for Create, Read, Update, and Delete, which are the fundamental record operations. Most controllers in the Ultra-Clean architecture have 5 CRUD action methods. Ancillary methods are application specific and their numbers usually vary from 0 to 4 or 5.
Looking at the action methods notice they all redirect their requests to their models. These models are no ViewModels, they are ActionModels, a new and exciting pattern.ActionModels
An ActionModel is a ViewModel on steriods. Below is an outline of a typical ActionModel. This one handles the entire Edit request - both GET and POST.
Most ActionModels have the same 4 regions: Data, Handlers, Helpers, and Mapping.
The Data region holds the posted data -- just like a ViewModel. The Handlers region processes the GET and POST requests. Helpers has optional helper methods. And Mapping is where AutoMapper mappings are defined, just for this Edit request.
An ActionModel is a single class that handles a request entirely by itself. It holds the posted data, and performs validation, data access, and object mapping -- totally encapsulated and in one place (i.e. SOLID).
So, if there is a bug in your Edit page, you know the one place where to go look (the Edit ActionModel) . Support and maintenance are super easy with ActionModels.
Some of your may see similarities with MediatR, but there really is no comparison: ActionModels are so much simpler and easier to work with.Handlers
Let's have a quick look at handlers which are methods that process a request. This one handles the List page (GET) request. It's called GetAsync.
This simple 5-line method renders the complete Opportunities list page you see below, including filters, sorting, and pagination. Quite amazing. And it does this with a single query without table joins (this is the Low-query pattern).
Pages like this are high performance, easy on the database, and also easy on you, the developer. Imagine your productivity in this environment!
Did you notice there is no dependency injection in the above code examples? Neither in the Controller, nor in the ActionModels. Actually there is plenty, but it's handled entirely by a single base class, named BaseModel, using a revolutionary pattern called Lazy Injection.
Lazy Injection is a new and exciting pattern: it only returns a service when actually requested -- not when the class is created (which happens with constructor injection).
Lazy Injection makes coding so much easier. You simply focus on building your applications and not worry about what services to inject into your classes. In addition, your code runs faster because only services that are actually used will be created.
Analytics is a full-stack .NET analytics and business intelligence solution. You'll learn where the Gang of Four patterns will have the most impact in your code. The Analytics app is a lightweight solution with lots of developer value.
Art Shop is a comprehensive ecommerce solution built with enterprise architecture patterns. It includes a store front, shopping cart, check out, order management, product management, and analytics. It's a great way to learn about design patterns, architecture, and real-world ecommerce development.
SaaS University is a modern SaaS (Software as a Service) solution that is multi-tenant, multi-timezone, multi-language, multi-locale, and multi-currency. This is for ambitious developers that are serious about accelerating their careers.
CRM is a Customer Relationship Management solution that's beyond impressive. Not only was it built by a single developer in just 33 days, it's also a beautiful and easy-to-use solution that end-users will fall in love with. CRM is a valuable reference app for any .NET developer.
Following purchase you download and install your package. You're now ready to dig in and have answers to all your development questions available at your fingertips - ready-to-use code included. Getting started couldn't be easier.
Here is the table of contents for the full package, with some of the questions each chapter answers:
With Dofactory .NET you receive 15 information-packed chapters with development techniques and code that you won't find anywhere else.
It has never been easier to learn rapid application development (RAD) with design patterns, architecture, low code, and more. Get ready for your new .NET developer lifestyle.
Imagine for a moment being able to develop better solutions faster than anyone else.
Your skill, speed, and confidence is sure to attract the attention of your team, your company, your network, your customers, and even people outside your company.
Before you know it, you'll be the go-to person for development questions. Your lifestyle and your career will never be the same.
Your investment in Dofactory .NET will pay you back many times over -- for details see our ROI calculator. By putting in the time and effort to study the materials you will gain valuable skills, and payback will be fast.
What kinds of payback? How about a bonus, a pay raise, a promotion, a job change, side gigs, or a complete career switch. If you feel stuck in your current situation, Dofactory .NET will open many doors for you.
Alternatively, you can decide to start your own online side business: it could be ecommerce, SaaS, developer tools, you name it. Develop the project that you always dreamed off. Dofactory .NET has all the necessary code to get you started quickly.
Don't stop there. Move your business to the next level and hire designers and SEO specialists to place your project in front of a world-wide audience.
Think that any of these goals are unrealistic? They are not. Dofactory .NET empowers you to build world-class solutions and reach for the sky!
Get Dofactory .NET. It's a no-brainer. Place your order today!
|1. Intro to Design Patterns|
|2. Design Excellence™ Handbook|
|3. Code Excellence™ Handbook|
|4. Gang of Four Design Patterns|
|5. Head First Design Patterns|
|6. Analytics Solution|
|7. Enterprise Architecture Patterns|
|8. Model-View Design Patterns|
|9. ECommerce Solution|
|10. CQRS/MediatR Patterns|
|11. Code Generator|
|12. Multi-tenant SaaS Solution|
|13. Ultra-Clean™ Architecture|
|14. 33-Day App Factory™|
|15. 33-Day CRM Solution|