ASP.NET Core Hero Boilerplate - Quick Start Guide (codewithmukesh.com)
ASP.NET Core Boilerplate - Visual Studio Marketplace
ASP.NET Core Boilerplate - Muhammad Rehan Saeed
Whats New in ASP.NET Core Boilerplate - Muhammad Rehan Saeed
.NET 6 ASP.NET Core Migration (github.com)
Maybe it's time to rethink our project structure with .NET 6 - Tim Deschryver
Where Are My Favorite Extensions in Visual Studio 2022? - Visual Studio Blog (microsoft.com)
Where Are My Favorite Extensions in Visual Studio 2022?
MicroserviceTemplate - Visual Studio Marketplace
Microservice template gives you a possibility to start developing a microservice architecture with UI (Swagger Open API) and Mediatr (CQRS). Template Based on NET 6.0.x.
Productivity Power Tools 2022 - Visual Studio Marketplace
Installs the individual extensions of Productivity Power Tools 2022
CodeMaid VS2022 - Visual Studio Marketplace
Code Cleanup On Save - Visual Studio Marketplace
CleanArchitectureCQRSTemplate - Visual Studio Marketplace
Clean Architecture (CQRS) 的 (Application/Domain/Infrastructure) 層範本. 使用 MediatR 為基礎的 CQRS 樣板。 提供： Application Services Domain Layer Infrastructure UI = 使用 .NET 5 MVC
Serene - Visual Studio Marketplace
UWP Essentials - Visual Studio Marketplace
The easiest way to set up Visual Studio for the ultimate UWP development experience.
.NET MAUI Project and Item Templates - Visual Studio Marketplace
.NET MAUI Project, Item Templates, and Code Snippets for Visual Studio 2022 (.NET MAUI Preview 10).
Create a New Repository from fullstackhero/dotnet-webapi-boilerplate (github.com)
fullstackhero - Open-Source Boilerplates for Modern Web Applications
PAPA React (papareact.com) Zero to Full Stack Hero
HTML, CSS từ Zero đến Hero | by F8 (fullstack.edu.vn)
Implementing a microservice domain model with .NET | Microsoft Docs
The simplicity of ASP.NET Endpoints - Tim Deschryver
These new routing APIs have far less overhead than controller-based APIs. Using the new routing APIs, ASP.NET Core is able to achieve ~800k RPS in the TechEmpower JSON benchmark vs ~500k RPS for MVC.
Minimal APIs at a glance (github.com)
.NET 6 introduces a new hosting model for ASP.NET Core applications. This model is streamlined and reduces the amount of boilerplate code required to get a basic ASP.NET Core application up and running.
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello World");
app.Run();
This model unifies Startup.cs and Program.cs into a single file experience that takes advantage of top level statements to remove any boilerplate. There should be a mostly mechanical translation from .NET 5 projects using a Startup class to the new hosting model:
Program.cs (.NET 5)
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
}
Startup.cs (.NET 5)
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
}
}
Program.cs (.NET 6)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
The above shows that ConfigureServices(IServiceCollection) can be configured using WebApplicationBuilder.Services and Configure(IApplicationBuilder...) can be configured by using WebApplication.
The developer exception page middleware is enabled when the environment is Development.
The application name always defaults to the entry point assembly's name Assembly.GetEntryAssembly().GetName().FullName. When using the WebApplicationBuilder in a library, you will need to explicitly change the application name to the library's assembly to allow MVC's application part discovery to work (finding controllers, views etc) (see the Cheatsheet for instructions on how to do this).
The endpoint routing middleware wraps the entire middleware pipeline. This means there's no need to have explicit calls to UseEndpoints to register routes. UseRouting can still be used to move where route matching happens.
The final pipeline is created before any IStartupFilter runs. This means that exceptions caused while building the main pipeline won't be visible to the IStartupFilter call chain.
Some tools (like EF migrations) use Program.CreateHostBuilder to access the application's IServiceProvider to execute custom logic in the context of the application, these tools have been updated to use a new technique to achieve the same thing. We will work with the ecosystem to make sure tools are all updated to use the new model.
It is not possible to change any host settings (application name, environment or the content root) after the creation of the WebApplicationBuilder (see the Cheatsheet for instructions on how to do this). The following APIs will throw an exception:
WebHost
builder.WebHost.UseContentRoot(Directory.GetCurrentDirectory());
builder.WebHost.UseEnvironment(Environments.Staging);
builder.WebHost.UseSetting(WebHostDefaults.ApplicationKey, "ApplicationName2");
builder.WebHost.UseSetting(WebHostDefaults.ContentRootKey, Directory.GetCurrentDirectory());
builder.WebHost.UseSetting(WebHostDefaults.EnvironmentKey, Environments.Staging);
Host
builder.Host.UseEnvironment(Environments.Staging);
builder.Host.UseContentRoot(Directory.GetCurrentDirectory());
It is not possible to use the Startup class via the WebApplicationBuilder.Host or WebApplicationBuilder.WebHost. The following will throw an exception:
var builder = WebApplication.CreateBuilder(args);
builder.Host.ConfigureWebHostDefaults(webHostBuilder =>
{
webHostBuilder.UseStartup<Startup>();
});
OR
var builder = WebApplication.CreateBuilder(args);
builder.WebHost.UseStartup<Startup>();
The IHostBuilder implementation on WebApplicationBuilder (WebApplicationBuilder.Host), does not defer execution of ConfigureServices, ConfigureAppConfiguration or ConfigureHostConfiguration methods. This allows code using WebApplicationBuilder to observe changes made to the IServiceCollection and IConfiguration. The below example will only add Service1 as an IService.
using Microsoft.Extensions.DependencyInjection.Extensions;
var builder = WebApplication.CreateBuilder(args);
builder.Host.ConfigureServices(services =>
{
services.TryAddSingleton<IService, Service1>();
});
builder.Services.TryAddSingleton<IService, Service2>();
var app = builder.Build();
// This will print Service1
Console.WriteLine(app.Services.GetRequiredService<IService>());
app.Run();
class Service1 : IService
{
}
class Service2 : IService
{
}
interface IService
{
}
The existing .NET ecosystem has built extensibility around IServiceCollection, IHostBuilder and IWebHostBuilder. These properties are available on the WebApplicationBuilder as Services, Host and WebHost.
The WebApplication implements both Microsoft.AspNetCore.Builder.IApplicationBuilder and Microsoft.AspNetCore.Routing.IEndpointRouteBuilder.
We expect library authors to continue targeting IHostBuilder, IWebHostBuilder, IApplicationBuilder and IEndpointRouteBuilder when building ASP.NET Core specific components. This will ensure that your middleware, route handler, or other extensibility points continue to work across different hosting models.
No, it should be functionally equivalent for 98% to what you can do with the IHostBuilder and the IWebHostBuilder. There are more advanced scenarios (the 2%) that will require specific knobs on IHostBuilder but we expect those to be extremely rare.
No, it's not. It's an alternative model that will keep working forever. The generic host still underpins the new hosting model and is still the primary way to host worker-based applications.
No, you don't have to. It's the preferred way to host ASP.NET Core applications from .NET 6 and onwards but you aren't forced to change your project layout. This means you can upgrade from .NET 5 to .NET 6.0 by changing the target framework in your project file from net5.0 to net6.0.
The new project templates all use top-level statements, but these new hosting APIs can be used in any .NET 6 application to host a webserver/web application.
There are 2 solutions to this problem:
This is an example of #2:
.NET 5
public class Startup
{
public static string ConfigurationValue { get; private set; }
public Startup(IConfiguration configuration)
{
Configuration = configuration;
ConfigurationValue = Configuration["SomeValue"];
}
public IConfiguration Configuration { get; }
// More configuration here
}
.NET 6
var builder = WebApplication.CreateBuilder(args);
ConfigurationValue = builder.Configuration["SomeValue"];
var app = builder.Build();
app.Run();
partial class Program
{
public static string ConfigurationValue { get; private set; }
}
This would make it possible to use Program.ConfigurationValue in your .NET 6 application.
NOTE: We recommend using dependency injection to flow state in your ASP.NET Core applications.
WebApplicationFactory<TEntryPoint> is the way to test the new hosting model. See the Cheatsheet for an example.
This is still supported, see the Cheatsheet for an example.
Yes, you can. Here's a shim you can use to keep it working as is with the new hosting model:
Program.cs
var builder = WebApplication.CreateBuilder(args);
var startup = new Startup(builder.Configuration);
startup.ConfigureServices(builder.Services);
// Uncomment if using a custom DI container
// builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
// builder.Host.ConfigureContainer<ContainerBuilder>(startup.ConfigureContainer);
var app = builder.Build();
startup.Configure(app, app.Environment);
app.Run();
Startup.cs
class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public void ConfigureServices(IServiceCollection services)
{
}
// Uncomment if using a custom DI container
// public void ConfigureContainer(ContainerBuilder builder)
// {
// }
public void Configure(IApplicationBuilder app, IWebHostEnvironment environment)
{
}
}
There are a few differences here:
.NET 5
public class Startup
{
public void Configure(IApplicationBuilder app)
{
app.UseStaticFiles();
}
}
.NET 6
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.UseStaticFiles();
app.Run();
.NET 5
public class Startup
{
public void Configure(IApplicationBuilder app)
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGet("/", () => "Hello World");
});
}
}
.NET 6
In .NET 6, routes can be added directly to the WebApplication without an explicit call to UseEndpoints.
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello World");
app.Run();
NOTE: Routes added directly to the WebApplication will execute at the end of the pipeline.
.NET 5
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseContentRoot(Directory.GetCurrentDirectory())
.UseEnvironment(Environments.Staging)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>()
.UseSetting(WebHostDefaults.ApplicationKey, typeof(Program).Assembly.FullName);
});
.NET 6
var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
ApplicationName = typeof(Program).Assembly.FullName,
ContentRootPath = Directory.GetCurrentDirectory(),
EnvironmentName = Environments.Staging
});
Console.WriteLine($"Application Name: {builder.Environment.ApplicationName}");
Console.WriteLine($"Environment Name: {builder.Environment.EnvironmentName}");
Console.WriteLine($"ContentRoot Path: {builder.Environment.ContentRootPath}");
var app = builder.Build();
.NET 5
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureAppConfiguration(config =>
{
config.AddIniFile("appsettings.ini");
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
.NET 6
var builder = WebApplication.CreateBuilder(args);
builder.Configuration.AddIniFile("appsettings.ini");
var app = builder.Build();
.NET 5
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureLogging(logging =>
{
logging.AddJsonConsole();
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
.NET 6
var builder = WebApplication.CreateBuilder(args);
// Configure JSON logging to the console
builder.Logging.AddJsonConsole();
var app = builder.Build();
.NET 5
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
// Add the memory cache services
services.AddMemoryCache();
// Add a custom scoped service
services.AddScoped<ITodoRepository, TodoRepository>();
}
}
.NET 6
var builder = WebApplication.CreateBuilder(args);
// Add the memory cache services
builder.Services.AddMemoryCache();
// Add a custom scoped service
builder.Services.AddScoped<ITodoRepository, TodoRepository>();
var app = builder.Build();
.NET 5
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureHostOptions(o => o.ShutdownTimeout = TimeSpan.FromSeconds(30));
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
Existing extension methods on IHostBuilder can be accessed using the Host property.
.NET 6
var builder = WebApplication.CreateBuilder(args);
// Wait 30 seconds for graceful shutdown
builder.Host.ConfigureHostOptions(o => o.ShutdownTimeout = TimeSpan.FromSeconds(30));
var app = builder.Build();
.NET 5
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
// Change the HTTP server implemenation to be HTTP.sys based
webBuilder.UseHttpSys()
.UseStartup<Startup>();
});
.NET 6
Existing extension methods on IWebHostBuilder can be accessed using the WebHost property.
var builder = WebApplication.CreateBuilder(args);
// Change the HTTP server implemenation to be HTTP.sys based
builder.WebHost.UseHttpSys();
var app = builder.Build();
By default, the web root is relative to the content root in the wwwroot folder. This is where the static files middleware expects to find static files. You can change this by using the UseWebRoot method on the WebHost property:
.NET 5
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
// Look for static files in webroot
webBuilder.UseWebRoot("webroot")
.UseStartup<Startup>();
});
.NET 6
var builder = WebApplication.CreateBuilder(args);
// Look for static files in webroot
builder.WebHost.UseWebRoot("webroot");
var app = builder.Build();
This example uses Autofac
.NET 5
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
});
public class Startup
{
public void ConfigureContainer(ContainerBuilder containerBuilder)
{
}
}
.NET 6
var builder = WebApplication.CreateBuilder(args);
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
// Register your own things directly with Autofac here. Don't
// call builder.Populate(), that happens in AutofacServiceProviderFactory
// for you.
builder.Host.ConfigureContainer<ContainerBuilder>(builder => builder.RegisterModule(new MyApplicationModule()));
var app = builder.Build();
.NET 5
In Startup.Configure you can inject any service added via the IServiceCollection.
public class Startup
{
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IService, Service>();
}
// Anything added to the service collection can be injected into Configure
public void Configure(IApplicationBuilder app,
IWebHostEnvironment env,
IHostApplicationLifetime lifetime,
IService service,
ILogger<Startup> logger)
{
lifetime.ApplicationStarted.Register(() =>
logger.LogInformation($"The application {env.ApplicationName} started in we injected {service}"));
}
}
.NET 6
In .NET 6, there are a few common services available as top level properties on WebApplication and additional services need to be manually resolved from the IServiceProvider via WebApplication.Services.
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<IService, Service>();
var app = builder.Build();
IService service = app.Services.GetRequiredService<IService>();
ILogger logger = app.Logger;
IHostApplicationLifetime lifetime = app.Lifetime;
IWebHostEnvironment env = app.Environment;
lifetime.ApplicationStarted.Register(() =>
logger.LogInformation($"The application {env.ApplicationName} started in we injected {service}"));
app.Run();
In the below samples, the test project uses TestServer and WebApplicationFactory. These ship as separate packages that need to explicit referenced:
WebApplicationFactory
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="{Version}" />
</ItemGroup>
TestServer
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.TestHost" Version="{Version}" />
</ItemGroup>
This sample is using xUnit and IHelloService will be shared between both examples:
public interface IHelloService
{
string HelloMessage { get; }
}
public class HelloService : IHelloService
{
public string HelloMessage => "Hello World";
}
.NET 5
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IHelloService, HelloService>();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IHelloService helloService)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGet("/", async context =>
{
await context.Response.WriteAsync(helloService.HelloMessage);
});
});
}
}
With TestServer
[Fact]
public async Task HelloWorld()
{
using var host = Host.CreateDefaultBuilder()
.ConfigureWebHostDefaults(builder =>
{
// Use the test server and point to the application's startup
builder.UseTestServer()
.UseStartup<WebApplication1.Startup>();
})
.ConfigureServices(services =>
{
// Replace the service
services.AddSingleton<IHelloService, MockHelloService>();
})
.Build();
await host.StartAsync();
var client = host.GetTestClient();
var response = await client.GetStringAsync("/");
Assert.Equal("Test Hello", response);
}
class MockHelloService : IHelloService
{
public string HelloMessage => "Test Hello";
}
With WebApplicationFactory
[Fact]
public async Task HelloWorld()
{
var application = new WebApplicationFactory<Program>()
.WithWebHostBuilder(builder =>
{
builder.ConfigureServices(services =>
{
services.AddSingleton<IHelloService, MockHelloService>();
});
});
var client = application.CreateClient();
var response = await client.GetStringAsync("/");
Assert.Equal("Test Hello", response);
}
class MockHelloService : IHelloService
{
public string HelloMessage => "Test Hello";
}
.NET 6
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<IHelloService, HelloService>();
var app = builder.Build();
var helloService = app.Services.GetRequiredService<IHelloService>();
app.MapGet("/", async context =>
{
await context.Response.WriteAsync(helloService.HelloMessage);
});
app.Run();
In .NET 6, WebApplicationFactory<TEntryPoint> is used to test application using new hosting model. The compiler produces an internal Program class applications that use top level statements. We need to make this available to the test project by using InternalsVisibleTo. This can be done using the project file or in any other .cs file:
MyProject.csproj
<ItemGroup>
<InternalsVisibleTo Include="MyTestProject" />
</ItemGroup>
OR
[assembly: InternalsVisibleTo("MyTestProject")]
The other solution is to make the Program class public. You can do this with top level statements by defining a public partial Program class anywhere in the project (or in Program.cs):
Program.cs
var builder = WebApplication.CreateBuilder(args);
// ... Wire up services and routes etc
app.Run();
public partial class Program { }
[Fact]
public async Task HelloWorld()
{
var application = new WebApplicationFactory<Program>()
.WithWebHostBuilder(builder =>
{
builder.ConfigureServices(services =>
{
services.AddSingleton<IHelloService, MockHelloService>();
});
});
var client = application.CreateClient();
var response = await client.GetStringAsync("/");
Assert.Equal("Test Hello", response);
}
class MockHelloService : IHelloService
{
public string HelloMessage => "Test Hello";
}
The .NET 5 version and .NET 6 version with the WebApplicationFactory are identical. This is by design.
sanjyotagureddy/aspnetrun-microservices: Building Microservices on .Net Ecosystem (github.com)
1) Examples and Tutorials of Event Sourcing in .NET
oskardudycz/EventSourcing.NetCore: Examples and Tutorials of Event Sourcing in .NET (github.com)
2) Full Modular Monolith application with Domain-Driven Design approach
3) Sample .NET Core REST API CQRS implementation with raw SQL and DDD using Clean Architecture
4) Clean Architecture with .NET5, C#9 and React+Redux. Use cases as central organizing structure, completely testable, decoupled from frameworks
5) WhiteApp API solution template which is built on Onion Architecture with all essential feature using .NET 5!
WhiteApp or QuickApp API solution template which is built on Onion Architecture with all essential feature using .NET Core
Onion Architecture - Visual Studio Marketplace
This is default white application for ASP.NET Core API development
This whiteapp contains following features, uncheck feature need to implement yet.
Below features will be implemented in infrastructure layer. You can plug and play based on your project.
Use this template
gtechsltn/Onion-Architecture-ASP-NET-Core (github.com)
gtechsltn/SimpleWebApps (github.com)
6) Clean Architecture Template for .NET 6.0 WebApi built with Multitenancy Support
4 Tips for Using Responsive Web Design Effectively - The Media Temple Blog
Expert advice: 50 tips for improving your software development skills (techbeacon.com)
How do you keep improving as a software engineer? Some pieces of advice are valid no matter your experience level, but often the advice will depend on where you are in your career.
If you're a beginner, the best advice is to simply learn your language, frameworks, and tools top to bottom and gain more experience with a variety of different projects.
If you're an experienced software developer, you should constantly try to find new ways to optimize your code for readability, performance, and maintainability, and then practice making well-reasoned decisions about where to focus time and resources in your code—whether it's testing, performance optimization, or other technical debt.
Those are some of the themes you’ll find if you ask veteran software engineers to share their best advice for being a great programmer. There aren’t any well-kept secrets. The advice of many of the most successful developers is readily available to you on blogs and forums.
I’ve taken the most illustrative advice and recurring tips from blogs and forums and organized them into five categories that emerged as I compiled them. I've paraphrased and merged various similar tips into single snippets, and I've also left a few pieces of advice as untouched quotes from their authors.
Whether you have five, ten, or twenty years of experience programming—or if you have almost no experience—I think just about every developer will find some good ideas for self-improvement.
1. The best programmers can take a complex problem, break it down into smaller pieces, solve each of those pieces, and then put everything back together to solve the initial problem.
2. Software is just a tool for solving domain problems. Since it’s needed in almost all domains, develop in one that interests you. If you understand a domain well and are passionate about it, you’ll be a much better, more motivated developer. You’ll also be exponentially more valuable and lucrative to companies hiring in your chosen domain.
3. Don’t let one domain pigeonhole you into one way of coding. An example would be a mobile developer who is mainly good at hooking together existing APIs but can't come up with a sane data representation. Don’t be a one-trick pony.
4. Plan your code away from the computer. It will help you build a clear mental model before you start. You use the same strategy in writing, because if you don’t have an outline, your content becomes a messy stream of consciousness.
5. “When you're stuck, write your program on paper. I'm serious. It's magic. This is standard practice in programming competitions. (I think it works because when you don't have to think about syntax you have more excess brain power to solve the actual problem.)” (Source)
—Joseph Gentle
6. “Compelling web apps tend to be the ones that use data in unexpected ways or in ways that solve everyday problems. Learn everything you can about data storage.” (Source)
—Maggie Nelson
7. As an architect, you can’t have blind spots in your understanding of your applications and their execution environments. You need to know how things work in the front end (UI), the back end, the data store, the OS, any virtualization layers, the hardware, the network, and the data center.
8. Contribute to open-source projects as a bridge from beginner to intermediate. Collaborate with the developers of the project and attend meetups to collaborate with other developers in person.
9. Don’t let anything get in the way of that initial motivation to learn programming and just build something. Sometimes you block yourself by having too much focus on reading books or resources first. Other times beginners will try to find the perfect first language. Your first language doesn’t matter. What matters is learning to program well. Just start coding.
10. "Learning programming languages is NOT learning how to program. Focus on programming techniques, problem solving, and analytical skills, not on learning as many languages as you can."
—Richard Eng
11. Learn multiple programming paradigms such as object-oriented programming, functional programming, reflective programming, etc. Believe it or not, your programming in one paradigm will improve after studying an alternative paradigm.
12. "Wherever possible, always choose the simpler programming language. More complex languages increase the cognitive load on your brain. Simpler languages do not necessarily give up anything in terms of power or expressiveness."
—Richard Eng
13. Beginners learn just enough of their tools to get by. To become an intermediate or expert developer, you need to know your tools cold. Learn all of the features, menus, and context menus. Learn to use them without a mouse by memorizing keyboard shortcuts. Find every “tips and tricks” article available.
14. Learn your stack on the deepest levels before you decide to reinvent the wheel. Peter Nixey gives a few good examples: “If you are a Ruby developer take time to learn the language's incredible range of methods. If you are a Node developer, take time to understand the architecture, the methods, and the mindset of Node. If you are an Angular developer go right up to the rock-face and understand the logic behind of the incredible architecture the core team is forging there right now. Ask before you invent.” (Source)
—Peter Nixey
15. The same goes for the languages you work in. Learn the most important libraries for your use cases. The more libraries you’re aware of, the less likely you are to try reinventing the wheel.
16. Whenever you can, use programming languages that will eliminate entire classes of run-time errors. To do that, look for languages with features like strong typing, static typing, managed memory, and/or immutable data.
17. “Frameworks, libraries, languages, never mind if you can’t understand what you find under the hood on your first attempt. You can always put them aside and return to them later, just see to it that you can take them apart and have a look. All the rules you have to follow when you first learn were invented by someone, you can make them yours to reinvent with some persistence. Steer clear of tools that put barriers in the way of this activity, those make you depend on them in the wrong way.” (Source)
—Jan Christian Meyer
18. “[When reading high-quality code], it might be tempting to look for main() and start from there, but you're likely to spend a lot of time just reading set-up code and command-line parsing. I prefer to scan the filenames to look for some activity that interests me and then dig into those files. It's not crucial to understand the whole project or the ins and outs of the entire design, you'll wear yourself out doing this. Read the code. Look at the comments, see what the authors are doing, and how they went about it.” (Source)
—Andrew Binstock
19. Create some of your own tools. (But of course, if you're going to use it in production, make sure it's not another wheel reinvention.)
20. Make common programs that have been made before. Not for a production project (see “reinventing the wheel”), but as a learning project. If other developers can make a calculator, text editor, paint, Tetris, or Pong, then so can you. Look at several examples of these apps written by more experienced developers and try to learn their tricks.
21. Develop an aesthetic appreciation for code. Read the source code of famous open-source tools and frameworks such as Ruby on Rails or Jenkins, and get familiar with norvig.com. Over time, you need to train yourself to know what great code looks like and what bad code “smells” like.
22. “Don't ask permission to refactor, test, document etc. It's all part of ‘programming’. Don't ask permission to do your job.” (Source)
—Jerome Terry
23. "Fix what isn’t broken. You should go to your last project and read through the code. Think about what each piece does. There's a loop here, some sorting there, a bit of number crunching, screen updates, HTML generation, database CRUD, that sort of thing. Now replace the hard-coded HTML with a templating system, get the database CRUD out of your business objects and re-write it to use proper parameterized queries instead of string concatenation, replace all the "writelns" and "MessageBoxes" in your error handlers with a logging framework, refactor code that's trying to borrow methods from other classes, use locale-aware string formatting, stop guessing how big an array should be and use a dynamic collection, delete orphaned code." (Source)
—Chris Wenham
24. Most developers have heard the saying, "Always write code as if the person who ends up maintaining it will be a violent psychopath who knows where you live." What that means realistically is that you should write readable code that could be easily comprehended a year later by someone who’s disinterested and in a hurry. If you’ve ever had to dig through indecipherable code, you know why this is so important. Have some empathy for the developers who will read your code.
25. Name variables so that other developers can understand your code better. This is a skill you need to nurture.
26. Using inheritance often reduces testability and reusability of your object-oriented code in the long run. Your first choice should be using composition and interfaces.
27. Don’t use design patterns like a hammer looking for a nail. If you don’t have a clear reason you need it, don’t use it.
28. Always favor shallow code hierarchies to deep-nested code (whether it’s inside or outside a function). Deep-nested code is harder to maintain, harder to reuse, and more likely to create bugs.
29. Reusable code is helpful and important, but trying to write overgeneralized, super flexible code is often a waste of time. This kind of code is usually harder to maintain and causes bugs. It’s okay to hardcode some things if your code is doing one task.
30. Master the art of debugging using "print statements." There are many scenarios where a sophisticated debugger is not available to you, but I've never found a platform nor environment where you couldn't output textual information to a screen or file.
—Richard Eng
31. Having great writing and communication skills directly translates into programming capability. Joel Spolsky can elaborate on why this is:
"The difference between a tolerable programmer and a great programmer is not how many programming languages they know, and it's not whether they prefer Python or Java. It's whether they can communicate their ideas. By persuading other people, they get leverage. By writing clear comments and technical specs, they let other programmers understand their code, which means other programmers can use and work with their code instead of rewriting it. Absent this, their code is worthless."
32. Just like natural languages, you haven’t mastered programming until you see and think in code. A popular book, Structure and Interpretation of Computer Programs, by Abelson, Sussman, is one of the best resources to help you do this. Don’t worry that its examples are in Scheme; it's an optimal language for learning to think in code.
33. Donald Knuth, is known for his maxims “When in doubt, use brute force” and “Premature optimization is the root of all evil.” When he says “use brute force,” he means that you shouldn’t let yourself get stuck trying to come up with a prematurely optimal algorithm. Just use the simplest, unsophisticated algorithm that will work and iterate from there. Using the simplest formula will also help you better understand how your software should work so that you can start forming a mental model with which to think of better, more efficient algorithms.
34. Know when to take on technical debt and when to pay it off so it doesn’t compound. When exploring (and discarding) different features and pivoting frequently, borrow heavily on technical debt. When your position is stable and your direction is clearer, optimize your remaining features and clean up bugs to pay off that technical debt before moving on to the next stage.
35. Within the context of your projects, learn what the right amount of testing is. Too little and your software becomes unreliable and everyone is afraid to deploy to production. Too much and you’ll end up wasting too much time and resources writing and maintaining them, while also making the development process slower.
36. Estimating time is hard. This is why iterative development methods such as Scrum are so popular. Push yourself and your team to have increasingly shorter release cycles. Surprisingly, shipping code more frequently reduces risk instead of increasing it. It forces you to have better organizational practices and make a better product for the customer with faster feedback.
37. Commit your code in small, working chunks and write a detailed commit messages that will help developers find and understand bugs that may have been introduced in that commit. Just summarize what you did and why you did it.
38. Most developers don’t think about security in every unit of code they write. Many think that frameworks will handle that for them. Don’t be like most developers.
39. You can spend an exponentially greater amount of time hunting down the last 1% of bugs in a project than you would for the first 90%. If you’re not working in a domain that requires your software to work perfectly 99.999% of the time, then you should spend less time debugging the edge cases and features people probably won’t use.
40. Have large chunks of time set aside for focused coding each day. The quantity of time spent coding is meaningless if it’s full of interruptions such as meetings, emails, and web browsing.
41. Communicate clearly with your team about what you’re doing each day. Talking about your architectural approaches will help you think about those approaches in new ways. It has nothing to do with proving to people that you’re doing good work. More likely, your team will have some ideas you would have never thought of on your own, and you’ll solve problems a lot faster. Your team should also document solutions and share them on a wiki to save valuable time for everyone.
42. Don’t be ashamed to admit when you don’t know something. As a developer, you’re often solving new problems, so you can’t be expected to know all the solutions immediately. Trying to hide your lack of knowledge only slows the learning process.
43. Don’t be afraid to share your unfinished work with others frequently.
44. "Emotionally detach from your code. Find the code that you're the most proud of and delete it, then rewrite it from scratch in a different way. Use a "design pattern" that confuses you or that you hate (e.g., the Singleton) and figure out how to make it work. If necessary, delete that after you've got it working and try again with a new pattern or language. Not only will you learn that there's More Than One Way To Do It, but you'll learn that your code is transitory. Code, by its nature, is not just inextricably glued to its language, platform, and the APIs it consumes, but written in the form of ephemeral static charges, orientations of magnetic particles, subject to the whims of the market, Moore's Law, and your employer. … Remember that emotional detachment from code is a virtue, but this doesn't mean emotional detachment from your work is, too. In fact, another way to become emotionally detached from code is to put your interest into the outcome instead." (Source)
—Chris Wenham
45. Googling is a crucial developer skill. Learning how to do something you haven’t done before and finding optimal solutions from the collective intelligence of the developer community is half the battle in programming.
46. "Good programmers know what to write, but great ones know what to rewrite (and reuse)." (Source)
—Eric S. Raymond
47. Teach. Even if you’re a novice at programming, you’re knowledgeable about something. Teaching teaches the teacher. And if you can train other workers, your manager should realize that you’re exponentially more valuable.
48. Don’t focus on becoming a “10x” programmer. Read these articles by Matt Asay and Scott Hanselman to see why.
49. “You won’t—you cannot—become a better programmer through sheer force of programming alone. You can only complement and enhance your existing programming skills by branching out. Learn about your users. Learn about the industry. Learn about your business. The more things you are interested in, the better your work will be.” (Source)
—Jeff Atwood
50. Make mistakes, ask questions, get rapid feedback, get uncomfortable, compare it to what you know, keep going. More on that here.
NMillard/BasicSolutionStructure (github.com)
gtechsltn/BasicSolutionStructure (github.com)
MongoDB and Data Streaming: Implementing a MongoDB Kafka Consumer - DZone Big Data
Data Streaming with Apache Kafka & MongoDB - EMEA (slideshare.net)
MongoDB Connector for Apache Kafka 1.5 Available Now | MongoDB
We have implemented below features over the run-aspnetcore-microservices repository.
Configuring the AWS SDK for .NET with .NET Core - AWS SDK for .NET (version 3) (amazon.com)
NuGet Packages:
+ AWSSDK.S3 (Amazon Simple Storage Service (Amazon S3), provides developers and IT teams with secure, durable, highly-scalable object storage.)
+ AWSSDK.Extensions.NETCore.Setup (Extensions for the AWS SDK for .NET to integrate with .NET Core configuration and dependency injection frameworks.)
+ AWSSDK.DynamoDBv2 (Amazon DynamoDB is a fast and flexible NoSQL database service for all applications that need consistent, single-digit millisecond latency at any scale.)
+ AWSSDK.CognitoIdentity (Amazon Cognito is a service that makes it easy to save user data, such as app preferences or game state, in the AWS Cloud without writing any backend code or managing any infrastructure. With Amazon Cognito, you can focus on creating great app experiences instead of having to worry about building and managing a backend solution to handle identity management, network state, storage, and sync.)
Amazon Cognito: User Identity Management
Successful web or mobile applications can reach millions of users, and it is critical that such applications have a robust and scalable approach for user and identity management.
Applications can have specific requirements, such as using their own identity store, or leveraging an existing identity provider such as Facebook, Google, or Amazon. Some need to use a combination of their own identity store with existing identity providers. This is often coupled with requirements for a user interface that handles user registration, login, user verification, and forgotten passwords.
Amazon Cognito enables you to add user sign-up, sign-in, and access control to your web and mobile apps quickly and easily. Amazon Cognito scales to millions of users and supports sign-in with social identity providers, including Facebook, Google, and Amazon, and enterprise identity providers via SAML 2.0.
Amazon Cognito can also be used to control access to REST APIS through integration with the Amazon API Gateway service, and can reduce the work to authenticate web application users by integrating with
the Application Load Balancer.
Security features include multi-factor authentication, checks for compromised credentials, account takeover protection, and phone and email verification. Amazon Cognito also supports application specific identity stores, user profiles, and customized workflows and user migration through Lambda triggers.
+ ASP.NET Core Identity for Amazon Cognito
Introducing the ASP.NET Core Identity Provider Preview for Amazon Cognito | AWS Developer Tools Blog
MongoDB - How to backup and restore a database | Jason Watmore's Blog
vb-software/netcore-webapi-starter: .NET Core Web API Starter Template (github.com)
Build a Basic CRUD App with ASP.NET Core 3.0 and MongoDB | Okta Developer
ASP.NET Core 3.1 - Role Based Authorization Tutorial with Example API | Jason Watmore's Blog
Authentication/Authorization:
Node.js + MongoDB API - JWT Authentication with Refresh Tokens | Jason Watmore's Blog
ASP.NET Core 3.1 API - JWT Authentication with Refresh Tokens | Jason Watmore's Blog
https://www.pluralsight.com/paths/mvc5
Suggested load order is:
ASP.NET Core MVC case study solution for codeArbor and PluralSight Guides. Demonstrates client data validation using view models, data annotations, jQuery unobtrusive validation, and the Core MVC ModelState object.
https://github.com/ajsaulsberry/BlipValidate
http://www.codearbor.com/library/building-robust-numeric-fields-for-html-forms-with-aspnet-core-mvc/
----------------------------------------------------------------------------------------------------
Tutorial: Get started with Razor Pages in ASP.NET Core
https://docs.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/razor-pages-start?view=aspnetcore-3.1&tabs=visual-studio
Part 2, add a model to a Razor Pages app in ASP.NET Core
https://docs.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/model?view=aspnetcore-3.1&tabs=visual-studio
Part 3, scaffolded Razor Pages in ASP.NET Core
https://docs.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/page?view=aspnetcore-3.1&tabs=visual-studio
Part 4, with a database and ASP.NET Core
https://docs.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/sql?view=aspnetcore-3.1&tabs=visual-studio
Part 5, update the generated pages in an ASP.NET Core app
https://docs.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/da1?view=aspnetcore-3.1
Part 6, add search to ASP.NET Core Razor Pages
https://docs.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/search?view=aspnetcore-3.1
Part 7, add a new field to a Razor Page in ASP.NET Core
https://docs.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/new-field?view=aspnetcore-3.1&tabs=visual-studio
Part 8, add validation to an ASP.NET Core Razor Page
https://docs.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/validation?view=aspnetcore-3.1&tabs=visual-studio
----------------------------------------------------------------------------------------------------
Razor Pages with Entity Framework Core in ASP.NET Core - Tutorial 1 of 8
https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/intro?view=aspnetcore-3.1&tabs=visual-studio
Part 2, Razor Pages with EF Core in ASP.NET Core - CRUD
https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/crud?view=aspnetcore-3.1
Part 3, Razor Pages with EF Core in ASP.NET Core - Sort, Filter, Paging
https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/sort-filter-page?view=aspnetcore-3.1
Part 4, Razor Pages with EF Core migrations in ASP.NET Core
https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/migrations?view=aspnetcore-3.1&tabs=visual-studio
Part 5, Razor Pages with EF Core in ASP.NET Core - Data Model
https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/complex-data-model?view=aspnetcore-3.1&tabs=visual-studio
Part 6, Razor Pages with EF Core in ASP.NET Core - Read Related Data
https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/read-related-data?view=aspnetcore-3.1&tabs=visual-studio
Part 7, Razor Pages with EF Core in ASP.NET Core - Update Related Data
https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/update-related-data?view=aspnetcore-3.1
Part 8, Razor Pages with EF Core in ASP.NET Core - Concurrency
https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/concurrency?view=aspnetcore-3.1&tabs=visual-studio
----------------------------------------------------------------------------------------------------
ASP.NET Core MVC with EF Core - tutorial series
https://docs.microsoft.com/en-us/aspnet/core/data/ef-mvc/?view=aspnetcore-3.1
----------------------------------------------------------------------------------------------------
Host ASP.NET Core on Windows with IIS
https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/iis/?view=aspnetcore-3.1
----------------------------------------------------------------------------------------------------
ASP.NET Core Middleware
https://docs.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-3.1
----------------------------------------------------------------------------------------------------
ASP.NET Hosting
https://dotnet.microsoft.com/apps/aspnet/hosting
----------------------------------------------------------------------------------------------------
ASP.NET Hosting | Windows Hosting at Winhost
https://www.winhost.com/home.aspx
----------------------------------------------------------------------------------------------------
Handle errors in ASP.NET Core
https://docs.microsoft.com/en-us/aspnet/core/fundamentals/error-handling?view=aspnetcore-3.1
----------------------------------------------------------------------------------------------------
Troubleshoot and debug ASP.NET Core projects - Debug ASP.NET Core apps
https://docs.microsoft.com/en-us/aspnet/core/test/troubleshoot?view=aspnetcore-3.1
----------------------------------------------------------------------------------------------------
Microsoft Security Advisory - ASP.NET Core Vulnerability
https://www.codeproject.com/Articles/1259484/CRUD-Operation-in-ASP-NET-Core-Web-API-with-Entity
https://github.com/mukeshkumartech/CRUD-AspNetCore-WebAPI
https://www.c-sharpcorner.com/article/entity-framework-core-a-code-first-approach/
https://code-maze.com/asp-net-core-web-api-with-ef-core-db-first-approach/
https://github.com/CodeMazeBlog/ef-db-first
CompatibilityVersion.Version_2_1
http://bekenty.com/entityframework-core-asp-net-core/
https://github.com/BekenJB/EmployeeManagerWithEFCore
WITH student_cte AS (
SELECT
First_Name,
Last_Name,
Phone,
ROW_NUMBER() OVER(
PARTITION BY
First_Name,
Last_Name,
Phone
ORDER BY
First_Name,
Last_Name,
Phone
) rn
FROM dbo.Students
)
select * from student_cte;
WITH student_cte AS (
SELECT
First_Name,
Last_Name,
Phone,
ROW_NUMBER() OVER(
PARTITION BY
First_Name,
Last_Name,
Phone
ORDER BY
First_Name,
Last_Name,
Phone
) rn
FROM dbo.Students
)
DELETE FROM student_cte WHERE rn >1;
https://stackoverflow.com/questions/24124644/to-get-the-hosted-web-sites-names-from-iis
Use C# to manage IIS
https://www.codeproject.com/Articles/99634/Use-C-to-manage-IIS
Programmatically Manage IIS
https://www.codeproject.com/Articles/31293/Programmatically-Manage-IIS
Windows XP IIS Manager v1.7
https://www.codeproject.com/Articles/9860/Windows-XP-IIS-Manager-v
Need to install the "IIS Metabase and IIS 6 configuration compatibility
Read more: https://drive.google.com/file/d/19G0_FwXX-odXPnXTk6jVBWCipBODFZdV/
https://www.activexperts.com/support/network-monitor/online/iis6metabase/
Creating Web API in ASP.NET Core 2.0
https://www.codeproject.com/Articles/1264219/Creating-Web-API-in-ASP-NET-Core-2-0
https://www.guru99.com/asp-net-web-api-interview-questions.html
https://www.fullstack.cafe/blog/asp-net-web-api-interview-questions
https://www.udemy.com/course/complete-aspnet-core-21-course/
https://www.codeproject.com/Articles/5262285/Implementing-CQRS-Pattern-with-Vue-js-ASP-NET-Core
https://www.c-sharpcorner.com/article/implementing-cqrs-pattern-with-vue-js-asp-net-core-mvc/
https://codeload.github.com/ColorlibHQ/AdminLTE/zip/v2.4.18 (HAY HAY HAY)
https://github.com/moemura/AdminLTE.Core (HAY HAY HAY)
https://github.com/moemura/AdminLTE.Core/releases/tag/2.0.1
https://github.com/dotnet-express/AdminLTE-Starter-Kit/releases
https://github.com/dotnet-express/AdminLTE-Starter-Kit/releases/tag/v0.8.0
https://github.com/go2ismail/adminlte-aspnetcore2-version
https://github.com/shehryarkn/Dynamic-User-Defined-Dashboards-Asp-Net-Core
https://github.com/shehryarkn/Asp-net-Core-Project-with-Admin-Template-Setup
Checklist: https://www.michaelagreiler.com/code-review-checklist/
Google: https://blog.fullstory.com/what-we-learned-from-google-code-reviews-arent-just-for-catching-bugs/
https://www.cybersecuritycourses.com/course/dev544-secure-coding-in-net-developing-defensible-applications/ (HAY HAY HAY)
https://niccs.us-cert.gov/training/search/sans-institute/secure-coding-net-developing-defensible-applications (HAY HAY HAY)
1. Readability a.k.a. ‘Understandability’ (Khả năng đọc hoặc Khả năng hiểu được)
2. Maintainability (Bảo trì)
3. Security (Bảo mật)
4. Speed and Performance (Tốc độ và hiệu suất)
5. Documentation (Tài liệu)
6. Reinventing the Wheel (Phát minh lại bánh xe)
7. Reliability (Độ tin cậy)
8. Scalability (Khả năng mở rộng)
9. Reusability (Tái sử dụng)
10. Patterns (Mẫu)
11. Test Coverage and Test Quality (Phạm vi kiểm tra và chất lượng kiểm tra)
12. Fit for Purpose (Phù hợp cho mục đích)
https://www.enosecurity.com/training-tutorials-courses/secure-coding-in-asp-net-training/ (Tranining)
https://forums.asp.net/t/1926690.aspx?Secure+Coding+best+practices+guideline
https://download.microsoft.com/documents/uk/msdn/security/The Developer Highway Code.pdf
http://www.evoketechnologies.com/blog/code-review-checklist-perform-effective-code-reviews/
https://nyu-cds.github.io/effective-code-reviews/01-intro/
https://nyu-cds.github.io/effective-code-reviews/02-best-practices/
https://nyu-cds.github.io/effective-code-reviews/03-checklist/
https://www.owasp.org/images/2/2e/OWASP_Code_Review_Guide-V1_1.pdf
https://dzone.com/refcardz/restful-api-lifecycle-management
https://msdn.microsoft.com/en-us/library/bb308959.aspx
https://www.codeproject.com/Reference/593751/Code-Review-Checklist-and-Guidelines-for-Csharp-De
https://www.codeproject.com/Articles/524235/Codeplusreviewplusguidelines
The severity to find issues with code should go as below. Reviewer must focus on issues with High severity first and then to Medium severity and then Low severity issues.
https://weblogs.asp.net/tgraham/44763
In my previous blog post, we discussed about “10 Simple Code Review Tips for Effective Code Reviews”. Now, let’s take this topic further and explore the code review checklist, which would help to perform effective code reviews to deliver best quality software.
This code review checklist also helps the code reviewers and software developers (during self code review) to gain expertise in the code review process, as these points are easy to remember and follow during the code review process.
Let’s first begin with the basic code review checklist and later move on to the detailed code review checklist.
Let’s discuss about the basic code review checklist, which can be very handy if you are a beginner in code reviews and/or during initial code reviews.
While reviewing the code, ask yourself the following basic questions:
If you feel that the answer is not satisfactory to any of the above questions, then you can suggest/recommend code changes.
The following code review checklist gives an idea about the various aspects you need to consider while reviewing the code:
While going through the code, check the code formatting to improve readability and ensure that there are no blockers:
a) Use alignments (left margin), proper white space. Also ensure that code block starting point and ending point are easily identifiable.
b) Ensure that proper naming conventions (Pascal, CamelCase etc.) have been followed.
c) Code should fit in the standard 14 inch laptop screen. There shouldn’t be a need to scroll horizontally to view the code. In a 21 inch monitor, other windows (toolbox, properties etc.) can be opened while modifying code, so always write code keeping in view a 14 inch monitor.
d) Remove the commented code as this is always a blocker, while going through the code. Commented code can be obtained from Source Control (like SVN), if required.
a) The code should follow the defined architecture.
a) Maintainability (Supportability) – The application should require the least amount of effort to support in near future. It should be easy to identify and fix a defect.
b) Reusability
c) Reliability – Exception handling and cleanup (dispose) resources.
d) Extensibility – Easy to add enhancements with minimal changes to the existing code. One component should be easily replaceable by a better component.
e) Security – Authentication, authorization, input data validation against security threats such as SQL injections and Cross Site Scripting (XSS), encrypting the sensitive data (passwords, credit card information etc.)
f) Performance
g) Scalability – Consider if it supports a large user base/data? Can this be deployed into web farms?
h) Usability – Put yourself in the shoes of a end-user and ascertain, if the user interface/API is easy to understand and use. If you are not convinced with the user interface design, then start discussing your ideas with the business analyst.
In most cases the principles are interrelated, following one principle automatically satisfies other principles. For e.g: if the ‘Single Responsibility Principle’ is followed, then Reusability and Testability will automatically increase.
In a few cases, one requirement may contradict with other requirement. So need to trade-off based on the importance of the weight-age, e.g. Performance vs Security. Too many checks and logging at multiple layers (UI, Middle tier, Database) would decrease the performance of an application. But few applications, especially relating to finance and banking require multiple checks, audit logging etc. So it is ok to compromise a little on performance to provide enhanced security.
The above code review checklist is not exhaustive, but provides a direction to the code reviewer to conduct effective code reviews and deliver good quality code. Initially, it would take some time to review the code from various aspects. After a bit of practice, code reviewers can perform effective code reviews, without much effort and time. If you would like to become an expert code reviewer, this code review checklist serves as a great starting point. Happy Code Reviewing!
Hosting and deployment overview for ASP.NET Core apps
https://docs.microsoft.com/en-us/aspnet/core/publishing/
Frequently Asked Questions
https://docs.microsoft.com/en-us/windows/deployment/usmt/usmt-faq
User State Migration Tool (USMT)