33-Day
App Factory™

The 33-Day App Factory™ is included with the Pro edition of Dofactory .NET.

App Factory™ is a day-by-day, step-by-step guide and platform that helps you build fully-functional .NET applications in just 33 days. Your solutions will be running on a modern Ultra-Clean™ Architecture, as well as the best design patterns and low-code techniques that are not available anywhere else.

App Factory™ provides a great headstart, because you'll start with a well-defined architecture and a rich set of built-in components, such as authentication, authorization, error logging, caching, administration, Excel import/export, and more. You can immediately focus on your business requirements instead of spending time building the plumbing.

Give it a try!  It will forever change how you think about application development. And it will forever change your career and your business.

To view the pages click on the menu on the left under VIEW APPLICATION PAGES. Soon you'll deliver similar results in your own applications.

VIEW APPLICATION PAGES
33-DAY APP FACTORY

Build amazing solutions in just 33 days. Comes with 100% source code.

PATTERNS & FEATURES
  • Factory
  • Singleton
  • Builder
  • Iterator
  • Strategy
  • Composite
  • Proxy
  • Facade
  • Service
  • Repository
  • Lazy Load
  • Dependenc Injection
  • Data Transfer Object
  • Data Caching

What can I build in 33 days?

To see an example of the kind of applications that you can develop in 33 days, please see our CRM application. This solution was built by a single developer in 33 days.

The CRM application has it all. It has 45 pages, fully supports 7 main entities -- Leads, Opportunities, Tasks, Accounts, Contacts, Campaigns and Cases -- and has additional functionality like authentication, user management, error logging, administrative tasks, and more. All this for 33 days of work!

What is it like working with the App Factory™?

Working with App Factory™ is like a dream come true. It is simple and fast. With the Ultra-Clean™ architecture you will always know what to write, how to write it, and where to place the code. And with App Factory™, you can be sure that your app design and your architecture are solid, scalable, and production-ready.

Code Please.

Let's look at some code. We'll use a solution built for Custom Surfboards, Inc which is a California company that manufactures and sells surfboards. This example is also included with Dofactory .NET.

First, here is the Visual Studio solution:

The solution is small and simple: a single single project with just 4 folders. These are standard folders in all App Factory™ solutions: Areas, Code, Domain, and Data.

Areas.

Each Area represents a module. In this example we're building a Customer module in which users list, search, filter, sort, paginate, view, add, edit, and delete customer records. They can also import and export Excel files with customer records.

All the code for Customer functionality is located in a single folder: totally separate from all other modules.

These are not standard MVC areas. The Customers folder is a Flat Area in which there are no subfolders. Folders like Controllers, Models, and Views do nothing but hinder navigation, so they have been removed. Today it's all about discoverablity. With Flat Area, all your files are at your fingertips.

What do Customer pages look like?

Here are some screenshots of the pages in the Customer module.

Customers list page (click to enlarge).
Fully supports search, sort, filter, pagination, Excel import, and export.

Customer detail page (click to enlarge).

Edit Customer page (click to enlarge).

New Customer page (click to enlarge).

Customer Excel import page (click to enlarge).

Controllers.

The Old Code MVC Controllers don't adhere to SOLID principles because they do too many things by handling all kinds of unrelated requests.

App Factory™ fixes this with the Ultra-Clean™ architecture. It moves functionality out to individual Actionmodels, one for each request. The Customer module has 6 Actionmodels: Delete, Detail, Edit, List, Import, and Export -- all adhering to SOLID principles.

This leaves the Controller with just one responsibility: to forward requests to the correct Actionmodels. And that is exactly what App Factory™ controllers do.

Below is the low-code Customer controller. Notice it has just one line of code for each request. Also notice there is no dependency injection. All super simple. Every controller in your solution will look like this.


Actionmodels.

Each Actionmodel handles a single request -- entirely by itself. It's a self-contained unit with the data (viewmodel), validation, database access, object mapping, and data preparation for page rendering. So, if you develop the code for a particular page, then this is the only place where you will work (which makes development as well as debugging very simple).

Below is the Detail Actionmodel which handles the Customer detail page request.

It has just 57 lines of code. The same 4 regions exist in all Actionmodels: Data, Handlers, Helpers, and Mapping.

The Data region holds the data that normally exists in the viewmodel. The Handlers processes the request with database access and validation. Helpers provide optional helper methods. And Mapping is where AutoMapper mappings are defined.

Below is the complete Detail Actionmodel expanded.

As an aside, the '_viewedService' logs each viewed page which allows users to see their most recently viewed pages.

Next is another example: the List Actionmodel which renders a list of Customers.

This page support sort, filter, and pagination actions. Yes, the entire code is just 111 lines, most of it in a BuildQuery method that builds a dynamic EF Core query. Click here to see the full BuildQuery method.

Notice how simple the queries are: without EF 'Include' or JOIN operations. This is the low-query pattern: simple queries with great performance.

Database.

A final note about the databases in these applications. Just like the code, the data model should be as simple as possible. Our databases have tables and indexes only; there are no views, triggers, stored procedures, functions, or any other database objects.

Dofactory .NET comes with a set of Ultra-Clean™ data model guidelines that were borrowed from our Dofactory SQL product.

Dofactory SQL teaches you how to model with tables and indexes only, how denormalization will reduce the number of tables, simplify queries, and improve performance. And how caching further improves simplicity and performance. Put the data (Dofactory SQL) and code (Dofactory .NET) together and you have the ultimate in simplicity and performance.

Take the next step.

And there you have it. This is just a small sample of what Dofactory .NET with App Factory™ has to offer. Wouldn't you rather be coding this way and know that everybody using the solution is going to love your work? Give it a try. You won't regret it.



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