We're going to use Dapper.NET on our project; that much is not in doubt. However, we're not going to start development with it, and it will not be the only ORM in use. The plan is to develop this project using Entity Framework, and later optimize to use Dapper.NET in certain scenarios where the system needs a performance boost.
.NET Core + Angular Dashboard
Topics Covered:
- Building a dashboard application in Angular
- Building a Web API in .NET Core 2.0
- Using Chart.js to build stunning charts of different types
- Making HTTP requests using Angular to query a Web API
- Using Postman to send requests
- Working with Observables
- Using Input and Output decorators in Angular
- Using PostgreSQL and pgAdmin
- Automatically seeding a database with large amounts of sample data
- Styling an application using custom CSS and Bootstrap 4
- Using Map, Filter, and Reduce in Javascript
- Creating Routes in Angular
- Get, Put, Post, Patch Web API Controller Action request types
- Configuring your API for CORS
Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages, enabling Java and other programmers to be more productive. Code sizes are typically reduced by a factor of two to three when compared to an equivalent Java application.
@NgModule({
imports: [
CommonModule,
InjectionBeyondClassesRoutingModule
],
declarations: [TestProvidersComponent],
providers: [
{ provide: "API_BASE_HREF", useValue: "http://localhost:5000" },
{ provide: "APP_BASE_HREF", useValue: document.location.pathname },
{ provide: "IS_PROD", useValue: true },
{ provide: "APIKey", useValue: "XYZ1234ABC" },
{ provide: "Random", useValue: Math.random() },
{
provide: "emailApiConfig", useValue: Object.freeze({
apiKey: "email-key",
context: "registration"
})
},
{ provide: "languages", useValue: "en", multi: true },
{ provide: "languages", useValue: "fa", multi: true }
]
})
export class InjectionBeyondClassesModule { } import { Component, OnInit, Inject } from "@angular/core";
import { inject } from "@angular/core/testing";
@Component({
selector: "app-test-providers",
templateUrl: "./test-providers.component.html",
styleUrls: ["./test-providers.component.css"]
})
export class TestProvidersComponent implements OnInit {
constructor(
@Inject("API_BASE_HREF") public apiBaseHref: string,
@Inject("APP_BASE_HREF") public appBaseHref: string,
@Inject("IS_PROD") public isProd: boolean,
@Inject("APIKey") public apiKey: string,
@Inject("Random") public random: string,
@Inject("emailApiConfig") public emailApiConfig: any,
@Inject("languages") public languages: string[]
) { }
ngOnInit() {
}
} <h1>
Injection Beyond Classes
</h1>
<div class="alert alert-info">
<ul>
<li>API_BASE_HREF: {{apiBaseHref}}</li>
<li>APP_BASE_HREF: {{appBaseHref}}</li>
<li>IS_PROD: {{isProd}}</li>
<li>APIKey: {{apiKey}}</li>
<li>Random-1: {{random}}</li>
<li>Random-2: {{random}}</li>
<li>emailApiConfig {{emailApiConfig | json}}</li>
<li>languages: {{languages | json}}</li>
</ul>
</div> 
import { InjectionToken } from "@angular/core";
export let APP_CONFIG = new InjectionToken<string>("this.module.config");
export interface IThisModuleConfig {
apiEndpoint: string;
}
export const ThisModuleConfig: IThisModuleConfig = {
apiEndpoint: "http://localhost:45043/api/"
}; import { InjectionToken } from '@angular/core';
export const EmailService1 = new InjectionToken<string>("EmailService");
export const EmailService2 = new InjectionToken<string>("EmailService");
console.log(EmailService1 === EmailService2); // false import { ThisModuleConfig, APP_CONFIG } from "./thismodule.config";
@NgModule({
providers: [
{ provide: APP_CONFIG, useValue: ThisModuleConfig }
]
})
export class InjectionBeyondClassesModule { } import { IThisModuleConfig, APP_CONFIG } from "./../thismodule.config";
@Component()
export class TestProvidersComponent implements OnInit {
constructor(
@Inject(APP_CONFIG) public config: IThisModuleConfig
) { }
ngOnInit() {
}
} @NgModule({
providers: [
// ------ useFactory
{ provide: "BASE_URL", useFactory: getBaseUrl },
{ provide: "RandomFactory", useFactory: randomFactory }
]
})
export class InjectionBeyondClassesModule { }
export function getBaseUrl() {
return document.getElementsByTagName("base")[0].href;
}
export function randomFactory() {
return Math.random();
} export class TestProvidersComponent implements OnInit {
constructor(
@Inject("BASE_URL") public baseUrl: string,
@Inject("RandomFactory") public randomFactory: string
) { } import { HttpClient } from "@angular/common/http";
import { Injectable } from "@angular/core";
@Injectable()
export class CarService {
constructor(private http: HttpClient) { }
} import { CarService } from "./car.service";
import { HttpClient } from "@angular/common/http";
@NgModule({
providers: [
// ------ useFactory
{ provide: "Car_Service", useFactory: carServiceFactory, deps: [HttpClient] }
]
})
export class InjectionBeyondClassesModule { }
export function carServiceFactory(http: HttpClient) {
return new CarService(http);
} import { CarService } from "./car.service";
@NgModule({
providers: [
// ------ useClass
{ provide: "Car_Service_Name1", useClass: CarService },
]
})
export class InjectionBeyondClassesModule { } import { CarService } from "./car.service";
@NgModule({
providers: [
CarService
]
})
export class InjectionBeyondClassesModule { } import { CarService } from "./car.service";
@NgModule({
providers: [
// ------ useClass
{ provide: "Car_Service_Name1", useClass: CarService },
// ------ useExisting
{ provide: "Car_Service_Token2", useExisting: "Car_Service_Name1" },
]
})
export class InjectionBeyondClassesModule { } 
A DbContext instance represents a combination of the Unit Of Work and Repository patterns such that
it can be used to query from a database and group together changes that will then be written back to
the store as a unit. DbContext is conceptually similar to ObjectContext.
Use ViewModels to manage data & organize code in ASP.NET MVC applications
The concept of the ViewModel isn't just for ASP.NET MVC, as you'll see references to ViewModels throughout the web in articles and blog posts about the MVC, MVP, and MVVM patterns. Those posts and articles can center around any number of technologies such as ASP.NET, Silverlight, WPF, or MVC... This post will investigate ViewModels as they apply to the world of ASP.NET MVC.
dotnet-format is a code formatter for dotnet that applies style preferences to a project or solution. Preferences will be read from an .editorconfig file, if present, otherwise a default set of preferences will be used.
