Let’s get started.<\/p>\n
<\/a>What are .NET Project Templates?\u00a0\u00a0<\/h2>\nWe can use .NET Project templates to create ready-to-run projects that make it easy to start with a working set of code. The .NET SDK comes with a set of default templates to cover the essential project types that we may require like the Console Apps<\/strong>, Class Libraries<\/strong>, ASP.NET Core apps,<\/strong> etc.<\/p>\nTo see all the available templates, we can use the dotnet new<\/code> command with the --list<\/code> option:<\/p>\ndotnet new --list<\/code><\/p>\nThis will list all built-in templates as well as the custom ones if we have installed any.<\/p>\n
However, sometimes we may need to create our project templates for specific contexts. For instance, an organization may have a requirement that all projects that they create need to follow a specific structure and format. The .NET CLI includes a template engine, which can create projects from a specified template. We are going to see how we can create our project template to use with .NET CLI and Visual Studio.<\/p>\n
<\/a>How to Create a .NET Project Template?\u00a0<\/h2>\nFor that, first, let’s prepare a project.<\/p>\n
We can start by creating a standard ASP.NET Core Web API project and then customizing it.<\/p>\n
That said, let’s create a new project using dotnet CLI:<\/p>\n
dotnet new webapi -o codemazeapi<\/code><\/p>\nSince we specify the output folder name as codemazeapi<\/code>, this will create a new folder named codemazeapi<\/code>\u00a0and an ASP.NET Core Web API project named codemazeapi<\/code> inside it. The project will have the structure of a standard ASP.NET Core Web API:<\/p>\n![\"default](\"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/default-web-api-project-template.png\")
<\/a>\u00a0<\/p>\nNow we are going to customize this project a bit. First,\u00a0 let’s remove the WeatherForecastController<\/code> and the WeatherForecast<\/code> class. Then let’s add a ValuesController<\/code> inside the Controller<\/code> folder with just a GET<\/code> action method:<\/p>\npublic class ValuesController : ControllerBase\r\n{\r\n public IActionResult Get()\r\n {\r\n return Ok(\"Hi from Code-Maze Web API Template\");\r\n }\r\n}<\/pre>\nFinally, in the launchSettings.json<\/code> file, let’s modify the launchUrl<\/code> value to api\/values<\/code>. This will make sure the application hits this controller endpoint on start-up.<\/p>\nNote that in this example we are working with .NET 6. If we use a different version, the default templates and source files could be a little different, but we can always customize those to match this example.<\/p>\n
Our customized Web API project is ready. The next step is to create a template out of it.<\/p>\n
Creating Template from Existing .NET Project<\/h3>\n
For creating a template from an existing project, we need to create a new folder .template.config<\/code> in the root of the project and<\/span> add a template.json<\/code> file inside it. This file is the most important part of building our custom template. It contains all the key information required for transforming our .NET project into a project template:<\/p>\n{\r\n \"$schema\": \"http:\/\/json.schemastore.org\/template\",\r\n \"author\": \"Muhammed Saleem\",\r\n \"classifications\": [ \"Web\", \"WebAPI\", \"C#\" ],\r\n \"identity\": \"CodeMazeTemplates.WebAPI\",\r\n \"name\": \"Code-Maze Web API Template\",\r\n \"shortName\": \"codemazeapi\",\r\n \"tags\": {\r\n \"language\": \"C#\",\r\n \"type\": \"project\"\r\n }\r\n}<\/pre>\n\n$schema<\/code>– It defines the schema for the JSON file.<\/li>\nauthor<\/code>– defines the author of the template<\/li>\nclassifications<\/code>– This is used to classify and group the templates. It becomes easier to search and find templates based on the values we provide for this property<\/li>\nidentity<\/code>– It uniquely identifies the template<\/li>\nname<\/code>– the name of the template when it is listed<\/li>\nshortName<\/code>– a short name that we can use while creating a new project from the template using dotnet new<\/code><\/li>\ntags<\/code>– defines a set of tags for the project. Here we specify that it is a project<\/code> template in the C#<\/code> language<\/li>\n<\/ul>\nWith this, our custom project template is ready. The next step is to install it.<\/p>\n
For installing the project template locally,\u00a0 we have to run the dotnet new<\/code> with the --install<\/code> or -i<\/code> command from the project root directory:<\/p>\ndotnet new -i .<\/code><\/p>\nNotice that we used .<\/code> argument with the install<\/code> command to indicate the template is located in the current folder. If our template location is different, we need to specify that folder path instead.<\/p>\nThis will install the template package locally:<\/p>\n
The following template packages will be installed:\r\n C:\\code-maze-repo\\templates\\codemazeapi\r\n\r\nSuccess: C:\\code-maze-repo\\templates\\codemazeapi installed the following templates:\r\nTemplate Name Short Name Language Tags\r\n-------------------------- ----------- -------- -------------\r\nCode-Maze Web API Template codemazeapi [C#] Web\/WebAPI\/C#<\/pre>\nNow if we run the dotnet new --list<\/code> command, it will list our custom template along with the .NET default templates:<\/p>\nTemplate Name Short Name Language Tags\r\n-------------------------------------------- ------------------- ---------- -------------------------------------\r\nASP.NET Core Empty web [C#],F# Web\/Empty\r\nASP.NET Core gRPC Service grpc [C#] Web\/gRPC\r\nASP.NET Core Web API webapi [C#],F# Web\/WebAPI\r\nASP.NET Core Web App razor,webapp [C#] Web\/MVC\/Razor Pages\r\nASP.NET Core Web App (Model-View-Controller) mvc [C#],F# Web\/MVC\r\nASP.NET Core with Angular angular [C#] Web\/MVC\/SPA\r\nASP.NET Core with React.js react [C#] Web\/MVC\/SPA\r\nASP.NET Core with React.js and Redux reactredux [C#] Web\/MVC\/SPA\r\nBlazor Server App blazorserver [C#] Web\/Blazor\r\nBlazor WebAssembly App blazorwasm [C#] Web\/Blazor\/WebAssembly\/PWA\r\nClass Library classlib [C#],F#,VB Common\/Library\r\nCode-Maze Web API Template codemazeapi [C#] Web\/WebAPI\/C#\r\nConsole App console [C#],F#,VB Common\/Console\r\n...<\/pre>\nWe have created our .NET project template and installed it locally. The next step is to create a project using that template.<\/p>\n
Creating New Projects Using a Custom Template<\/h3>\n
For creating a new project using our template, we can use the dotnet new<\/code> command:<\/p>\ndotnet new codemazeapi<\/code><\/p>\nThis will create a new project based on the codemazeapi<\/code> template.<\/p>\nNote that the project and solution have the same name as the template. Similarly, it uses the same namespace as defined in the template. Additionally, we can notice that this command did not create a project folder, it just creates the project in the same folder where we ran the above command. In the next section, we’ll look at how to customize all these.<\/p>\n
<\/a>Customizing .NET Project Templates<\/h2>\nEven though we have created a custom project template and created a new project from that template, right now it doesn’t do anything exciting other than copying the source files from the original project folder. However, it is possible to customize the template by modifying the template.json<\/code> file and providing additional parameters while creating projects. Let’s take a look at a few parameters that come out of the box with .NET templates.<\/p>\nThe Output Parameter<\/h3>\n
While creating new projects using dotnet new<\/code>, it is possible to specify an output folder by using the -o<\/code>\u00a0parameter:<\/p>\ndotnet new codemazeapi -o MyFirstAPI<\/code><\/p>\nThis will create a new output folder and place the project files inside it. It is a good way to organize projects into separate folders, but the rest of the project contents remain as it is.\u00a0<\/p>\n
The SourceName Parameter<\/h3>\n
Now let’s take a look at the sourceName<\/span><\/code> parameter. This represents the name of the project and the namespace that it uses. Once we specify this in the template.json<\/code> file, it acts as a placeholder and we can override that value while creating projects using the -n<\/code>\u00a0parameter:<\/p>\n{\r\n...\r\n \"shortName\": \"codemazeapi\",\r\n \"sourceName\": \"codemazeapi\",\r\n \"tags\": {\r\n \"language\": \"C#\",\r\n \"type\": \"project\"\r\n }\r\n}<\/pre>\nAfter making any changes to the template, we need to uninstall and reinstall the template to update it with the latest changes.<\/p>\n
For uninstalling the template, we can use dotnet new -u<\/code> command.\u00a0 Along with that, we need to either specify the folder of the template or use the .<\/code> argument if we are running this command from the template’s root folder:<\/p>\ndotnet new -u .<\/pre>\nThis will uninstall the template. We can install it once again using the dotnet new -i<\/code>\u00a0 as we did in the earlier section.<\/p>\nAfter installing the updated template, let’s create a new project once again. This time, let’s specify the project name argument as well:<\/p>\n
dotnet new codemazeapi -n MySecondAPI<\/pre>\nThis creates a new project as before, but this time we can see it renames the project and solution file with the name that we specified:<\/p>\n
![\"project](\"https:\/\/code-maze.com\/wp-content\/uploads\/2021\/12\/project-with-name-specified.png\")
<\/a><\/p>\nAdditionally, we can see that the namespace is also updated with the name that we provided.<\/p>\n
However, in this case, we can see that the template creates a new project in the folder in which we ran the command and did not create a separate project folder.<\/p>\n
To continue on, let’s see how we can create a new project folder based on the project name.<\/p>\n
The PreferNameDirectory Property<\/h3>\n
The preferNameDirectory<\/code> parameter, once set to true, will match the output folder with the name of the project:\u00a0<\/p>\n{\r\n...\r\n \"shortName\": \"codemazeapi\",\r\n \"sourceName\": \"codemazeapi\",\r\n \"preferNameDirectory\":true,\r\n \"tags\": {\r\n \"language\": \"C#\",\r\n \"type\": \"project\"\r\n }\r\n}<\/pre>\nLet’s uninstall and install the template once again to update it with the latest changes. After that let’s create a new project once again using the updated template:<\/p>\n
dotnet new codemazeapi -n MyThirdAPI<\/pre>\nThis time we can see that it created a new output folder matching the project name and then creates the project files inside it. This is pretty cool and almost matches the capabilities that an inbuilt .NET project template provides.<\/p>\n
<\/a>Creating Custom Parameters for .NET Project Templates<\/h2>\nIt is possible to configure the templates to accept custom parameters and customize the projects based on that. In this section, we are going to see how to implement that.<\/p>\n
For defining custom parameters, we\u00a0can use the symbols<\/code> property :<\/p>\n{\r\n...\r\n \"symbols\":{\r\n \"domain\": {\r\n \"type\": \"parameter\",\r\n \"description\": \"Your domain.\",\r\n \"defaultValue\": \"mydomain.com\",\r\n \"replaces\":\"{DOMAIN}\"\r\n }\r\n }\r\n}\r\n<\/pre>\nIn this example, we define just one parameter called domain<\/code>.\u00a0<\/p>\nEach parameter has these properties:<\/p>\n
To see all the available templates, we can use the This will list all built-in templates as well as the custom ones if we have installed any.<\/p>\n However, sometimes we may need to create our project templates for specific contexts. For instance, an organization may have a requirement that all projects that they create need to follow a specific structure and format. The .NET CLI includes a template engine, which can create projects from a specified template. We are going to see how we can create our project template to use with .NET CLI and Visual Studio.<\/p>\n For that, first, let’s prepare a project.<\/p>\n We can start by creating a standard ASP.NET Core Web API project and then customizing it.<\/p>\n That said, let’s create a new project using dotnet CLI:<\/p>\n Since we specify the output folder name as Now we are going to customize this project a bit. First,\u00a0 let’s remove the Finally, in the Note that in this example we are working with .NET 6. If we use a different version, the default templates and source files could be a little different, but we can always customize those to match this example.<\/p>\n Our customized Web API project is ready. The next step is to create a template out of it.<\/p>\n For creating a template from an existing project, we need to create a new folder With this, our custom project template is ready. The next step is to install it.<\/p>\n For installing the project template locally,\u00a0 we have to run the Notice that we used This will install the template package locally:<\/p>\n Now if we run the We have created our .NET project template and installed it locally. The next step is to create a project using that template.<\/p>\n For creating a new project using our template, we can use the This will create a new project based on the Note that the project and solution have the same name as the template. Similarly, it uses the same namespace as defined in the template. Additionally, we can notice that this command did not create a project folder, it just creates the project in the same folder where we ran the above command. In the next section, we’ll look at how to customize all these.<\/p>\n Even though we have created a custom project template and created a new project from that template, right now it doesn’t do anything exciting other than copying the source files from the original project folder. However, it is possible to customize the template by modifying the While creating new projects using This will create a new output folder and place the project files inside it. It is a good way to organize projects into separate folders, but the rest of the project contents remain as it is.\u00a0<\/p>\n Now let’s take a look at the After making any changes to the template, we need to uninstall and reinstall the template to update it with the latest changes.<\/p>\n For uninstalling the template, we can use This will uninstall the template. We can install it once again using the After installing the updated template, let’s create a new project once again. This time, let’s specify the project name argument as well:<\/p>\n This creates a new project as before, but this time we can see it renames the project and solution file with the name that we specified:<\/p>\n Additionally, we can see that the namespace is also updated with the name that we provided.<\/p>\n However, in this case, we can see that the template creates a new project in the folder in which we ran the command and did not create a separate project folder.<\/p>\n To continue on, let’s see how we can create a new project folder based on the project name.<\/p>\n The Let’s uninstall and install the template once again to update it with the latest changes. After that let’s create a new project once again using the updated template:<\/p>\n This time we can see that it created a new output folder matching the project name and then creates the project files inside it. This is pretty cool and almost matches the capabilities that an inbuilt .NET project template provides.<\/p>\n It is possible to configure the templates to accept custom parameters and customize the projects based on that. In this section, we are going to see how to implement that.<\/p>\n For defining custom parameters, we\u00a0can use the In this example, we define just one parameter called Each parameter has these properties:<\/p>\ndotnet new<\/code> command with the --list<\/code> option:<\/p>\ndotnet new --list<\/code><\/p>\n<\/a>How to Create a .NET Project Template?\u00a0<\/h2>\n
dotnet new webapi -o codemazeapi<\/code><\/p>\ncodemazeapi<\/code>, this will create a new folder named codemazeapi<\/code>\u00a0and an ASP.NET Core Web API project named codemazeapi<\/code> inside it. The project will have the structure of a standard ASP.NET Core Web API:<\/p>\n<\/a>\u00a0<\/p>\nWeatherForecastController<\/code> and the WeatherForecast<\/code> class. Then let’s add a ValuesController<\/code> inside the Controller<\/code> folder with just a GET<\/code> action method:<\/p>\npublic class ValuesController : ControllerBase\r\n{\r\n public IActionResult Get()\r\n {\r\n return Ok(\"Hi from Code-Maze Web API Template\");\r\n }\r\n}<\/pre>\nlaunchSettings.json<\/code> file, let’s modify the launchUrl<\/code> value to api\/values<\/code>. This will make sure the application hits this controller endpoint on start-up.<\/p>\nCreating Template from Existing .NET Project<\/h3>\n
.template.config<\/code> in the root of the project and<\/span> add a template.json<\/code> file inside it. This file is the most important part of building our custom template. It contains all the key information required for transforming our .NET project into a project template:<\/p>\n{\r\n \"$schema\": \"http:\/\/json.schemastore.org\/template\",\r\n \"author\": \"Muhammed Saleem\",\r\n \"classifications\": [ \"Web\", \"WebAPI\", \"C#\" ],\r\n \"identity\": \"CodeMazeTemplates.WebAPI\",\r\n \"name\": \"Code-Maze Web API Template\",\r\n \"shortName\": \"codemazeapi\",\r\n \"tags\": {\r\n \"language\": \"C#\",\r\n \"type\": \"project\"\r\n }\r\n}<\/pre>\n\n
$schema<\/code>– It defines the schema for the JSON file.<\/li>\nauthor<\/code>– defines the author of the template<\/li>\nclassifications<\/code>– This is used to classify and group the templates. It becomes easier to search and find templates based on the values we provide for this property<\/li>\nidentity<\/code>– It uniquely identifies the template<\/li>\nname<\/code>– the name of the template when it is listed<\/li>\nshortName<\/code>– a short name that we can use while creating a new project from the template using dotnet new<\/code><\/li>\ntags<\/code>– defines a set of tags for the project. Here we specify that it is a project<\/code> template in the C#<\/code> language<\/li>\n<\/ul>\ndotnet new<\/code> with the --install<\/code> or -i<\/code> command from the project root directory:<\/p>\ndotnet new -i .<\/code><\/p>\n.<\/code> argument with the install<\/code> command to indicate the template is located in the current folder. If our template location is different, we need to specify that folder path instead.<\/p>\nThe following template packages will be installed:\r\n C:\\code-maze-repo\\templates\\codemazeapi\r\n\r\nSuccess: C:\\code-maze-repo\\templates\\codemazeapi installed the following templates:\r\nTemplate Name Short Name Language Tags\r\n-------------------------- ----------- -------- -------------\r\nCode-Maze Web API Template codemazeapi [C#] Web\/WebAPI\/C#<\/pre>\n
dotnet new --list<\/code> command, it will list our custom template along with the .NET default templates:<\/p>\nTemplate Name Short Name Language Tags\r\n-------------------------------------------- ------------------- ---------- -------------------------------------\r\nASP.NET Core Empty web [C#],F# Web\/Empty\r\nASP.NET Core gRPC Service grpc [C#] Web\/gRPC\r\nASP.NET Core Web API webapi [C#],F# Web\/WebAPI\r\nASP.NET Core Web App razor,webapp [C#] Web\/MVC\/Razor Pages\r\nASP.NET Core Web App (Model-View-Controller) mvc [C#],F# Web\/MVC\r\nASP.NET Core with Angular angular [C#] Web\/MVC\/SPA\r\nASP.NET Core with React.js react [C#] Web\/MVC\/SPA\r\nASP.NET Core with React.js and Redux reactredux [C#] Web\/MVC\/SPA\r\nBlazor Server App blazorserver [C#] Web\/Blazor\r\nBlazor WebAssembly App blazorwasm [C#] Web\/Blazor\/WebAssembly\/PWA\r\nClass Library classlib [C#],F#,VB Common\/Library\r\nCode-Maze Web API Template codemazeapi [C#] Web\/WebAPI\/C#\r\nConsole App console [C#],F#,VB Common\/Console\r\n...<\/pre>\n
Creating New Projects Using a Custom Template<\/h3>\n
dotnet new<\/code> command:<\/p>\ndotnet new codemazeapi<\/code><\/p>\ncodemazeapi<\/code> template.<\/p>\n<\/a>Customizing .NET Project Templates<\/h2>\n
template.json<\/code> file and providing additional parameters while creating projects. Let’s take a look at a few parameters that come out of the box with .NET templates.<\/p>\nThe Output Parameter<\/h3>\n
dotnet new<\/code>, it is possible to specify an output folder by using the -o<\/code>\u00a0parameter:<\/p>\ndotnet new codemazeapi -o MyFirstAPI<\/code><\/p>\nThe SourceName Parameter<\/h3>\n
sourceName<\/span><\/code> parameter. This represents the name of the project and the namespace that it uses. Once we specify this in the template.json<\/code> file, it acts as a placeholder and we can override that value while creating projects using the -n<\/code>\u00a0parameter:<\/p>\n{\r\n...\r\n \"shortName\": \"codemazeapi\",\r\n \"sourceName\": \"codemazeapi\",\r\n \"tags\": {\r\n \"language\": \"C#\",\r\n \"type\": \"project\"\r\n }\r\n}<\/pre>\ndotnet new -u<\/code> command.\u00a0 Along with that, we need to either specify the folder of the template or use the .<\/code> argument if we are running this command from the template’s root folder:<\/p>\ndotnet new -u .<\/pre>\n
dotnet new -i<\/code>\u00a0 as we did in the earlier section.<\/p>\ndotnet new codemazeapi -n MySecondAPI<\/pre>\n
<\/a><\/p>\nThe PreferNameDirectory Property<\/h3>\n
preferNameDirectory<\/code> parameter, once set to true, will match the output folder with the name of the project:\u00a0<\/p>\n{\r\n...\r\n \"shortName\": \"codemazeapi\",\r\n \"sourceName\": \"codemazeapi\",\r\n \"preferNameDirectory\":true,\r\n \"tags\": {\r\n \"language\": \"C#\",\r\n \"type\": \"project\"\r\n }\r\n}<\/pre>\ndotnet new codemazeapi -n MyThirdAPI<\/pre>\n
<\/a>Creating Custom Parameters for .NET Project Templates<\/h2>\n
symbols<\/code> property :<\/p>\n{\r\n...\r\n \"symbols\":{\r\n \"domain\": {\r\n \"type\": \"parameter\",\r\n \"description\": \"Your domain.\",\r\n \"defaultValue\": \"mydomain.com\",\r\n \"replaces\":\"{DOMAIN}\"\r\n }\r\n }\r\n}\r\n<\/pre>\ndomain<\/code>.\u00a0<\/p>\n