WORLD'S #1 .NET DESIGN PATTERN FRAMEWORK

Build your .NET applications fast with Design Patterns and our new Ultra-Clean™ Architecture.

Tired of Old Code development that takes forever?
We have the technology for you!


Develop your next app in just  33 days !
Ready to order? Click here.
Dofactory .NET
What is Dofactory .NET

What is Dofactory .NET?

Dofactory .NET is a design pattern framework for rapid application development (RAD). Build comprehensive .NET solutions with design patterns, Ultra-Clean™ architecture, low-code, and more. Our focus is on simplicity and productivity.
Also included is the 33-Day App Factory™ which allows you to develop complete .NET solutions in just 33 days, start to finish! No more 'Old Code' development that takes forever.
Dofactory .NET is a unique package that offers answers and code solutions to the most crucial questions that .NET developers have. You won't find anything like it anywhere else.

Why Developers love Dofactory

Productivity

With Dofactory .NET you'll learn to build apps fast, eliminate repetitive tasks (like clicking around in your solution for hours), and structure your solutions for success. No more Old Code development. Create your next app in just 33 days.

Simplicity and Less Code

Simplify your application stack. Create solutions where the layers work together, front-end, middle-tier, and the database. Then apply low-code and low-query techniques and reduce your codebase by 50%.

Beautiful applications

Build applications that are beautiful and powerful at the same time. Design solutions like an expert with Design Excellence™ (DX), our new application design framework. Deliver amazing solutions that will delight your customers.

Be the best developer in the room.

Get the skills and the confidence you need to develop better solutions with design patterns, Ultra-Clean™ architecture, low-code, and more -- all in record time. Your career will never be the same.

Reduced costs.
Increased revenues.

As a business owner you save costs by bringing products to market faster. Start receiving revenues months earlier than with 'Old Code' development. Your ROI never looked so good.

One project. 33-Days. Done!


Dofactory .NET gives you the capability of delivering fully-functional apps, like the CRM application above, in record time.

33-Day Apps. How's that even possible?

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.

Design Patterns

The most comprehensive collection of C# design patterns ever put together.

Ultra-Clean™ Architecture

A clean, lightweight architecture that is designed for rapid development.

Low-Code, Low-Query

Reduce your code by 50% with low-code and low-query innovations.

Design Excellence™ (DX)

Design beautiful applications that will delight your customers.

Code Excellence™ (CX)

Increase developer productivity with optimal code solutions.

33-Day App Factory™

A step-by-step guide for rapid app development in just 33-days.


All working together to create amazing solutions.
Let's look at each of the 6 sections.

Design Patterns
We've created the most comprehensive collection of design patterns ever put together. From the classic Gang of Four patterns to the modern Design Patterns 2.0. Each one painstakingly curated with optimized C# and real-world examples.
Gang of Four Design Patterns.
Building a solid pattern foundation.

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.


Bonus: Head First Design Patterns.
Having fun with design patterns.

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.
Scale your apps farther and faster.

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.

Model View Design Patterns.
A family of architectural patterns.

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.
Meet the next generation.

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.

Ultra-Clean™ Architecture
The design patterns will teach you a ton, but you still need a place to make them shine. This is where you need the right architecture.
We tested many different architectures, but, without exception, we found that they would slow us down. So we built the Ultra-Clean™ Architecture to solve it.
The Ultra-Clean Architecture™ is a lightweight, ultra-effective architecture that has been handcrafted to perfection. No stone was left unturned to create the best foundation for rapid, clean development.
Ultra-Clean™ Architecture.
The future of rapid .NET development.

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.

Ultra-Clean™ Architecture
No Lock-in.
Mix and match with your own architecture.

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.

No Lock-in
Modular.
Separation of concern -- the right way.

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.

Modular
Low-code, Low-query
How many times have you tried to complete an application feature, only to find yourself in the weeds with what seems like a totally unrelated detail?
This has always been a huge point of frustration for us with our own work, because it was holding us back. So, we set out to solve this.
The solution includes Low-code and Low-query innovations which allows you to focus on completing a task with just a few lines of hyper-focused code. And it reduces the code you write by up to 50%.
Low-Code

Low-Code
Less code. More results.

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

Low-Query
Fewer queries. Same data.

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.

50% Less Code

50% Less Code
Build lightweight apps fast.

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.

Design Excellence™ (DX)
When developers, designers, and database professionals work together it can be difficult to agree on the best design and architecture for an application. Each has their own perspective, objectives, and vocabulary.
Design Excellence™ (DX) offers a unified approach in which the layers (front-end, middle-tier, database) work together to form a coherent unit in which each part plays an equally important role -- unlike DDD where the domain model is the boss and everyone else has to adjust.
And DX comes with its own application design vocabulary (about 20 terms) that everybody can understand and agree on.
Design Excellence™ (DX)
No-friction design.

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.

Design Excellence™ (DX)
Delight your users
Give users fully functional apps.

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.

Delight your users
Clean Design
Create clean and intuitive apps.

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.

Clean Design

Code Excellence™ (CX)
Creating Visual Studio solutions that are simple and easy-to-understand is important. First, it provides a mental map of the application architecture, and, secondly, it increases discoverability with files and classes that are easily accessible.
Knowing this, we started re-structuring solutions by removing inefficiencies that we found were hindering us in our progress. These changes affected all folders, files, classes, and code. Today our solutions are an absolute delight to work with.
This new solution structure is documented in our Code Excellence™ (CX) guide. Once you’ve worked with CX, there is no going back to the 'Old Code' solutions. The good news is that you don't have to!
Code Excellence™ (CX)

Code Excellence™ (CX)
Create a better work environment.

Code Excellence™ redefines clean code and code quality. Learn how to structure your projects, areas, controllers, views, and classes for a better, cleaner codebase.

Discoverability

Discoverability
Get more done with fewer clicks.

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.

Clean Code

Clean Code
Increase productivity with clean code.

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.

33-Day App Factory™
It all started when we set out to fix the problem of never-ending projects. And, here we are today with the solution: our 33-day App Factory™.
The App Factory™ is a step-by-step, day-by-day guide that allows you to build fully functional applications in just 33 days. We took everything presented in this package -- patterns, tactics, architecture, low-code, and much more -- and assembled it into the easiest, fastest developer solution ever built.
If you’re starting a new project, we encourage you do it with the 33-day App Factory™. You’ll save yourself a ton of agony. And you get to enjoy a whole new developer experience.
Rapid Application Development
Increase your speed of development.

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.

Rapid Application
Development
Custom components
Get a great headstart.

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.

Custom Components
33 Days
Build apps fast.

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.

33 Days

Code please!

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.

Creating a homey project

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.

Modules

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!

Controllers

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!



Dependency Injection

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.

Applications Please!

Below are solutions that show the power of Dofactory .NET.
All are included with your package -- 100% source code!.


ANALYTICS
Full-stack app built with design patterns.

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.

See more >

ECOMMERCE
Beautiful online art shop.

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.

See more >



SAAS
For ambitious developers.

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.

See more >

CRM
Beyond impressive.

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.

See more >

DOFACTORY .NET

What do I get?

Following download and installation you have answers, and code, to all your development questions at your fingertips. Getting started couldn't be easier.

Here is the table of contents for the full package, with some of the questions each chapter answers:

  • Chapter 1: Introduction to Design Patterns
    • What are design patterns and how to use them in your own work.
    • How to create more flexible software with design patterns
    • Design patterns and best practices. What's the difference?
    • Why design patterns and architecture must go together.
  • Chapter 2: The Design Excellence™ Guide
    • Why every application must be functionally complete
    • Ten design rules that apply to all applications
    • Designing applications that your customers will love
    • Simplicity through a single domain/data model.
  • Chapter 3: The Code Excellence™ Guide
    • The main reasons why VS solutions are so awkward
    • How to create solutions where you feel at home
    • How to increase productivity with code that is highly discoverable
    • What are Flat Areas and why they matter
    • How to make dependency injection work for you, not against you
  • Chapter 4: The Gang of Four Design Patterns
    • Why the GoF patterns are still highly relevant today.
    • How to write .NET optimized GoF design patterns.
    • When and where is each GoF design patterns best used.
    • How to convert reusable designs into a pattern.
  • Chapter 5: The Head First Design Patterns
    • Having fun learning design patterns
    • How to code tried-and-true, road-tested patterns in .NET.
    • How pizza delivery can benefit from design patterns
    • Learning GoF patterns with whimsical code examples
  • Chapter 6: Analytics Solution
    • How to develop a full-stack solution with GoF patterns
    • Strategy: changing data providers at run-time
    • Best places in the architecture to make design patterns shine
    • How to design a visually attractive solution with charting
  • Chapter 7: The Enterprise Architecture Patterns
    • How to build scalable solutions with Enterprise patterns
    • Why DDD and Domain models are not the answer
    • How a great enterprise architecture can solve performance issues.
    • Why data access is so critical to successful enterprise apps.
  • Chapter 8: The Model View Patterns
    • Learn the differences between MVC, MVP, and MVVM and why they matter.
    • Why separation-of-concern is a core tenet in these patterns
    • Web, Windows, Razor Page -- each one benefiting from Model View in their own way
    • How to create a plug-and-play data access layer
  • Chapter 9: ECommerce solution
    • How to write an amazing Ecommerce solutions with design patterns
    • How to create a cart, a product page, a checkout page, and more
    • The most valuable patterns and practices in real-world solutions
    • Learning to develop an online store for fun and profit
  • Chapter 10: CQRS Pattern with MediatR
    • How to separate queries from commands with CQRS
    • Implementing CQRS with the MediatR package
    • When and where is CQRS an absolute requirement
  • Chapter 11: Code Generator
    • How to create a lightweight ORM with business entities in 3 seconds.
    • How to make data access easier and faster
    • The Active Record Pattern: The data model is the object model
  • Chapter 12: SaaS Solution
    • How to design and develop a modern, multi-tenant SaaS solution.
    • How to: multi-language, multi-culture, multi-language, and multi-currency.
    • Top 5 challenges developing multi-tenant solutions.
    • The reasons why so many SaaS solutions fail.
  • Chapter 13: Ultra-Clean™ Architecture
    • The best parts of the Ultra-Clean™ Architecture. There are many.
    • How Ultra-Clean™ architecture gives you a competitive advantage
    • How to reduce your codebase by 50% with Low-Code and Low-Query techniques
    • The power of Lazy Injection revealed
  • Chapter 14: 33-Day App Factory™
    • In a hurry? Write your next application in 33 days
    • The four main stages of rapid application development
    • How to get a head-start with reusable custom components
    • Accelerating your career with the 33-day App Factory™
  • Chapter 15: 33-Day CRM Solution
    • How to build a CRM or other line-of-business app in 33 days
    • Patterns, Low-code, and Ultra-Clean™ architecture in a single solution
    • Patterns, practices, and principles for real-world RAD (rapid app development)
    • The secrets of building killer apps in record time

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.

CAREER

How will Dofactory improve
my career?

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.

My career

EARNINGS

How will Dofactory improve
my bottom-line?

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.

Start business

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!

20,000 CUSTOMERS

Dofactory is trusted by some of the world's top technology and fortune 500 organizations.

Microsoft
Dell
Nasa
Cognizant

THREE EDITIONS

Dofactory .NET comes in 3 editions.

Most Popular

Dofactory .NET

Standard
Edition
$ 79
Plus
Edition
$ 229
Pro
Edition
$ 279
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     

ORDER NOW

Choose the edition that is right for you.

Dofactory .NET Core 3.1
Dofactory .NET Core 3.1      Standard Edition
1-Developer license
$79
Dofactory .NET Core 3.1      Plus Edition
1-Developer license
$229
Dofactory .NET Core 3.1      Pro Edition
1-Developer license
$279


Dofactory .NET 4.8
Dofactory .NET 4.8      Standard Edition
1-Developer license
$79
Dofactory .NET 4.8      Plus Edition
1-Developer license
$229
Dofactory .NET 4.8      Pro Edition
1-Developer license
$279


Grow with Dofactory

Accelerate your .NET career today.
Grow with Dofactory.

ORDER NOW
Own Your Future.





Stay Inspired!
Join other developers and designers who have already signed up for our mailing list.
Terms     Privacy     Licensing       EULA       Sitemap      
© Data & Object Factory, LLC.
Made with    in Austin, Texas