Generate ASP.NET Core 3.1 Models, Views, Controllers, View Models, Web API, Middle-Tier, Data-Tier (linq-to-entities using the Entity Framework Core), and Stored Procedures or Ad-Hoc SQL in One Click*. AspCoreGen 3.0 MVC generates databound ASP.NET Core 3.1 MVC views.

AspCoreGen 3.0 MVC is an ASP.NET Core 3.1 MVC code generator. It can generate code in C#. It generates code by looking at your Microsoft SQL Server database tables (or views). AspCoreGen 3.0 MVC is the perfect code generator, it will generate a whole web application including a class library and a web API project in just One Click!

Generate an ASP.NET Core 3.1 MVC web app, business & data tier in C#, stored procedures, web api, and more in One Click!



How It Works

AspCoreGen 3.0 MVC generates ASP.NET Core 3.1 models, views, controllers, middle-tier and data-tier (linq-to-entities using Entity Framework Core) objects in a 3-tier layered infrastructure. In short it generates a whole web application. It also generates stored procedure scripts or ad-hoc SQL. All these are generated in One Click*.

Shown below is a visual reprensentation/flow of how AspCoreGen 3.0 MVC generates code.


Step-By-Step

1. Click the "Generate Code..." button.

2. Retrieve Microsoft SQL Server Database information.

3. Generate Code: Generates three projects.

a. Generate an ASP.NET Core 3.1 Web Application - Front End (UI - Presentation Layer).

- Generate Views, Controllers. See more

- Generate styles, scripts, images, icons, web.config, etc. See more

b. Generate an optional ASP.NET Core 3.1 Web API project.

- Optionally encapsulate calls to Business Objects when generating Web API. See more

c. Generate a Business/Data Objects Class Library project (.NET Core 3.1).

- Generate Middle-Tier Class Files (Middle Layer). See more

- Generate Data-Tier Class Files (Data Layer). See more

- Generate additional files such as Models and View Models

4. Generate SQL Scripts. See more

a. Generate Linq-to-Entities queries (EF Core), or Stored Procedures, or Ad-Hoc SQL. Stored procedures are generated inside Microsoft SQL Server. The Linq-to-Entities queries (EF Core) or Ad-Hoc SQL scripts are generated as class files.

N-Tier Layer Approach

AspCoreGen 3.0 MVC generates code in a 3-tier (n-tier) architecture. A presentation tier (the client), middle tier (business objects), data tier (data access objects), and the database scripts such as stored procedures. Code is separated in different layers.


Step-By-Step

1. Front End (UI - Presentation Layer) Views, Controllers, jаvascript, CSS, JQuery, and more.
2. Web API (Middle-Layer, Optional). Optionally encapsulate calls to Business Objects when generating Web API code.
3. Middle-Tier Class Files (Middle Layer) Business Logic Class Files, Models, Views, View Models, etc.
4. Data-Tier Class Files (Data Layer) using Linq-to-Entities - Entity Framework Core or Ad-Hoc SQL.
5. SQL Scripts (Stored Procedures).



The generated middle tier objects (and data tier objects) are generated in another application (class library project) and can also be consumed by other clients. Clients could be a web form (.aspx), a win form, or a web service (.asmx, wcf), etc. Or better yet you can choose to generate the Web API (optional) and get all the other clients to access this extra layer instead.

The middle tier encapsulates all calls to the data access objects (data tier) so that calling a CRUD (create, retrieve, update, delete) and other operations are very easy and may only take one line of code for most parts. We made it even easier by generating and showing an example for each CRUD operation, for each table in your database, so you just copy and paste a call from your chosen client.

The data tier encapsulates all calls to the database. These are calls using Linq-to-Entities, or Stored Procedures, or Ad-Hoc SQL. Linq-to-Entities, or Stored Procedures, or Ad-Hoc SQL are also generated so you don't have to worry about writing T-SQL commands.

Generated Projects

AspCoreGen 3.0 MVC generates three projects/applications in One Click! It generates 3 separate applications in one Solution. The separation of projects is another way to clearly distinguish the functionality of the respective applications.

Web Application Project
This is the ASP.NET Core application which mostly contains UI components, or the Presentation Layer.

Views
Controllers
Stylesheets
Images
jаvascript scripts and libraries
Code Examples
Miscellaneous files that completes an ASP.Net Core web application
Class Library Project
This is the API application that contains the Middle and Data Tier code which is shared between the Web Application and Web API

Business Objects (Middle Tier .cs class files)
Data Layer using Linq-to-Entities (Data Tier .cs class files)
Enum Files
Entity Framework Entities or Ad-Hoc SQL
Models
View Models
Miscellaneous files that completes a Class Library application
Web API Project
This is the optional Web API application.

Controllers
Miscellaneous files that completes a Web API application
Stored Procedures
This is Not a project or an application. These are SQL scripts directly generated in your Microsoft SQL Server.



Generated Web Project Examples

You can download six sample projects below generated by AspCoreGen 3.0 MVC. Please make sure to read the Readme.txt file for instructions. You will need Visual Studio 2019 and Microsoft SQL Server with the Microsoft Northwind database installed to use any of these sample projects. You also need to install the .NET Core 3.1 SDK in your machine. Right-click the download links below and choose "Save target as" in the context menu, and save it to your computer.

Generated Presentation (UI) Layer

Listed below are quick descriptions of the ASP.NET Core MVC Views AspCoreGen 3.0 MVC generates that makes up the Presentation Layer (Front End). Note: All generated views with a grid also have paging and sorting functionality. CRUD are database operations which means: create (add a new record), retrieve (get an existing record), update an existing record, delete an existing record.

Generated Web API

Listed below are quick descriptions of the Web API controller class files AspCoreGen 3.0 MVC generates. These Web API methods encapsulates calls to the Middle Layer methods. Generating Web APIs are optional. Web APIs can be a client and act as another middle layer. Generated Web API methods can be accessed publicly and can act as a service to other clients (winforms, web forms, other api or service like a wcf app, mobile app, etc). So you can also build a desktop app that can access the same API your ASP.Net Core app is using through the Web API. Clients/consumers of the Web API does not have to be a windows program, it returns collections as JSON data, or you can pass it JSON data when saving a new record or updating an existing record.

Web APIs are generated as a separate ASP.NET Core project in the same solution as the generated web application.

Consuming Web API Code Examples

The generated Web APIs can be consumed by various clients as mentioned above. Here are some code examples on how a windows-based client such as an MVC web app, web forms, win forms, web service (.asmx, wcf), etc can access the API. The examples below shows how to consume/call the generated Web API.

Note 1: Examples below shows Microsoft C# examples. Because these are Web APIs it can also be accessed by other programming language like PHP, or Java, etc.

Note 2: We made it even easier by generating all the code examples for each of the method that you can access. More operations can be consumed as shown here, and these operations are generated for each of your database table.

Select/Skip/Take
For example Sort Products in descending order, Skip the first 20 records and then Select 10 Product records. This will return a strongly-typed ProductsCollection collection. You can then just assign the returned collection to a GridView (web forms), or use a loop through the collection using foreach.

Generated Middle Layer

Listed below are quick descriptions of the Middle Layer class files (generated in the Class Library Project) which includes Business Object class files AspCoreGen 3.0 MVC generates that makes up the Middle Tier. In a 3-tier infrastructure, middle layer code is called by the UI or presentation layer code. It can contain business computations applicable to the application's purpose. It also contains calls to the data layer code.

Generated Data Layer

Listed below are quick descriptions of the Data Layer class files (generated in the Class Library Project) AspCoreGen 3.0 MVC generates that makes up the Data Tier. In a 3-tier infrastructure, data layer code is called by the middle layer code. It contains calls to the database (stored procedures/Ad-Hoc SQL/linq-to-entities using Entity Framework Core).

Accessing Code From The Middle Tier

To make it really simple, the Data Layer method signatures are very similar to the Middle Layer method signatures, we simply add a string constant "DataLayer" to the middle layer method name to call data layer objects. For example if the middle tier object name is Categories, then the respective data tier object name is CategoriesDataLayer. To call a data layer method you simply add a dot and then the method name; e.g. CategoriesLayer.TheMethodName();

Generated SQL Scripts/Linq-To-Entities Queries

Listed below are quick descriptions of the SQL Stored Procedure, Ad-Hoc DQL, or Linq-to-Entities queries AspCoreGen 3.0 MVC generates. When you choose to generate stored procedures, these scripts are directly generated in the database. Otherwise, when you choose linq-to-entities or Ad-Hoc SQL, these SQL scripts are generated in class files added to the web application's Class Library project.

Generated Miscellaneous Items

AspCoreGen 3.0 MVC generates 3 projects/applications in a single ASP.NET Core 3.1 Web Application as mentioned here. Listed below are quick descriptions of the Miscellaneous files and folders generated to complete each of the three applications that are generated.

Note: List below may not contain the full list of miscellaneous files generated by AspCoreGen 3.0 MVC. To get a more complete list, please read the Discussing the Generated Code for Database Tables under tutorials.

Notes

Relationships between related/associated tables must be explicitly established in the information schema of your database.
Express Edition is free. Professional Plus Edition is for sale. Please see the product matrix.
Code is only generated for database tables with a Primary Key.
Some MVC Views such as the "List with Grouping", "List with Totals and Grouping", "List with Master Detail (Grid)", "List by Foreign Key", and "List with Master Detail (Sub Grid)" are only generated for tables that have explicit Foreign Key(s).
The "List with Multiple Delete" MVC View is only generated for database tables with only One primary key.
Some Stored Procedures and/or Linq-to-Entities queries such as the "Select All By a Foreign Key", "Select, Skip, and Take By a Foreign Key", "Get Record Count by Foreign Key", and "Select Drop Down List Data", etc. are only generated for tables that have explicit Foreign Key(s).

OR GET THIS FILE WITHOUT PLATINUM MEMBERSHIP - PRICE 80$ ONLY