.NET¶

dotnet nuget locals --clear all

dotnet --list-sdks

dotnet new globaljson --sdk-version 6.0.400 --output <projname>
dotnet new mvc --no-https --output <projname> --framework net6.0

dotnet new sln --name <solution-name> # ソリューションファイルの生成
dotnet new sln -o <projname>
dotnet sln PartyInvites add <projname>

dotnet --list-sdks
dotnet watch
dotnet run
dotnet list package
dotnet remove package <hoge>

dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef --version 6.0.0
dotnet ef --help
dotnet ef database drop --force --context StoreDbContext

dotnet tool uninstall -g Microsoft.Web.LibraryManager.Cli
dotnet tool install -g Microsoft.Web.LibraryManager.Cli --version 2.1.113
libman init -p cdnjs
libman install bootstrap@5.1.3 -d wwwroot/lib/bootstrap
libman restore

dotnet --list-sdks

dotnet new sln # 現在のディレクトリに同名のファイル生成
dotnet new sln --name <MySolution> # 現在のディレクトリにファイル生成
dotnet new sln --output <MySolutionDirectory> # 指定したディレクトリに生成

dotnet sln add <HogeProject>

dotnet new --list

dotnet new globaljson
dotnet --list-sdks

dotnet --version

dotnet add package <hoge> --version

dotnet remove package <hoge>

dotnet new globaljson --sdk-version <6.0.100> --output <MySolution/MyProject>
dotnet new web --no-https --output <MySolution/MyProject> --framework <net6.0>
dotnet new sln -o <MySolution>
dotnet sln <MySolution> add <MySolution/MyProject>

dotnet add reference

cat /etc/dotnet/install_location

/usr/local/share/dotnet/x64
->
/usr/local/share/dotnet

dotnet tool install --global Microsoft.dotnet-interactive
dotnet interactive jupyter install
jupyter kernelspec list

#load "Paket.fsx"
Paket.Package ["Newtonsoft.Json"; "Deedle"; "MathNet.Numerics"; "MathNet.Numerics.FSharp"; ]
#load "Paket.Generated.Refs.fsx"

open System
open Deedle
open MathNet.Numerics
open Newtonsoft.Json\
open MathNet.Numerics.LinearAlgebra

load "XPlot.Plotly.Paket.fsx"
load "XPlot.Plotly.fsx""
open FSharp.Core
open XPlot.Plotly

// 以下はF# 5以降の方法：いったんコメントアウト。
//#r "nuget:Deedle"
//#r "nuget:DiffSharp"
//#r "nuget:FSharpPlus"
//#r "nuget:MathNet.Numerics"
//#r "nuget:MathNet.Numerics.FSharp"
//#r "nuget:XPlot"

cd /tmp
curl -OL https://github.com/dotnet/cli-lab/releases/download/1.6.0/dotnet-core-uninstall.tar.gz
mkdir -p /tmp/dotnet-core-uninstall
tar -zxf dotnet-core-uninstall.tar.gz -C dotnet-core-uninstall
cd dotnet-core-uninstall
dotnet-core-uninstall list
./dotnet-core-uninstall -h

cd ~/tmp
curl -OL https://github.com/dotnet/cli-lab/releases/download/1.6.0/dotnet-core-uninstall.tar.gz
mkdir -p ~/tmp/dotnet-core-uninstall
tar -zxf dotnet-core-uninstall.tar.gz -C dotnet-core-uninstall
cd dotnet-core-uninstall
dotnet-core-uninstall list
./dotnet-core-uninstall -h

dotnet new xunit -o <project-name> -f net6.0
dotnet sln add <project-name>
dotnet add <project-name> reference <solution-name>

dotnet --list-sdk

dotnet tool install -g LiveReloadServer

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

dotnet dev-certs https --clean
dotnet dev-certs https --trust

dotnet run --environment Production

dotnet run --environment Production

{
  "Movies:ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=Movie-1;Trusted_Connection=True;MultipleActiveResultSets=true",
  "Movies:ServiceApiKey": "12345"
}

var moviesConfig =
    Configuration.GetSection("Movies").Get<MovieSettings>();
_moviesApiKey = moviesConfig.ServiceApiKey;

public class MovieSettings
{
    public string ConnectionString { get; set; }
    public string ServiceApiKey { get; set; }
}

dotnet tool restore
dotnet restore

{
  "sdk": {
    "version": "6.0.400"
  }
}

PORT=3000

DB_ROOT_HOST="%"
DB_ROOT_USER=postgres
DB_ROOT_PASS=root
POSTGRES_USER=user
DB_USER=user
DB_PASS=pass
DB_PORT=5432
DB_NAME=mydb
TZ=Asia/Tokyo

version: "3"
services:
  pgsql:
    image: postgres:14
    platform: linux/x86-64
    tty: true
    env_file: .env
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASS}
      POSTGRES_DB: ${DB_NAME}
      TZ: ${TZ}
    ports:
      - ${DB_PORT}:5432
    # volume:
    #   - ./db/init:/docker-entrypoint-initdb.d
    healthcheck:
      test: [ "CMD", "pg_isready", "-U", "${POSTGRES_USER}", "||", "exit", "1" ]
      interval: 2s
      timeout: 5s
      retries: 5

PORT=3000

DB_ROOT_HOST="%"
DB_ROOT_USER=postgres
DB_ROOT_PASS=root
POSTGRES_USER=user
DB_USER=user
DB_PASS=pass
DB_PORT=5432
DB_NAME=mydb
TZ=Asia/Tokyo

version: "3"
services:
  pgsql:
    image: postgres:14
    platform: linux/x86-64
    tty: true
    env_file: .env
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASS}
      POSTGRES_DB: ${DB_NAME}
      TZ: ${TZ}
    ports:
      - ${DB_PORT}:5432
    healthcheck:
      test: [ "CMD", "pg_isready", "-U", "${POSTGRES_USER}", "||", "exit", "1" ]
      interval: 2s
      timeout: 5s
      retries: 5
  backend:
    image: "mcr.microsoft.com/dotnet/sdk:6.0"
    volumes:
      - ./backend:/app
    command: dotnet watch --project ./app run --urls "http://0.0.0.0:80"
    ports:
      - "80:80"

dotnet new tool-manifest
dotnet tool install dotnet-ef --version 6.0.14

dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef --version 6.0.14

dotnet add package Microsoft.EntityFrameworkCore --version 6.0.14
dotnet add package Microsoft.EntityFrameworkCore.Sqlite --version 6.0.13

dotnet add package Microsoft.EntityFrameworkCore.Sqlite --version 6.0.13
dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL --version 6.0.8
dotnet add package Microsoft.EntityFrameworkCore.InMemory
dotnet add package Microsoft.EntityFrameworkCore.SqlServer -v 6.0.13 # scaffoldで必要

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design -v 6.0.11

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlite(builder.Configuration.GetConnectionString("DefaultConnection") ??
                      throw new InvalidOperationException("Connection string 'DefaultConnection' not found.")));

builder.Services.AddDbContext<MyDbContext>(opt =>
    opt.UseInMemoryDatabase("mydb"));

builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("MyDbContext") ??
                      throw new InvalidOperationException("Connection string 'MyDbContext' not found.")));

  "ConnectionStrings": {
    "DefaultConnection": "DataSource=Migrations/app.db;Cache=Shared"
  },

  "ConnectionStrings": {
    "DefaultConnection": "DataSource=:memory:"
  },

  "ConnectionStrings": {
      "DefaultConnection": "User ID=user;Password=pass;Host=localhost;Port=5432;Database=mydb;"
  },

dotnet new tool-manifest
dotnet tool install Microsoft.Web.LibraryManager.Cli

dotnet libman init -p cdnjs
dotnet libman install bootstrap --provider cdnjs --destination wwwroot/lib/bootstrap
dotnet libman install jquery --provider cdnjs --destination wwwroot/lib/jquery
dotnet libman install jquery-validate --provider cdnjs --destination wwwroot/lib/jquery-validation
dotnet libman install jquery-validation-unobtrusive  --provider cdnjs --destination wwwroot/lib/jquery-validation-unobtrusive
dotnet libman install font-awesome --provider cdnjs --destination wwwroot/lib/font-awesome
dotnet libman install @fluentui/web-components --provider cdnjs --destination wwwroot/lib/fluentui/web-components

dotnet tool install dotnet-aspnet-codegenerator --version 6.0.11
dotnet dotnet-aspnet-codegenerator controller -name TodoItemsController -async -api -m TodoItem -dc TodoContext -outDir Controllers

// API利用：`Swashbuckle.AspNetCore`が必要
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(options =>
{
    options.SwaggerDoc("v1", new OpenApiInfo
    {
        Version = "v1",
        Title = "ToDo API",
        Description = "An ASP.NET Core Web API for managing ToDo items",
        TermsOfService = new Uri("https://phasetr.com/archive"),
        Contact = new OpenApiContact
        {
            Name = "Example Contact",
            Url = new Uri("https://phasetr.com/contact")
        },
        License = new OpenApiLicense
        {
            Name = "Example License",
            Url = new Uri("https://phasetr.com/archive")
        }
    });
});

// 中略: `var app = builder.Build();`のあと

// API利用：開発時は`Swagger`を立ち上げる
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

// API利用
app.MapControllers();

using Microsoft.AspNetCore.Mvc;
using HogeProject.Models;

namespace HogeProject.Controllers.Api.V1;

// 次のディレクティブの追加: これでAPI呼び出しでき, `Swagger`にも反映される
[ApiController]
[Route("api/v1/[controller]")]
public class HogeController : ControllerBase
{
    // 本体
}

dotnet new xunit -o <Proj.Tests>
dotnet sln add <Proj.Tests/Proj.Tests.csproj
dotnet add <Proj.Tests/Proj.Tests.csproj> reference <Proj/Proj.csproj>
cd Proj.Tests
dotnet add package Moq

dotnet new xunit -o CityBreaks.Tests
dotnet sln add CityBreaks.Tests/CityBreaks.Tests.csproj
dotnet add CityBreaks.Tests/CityBreaks.Tests.csproj reference CityBreaks/CityBreaks.csproj
cd CityBreaks.Tests
dotnet add package Moq

if (builder.Environment.IsDevelopment())
{
    builder.Services.AddTransient<IEmailSender, EmailService>();
}
else
{
    builder.Services.AddTransient<IEmailSender, ProductionEmailService>();
}

public async Task<IActionResult> OnPostChangeMainShopAsync(int shopId)
{
    var isProperShopId = await IsProperShopId(shopId);
    if (!isProperShopId) return NotFound();
    var userName = User.Identity!.Name!;
    var user = await _applicationUserService.GetByUserNameAsync(userName);
    user.ShopId = shopId;
    await _applicationUserService.UpdateAsync(user);
    var identity = (ClaimsIdentity) User.Identity;
    var claim = identity.FindFirst("ShopId");
    if (claim == null) return RedirectToPage("./Details", new {shopId});
    identity.RemoveClaim(claim);
    identity.AddClaim(new Claim("ShopId", $"{shopId}"));
    await _signInManager.RefreshSignInAsync(user);
    return RedirectToPage("./Details", new {shopId});
}

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore
dotnet add package Microsoft.AspNetCore.Identity.UI
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

dotnet tool install -g dotnet-aspnet-codegenerator

dotnet aspnet-codegenerator identity -h

    builder.Services.Configure<IdentityOptions>(options =>
    {
        options.Password.RequireDigit = false;
        options.Password.RequireLowercase = false;
        options.Password.RequireNonAlphanumeric = false;
        options.Password.RequireUppercase = false;
        options.Password.RequiredLength = 8;
        options.Password.RequiredUniqueChars = 1;
    });

var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);

public class ApplicationUser : IdentityUser<int>
{
}

public class ApplicationRole : IdentityRole<int>
{
}

public enum UserRoles
{
    Admin,
    Staff,
    Customer
}

public class ApplicationDbContext : IdentityDbContext<ApplicationUser, ApplicationRole, int>
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }

    public DbSet<ApplicationUser> ApplicationUsers => Set<ApplicationUser>();
    public DbSet<ApplicationRole> ApplicationRoles => Set<ApplicationRole>();

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);
        builder
            .ApplyConfiguration(new ApplicationUserConfiguration())
            .ApplyConfiguration(new ApplicationRoleConfiguration())
    }
}

builder.Services.AddIdentity<ApplicationUser, ApplicationRole>(options =>
        options.SignIn.RequireConfirmedAccount = true)
    .AddRoles<ApplicationRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders();

dotnet libman restore

app.MapGet("/", (ILogger<Program> logger) =>
{
    logger.LogInformation("👺 access to /");
    return "This is a GET.";
});

using QRCoder;

public class IndexModel : PageModel
{
    private readonly ILogger<IndexModel> _logger;

    public IndexModel(ILogger<IndexModel> logger)
    {
        _logger = logger;
    }

    public string ImageSrc { get; set; } = string.Empty;

    public IActionResult OnGet()
    {
        _logger.LogInformation("LOG TEST");
        var text = "https://phasetr.com/archive";
        var qrGenerator = new QRCodeGenerator();
        var qrCodeData = qrGenerator.CreateQrCode(text, QRCodeGenerator.ECCLevel.Q);
        var qrCode = new PngByteQRCode(qrCodeData);
        var bytes = qrCode.GetGraphic(10);
        var base64Str = Convert.ToBase64String(bytes);
        ImageSrc = $"data:image/png;base64,{base64Str}";
        return Page();
    }
}

<div class="text-center">
    <h2 class="display-4">Welcome</h2>
    <img src="@Model.ImageSrc" alt=""/>
</div>

builder.Services.AddRazorPages();
app.MapRazorPages();

@{
    Layout = "_Layout";
    const string output = "<p>This is a paragraph.</p>";
}

<div>
    <p>@output</p>
    <p>@Html.Raw("<p>This is a paragraph.</p>")</p>
</div>

builder.Services.Configure<WebEncoderOptions>(options =>
{
   options.TextEncoderSettings = new TextEncoderSettings(UnicodeRanges.BasicLatin, UnicodeRanges.Latin1Supplement);
});

<div asp-validation-summary="ModelOnly" class="text-danger"></div>

@removeTagHelper "Microsoft.AspNetCore.Mvc.TagHelpers.AnchorTagHelper, Microsoft.AspNetCore.Mvc.TagHelpers"
<!a href="https://www.learnrazorpages.com">Learn Razor Pages</!a>

@tagHelperPrefix x:
<x:a asp-page="/Index">Home</x:a>

ViewData["Title"] = "Welcome!";

<title>@ViewData["Title"] - WebApplication1</title>

@{
    Layout = "_Layout";
}

<div>
    <p>@Model.Message</p>
</div>


public class Index : PageModel
{
    public string Message { get; set; } = string.Empty;
    public void OnGet(int id)
    {
        Message = $"OnGet executed with id = {id}";
    }
}

@page
@model WelcomeModel
@{
}

<div class="col">
    <form method="post" asp-page-handler="Search">
        <p>Search</p>
        <input name="searchTerm" />
        <button>Search</button>
    </form>

    <form method="post" asp-page-handler="Register">
        <p>Register</p>
        <input name="email" />
        <button>Register</button>
    </form>
    <p>@Model.Message</p>
</div>

public class WelcomeModel : PageModel
{
    public string Message { get; set; }
    public void OnPostSearch(string searchTerm)
    {
        Message = $"You searched for {searchTerm}";
    }

    public void OnPostRegister(string email)
    {
        Message = $"You registered {email} for newsletters";
    }
}

dotnet new blazorwasm -ho --auth Individual --pwa -o <SolutionName>

@model CountryViewModel

<form asp-controller="Home" asp-action="Index" method="post">
    <select asp-for="Country" asp-items="Model.Countries"></select>
    <br /><button type="submit">Register</button>
</form>

using Microsoft.AspNetCore.Mvc.Filters;

namespace CityBreaks.Filters;

public class AsyncPageFilter : IAsyncPageFilter
{
    private readonly Serilog.ILogger _logger;

    public AsyncPageFilter(Serilog.ILogger logger)
    {
        _logger = logger;
    }

    public Task OnPageHandlerSelectionAsync(PageHandlerSelectedContext context)
    {
        var httpContext = context.HttpContext;
        _logger.Information(
            "HttpType: {Method}|Path :{Path}\tUserAgent: {UserAgent}\tPage: {PageName}\tHandler: {Handler}",
            httpContext.Request.Method, httpContext.Request.Path, httpContext.Request.Headers[";User-Agent"].ToString(),
            context.HandlerInstance.GetType().Name, context.HandlerMethod?.MethodInfo.Name);
        return Task.CompletedTask;
    }

    public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
        PageHandlerExecutionDelegate next)
    {
        await next.Invoke();
    }
}

using Microsoft.AspNetCore.Mvc.Filters;

namespace WebAppSample;

public class MyAsyncPageFilter : IAsyncPageFilter
{
    private readonly ILogger _logger;
    public MyAsyncPageFilter(ILogger logger)
    {
        _logger = logger;
    }

    public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
    {
        await next.Invoke();
    }

    public Task OnPageHandlerSelectionAsync(PageHandlerSelectedContext context)
    {
        var httpContext = context.HttpContext;
        var message = $"HttpType: {httpContext.Request?.Method}|Path :{httpContext.Request?.Path}\tUserAgent: {httpContext.Request?.Headers["User-Agent"].ToString()}\tPage: {context.HandlerInstance?.GetType().Name}\tHandler: {context.HandlerMethod?.MethodInfo?.Name}";
        _logger.LogTrace(message);
        return Task.CompletedTask;
    }

}

    builder.Services.AddRazorPages(options =>
    {
        // 省略
    }).AddMvcOptions(options =>
    {
        options.Filters.Add(new AsyncPageFilter(Log.Logger));
    });

using WebAppSample;

var builder = WebApplication.CreateBuilder(args);

var logger = LoggerFactory.Create(config =>
{
    config.AddConsole();
    config.SetMinimumLevel(LogLevel.Trace);
}).CreateLogger("WebAppSample");

builder.Services.AddRazorPages()
    .AddMvcOptions(options =>
    {
        options.Filters.Add(new MyAsyncPageFilter(logger));
    });


var app = builder.Build();

... 以下省略 ...

{
  "DetailedErrors": true,
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    }
  }
}

<partial name="_ProductViewDataPartial" for="Product" view-data="sampleViewData">

    [BindProperty] public string CityName { get; set; } = string.Empty;
    [BindProperty(SupportsGet=true)] public int Id  { get; set; } = 0;
    [BindProperty(Name="e-mail")] public string Email { get; set; } = "";


<div class="col-4">
    <h3>モデルバインディング</h3>
    <form method="post">
        <div class="mb-3">
            <label for="name">Enter city name</label>
            <input class="form-control" type="text" name="cityName"/>
        </div>
        <button class="btn btn-primary">Submit</button>
    </form>
    @if (Request.HasFormContentType && !string.IsNullOrWhiteSpace(Model.CityName))
    {
        <p>You submitted @Model.CityName</p>
    }
</div>

public class MyUserClaimsPrincipalFactory : UserClaimsPrincipalFactory<ApplicationUser>
{
    public MyUserClaimsPrincipalFactory(
        UserManager<ApplicationUser> userManager,
        IOptions<IdentityOptions> optionsAccessor)
        : base(userManager, optionsAccessor)
    {
    }

    protected override async Task<ClaimsIdentity> GenerateClaimsAsync(ApplicationUser user)
    {
        var identity = await base.GenerateClaimsAsync(user);
        // 追加したい要素を文字列で設定する
        identity.AddClaim(new Claim("ContactName", user.ContactName ?? "[Click to edit profile]"));
        return identity;
    }
}

public class MyUserClaimsPrincipalFactory : UserClaimsPrincipalFactory<ApplicationUser, ApplicationRole>
{
    private readonly IApplicationUserService _applicationUserService;

    public MyUserClaimsPrincipalFactory(
        UserManager<ApplicationUser> userManager,
        RoleManager<ApplicationRole> roleManager,
        IApplicationUserService applicationUserService,
        IOptions<IdentityOptions> options) : base(userManager, roleManager, options)
    {
        _applicationUserService = applicationUserService;
    }

    protected override async Task<ClaimsIdentity> GenerateClaimsAsync(ApplicationUser user)
    {
        var identity = await base.GenerateClaimsAsync(user);
        // 追加したい要素を文字列で設定する
        identity.AddClaim(new Claim("ContactName", user.ContactName ?? "[Click to edit profile]"));
        return identity;
    }
}

public void ConfigureServices(IServiceCollection services)
{
    .     .     .     .      .
    services.AddDefaultIdentity<ApplicationUser>()
        .AddDefaultUI(UIFramework.Bootstrap4)
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddClaimsPrincipalFactory<MyUserClaimsPrincipalFactory>();  // 追加
}

@foreach (var city in cities)
{
   if (city.Country == "UK")
   {
       @:Country:  @city.Country, Name: @city.Name
   }
}

@foreach (var city in cities)
{
   if (city.Country == "UK")
   {
       <text>Country:  @city.Country<br />
       Name: @city.Name</text>
   }
}

        var mock = new Mock<IStoreRepository>();
        mock.Setup(m => m.Products).Returns(new[]
        {
            new Product {ProductID = 1, Name = "P1"},
            new Product {ProductID = 2, Name = "P2"}
        }.AsQueryable());

        // これがロガーのモックオブジェクト
        var mockLogger = new Mock<ILogger<ListModel>>();

        var listModel = new ListModel(mock.Object, mockLogger.Object);
        listModel.OnGet(null,1);

using Microsoft.Extensions.Configuration;
private readonly IConfiguration _configuration;

var bucketName = _configuration["ENV_VAR_NAME"];

<input asp-for="CityName" />

// => <input type="text" id="CityName" name="CityName" value="" />

[BindProperty]
public string Name { get; set; }
[BindProperty]
[Display(Name = "Maximum Number Of Guests")]
public int MaxNumberOfGuests { get; set; }
[BindProperty]
[Display(Name ="Day Rate")]
public decimal DayRate { get; set; }
[BindProperty]
[Display(Name = "Smoking Permitted")]
public bool SmokingPermitted { get; set; }
[BindProperty]
[DataType(DataType.Date)]
[Display(Name ="Available From")]
public DateTime AvailableFrom { get; set; }

using Microsoft.AspNetCore.Mvc .Rendering

public class CreateModel : PageModel
{
    [BindProperty]
    [Display(Name = "City")]
    public int SelectedCity { get; set; }
    public SelectList Cities { get; set; }
    public string Message { get; set; }
    public void OnGet()
    {
        Cities = GetCityOptions();
    }

    public void OnPost()
    {
        Cities = GetCityOptions();
        if (ModelState.IsValid)
        {
            var city = GetCityOptions().First(o => o.Value == SelectedCity.ToString());
            Message = $"You selected {city.Text} with value of {SelectedCity}";
        }
    }

    private SelectList GetCityOptions()
    {
        var cities =  new List<City>
        {
            new City{ Id = 1, Name = "London"},
            new City{ Id = 2, Name = "Paris" },
            new City{ Id = 3, Name = "New York" },
            new City{ Id = 4, Name = "Rome" },
            new City{ Id = 5, Name = "Dublin" }
        };
        return new SelectList(cities, nameof(City.Id), nameof(City.Name));
    }

    private SelectList GetCityOptions2()
    {
       var cities =  new List<SelectListItem>
       {
           new SelectListItem{ Value = "1", Text = "London"},
           new SelectListItem{ Value = "2", Text = "Paris" },
           new SelectListItem{ Value = "3", Text = "New York", Selected = true },
           new SelectListItem{ Value = "4", Text = "Rome" },
           new SelectListItem{ Value = "5", Text = "Dublin" }
       };
       return new SelectList(cities);
    }
}


@if (Request.HasFormContentType)
{
    <p>You selected @Model.SelectedCity</p>
    <p>@Model.Message</p>
}
<form method="post">
    <div class="mb-3">
        <label class="form-label" asp-for="SelectedCity"></label>
        <select class="form-control" asp-for="SelectedCity" asp-items="Model.Cities"></select>
    </div>
    <button class="btn btn-primary">Submit</button>
</form>

public string CountryName { get; set; }
private SelectList GetCityOptions()
{
   var cities = new List<City>
   {
       new City{ Id = 1, Name = "Barcelona" , CountryName = "Spain" },
       new City{ Id = 2, Name = "Cadiz" , CountryName = "Spain" },
       new City{ Id = 3, Name = "London", CountryName = "United Kingdom" },
       new City{ Id = 4, Name = "Madrid" , CountryName = "Spain" },
       new City{ Id = 5, Name = "Rome", CountryName = "Italy" },
       new City{ Id = 6, Name = "Venice", CountryName = "Italy" },
       new City{ Id = 7, Name = "York" , CountryName = "United Kingdom" },
   };
   return new SelectList(cities, nameof(City.Id), nameof(City.Name), null, nameof(City.CountryName));
}

[TestMethod]
public void TestValuesController()
{
    ValuesController controller = new ValuesController();
    controller.ControllerContext = new ControllerContext();
    controller.ControllerContext.HttpContext = new DefaultHttpContext();
    controller.ControllerContext.HttpContext.Request.Headers["device-id"] = "20317";
    var result = controller.Get();
    //the controller correctly receives the http header key value pair device-id:20317
}

using CityBreaks.Models;
using CityBreaks.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;

namespace CityBreaks.Pages;

[Authorize] // 注意
public class IndexModel : PageModel
{
    private readonly ICityService _cityService;

    public IndexModel(ICityService cityService) =>
        _cityService = cityService;

    public List<City> Cities { get; set; }
    public async Task OnGetAsync() =>
        Cities = await _cityService.GetAllAsync();
}

builder.Services.AddRazorPages(options => {
   options.Conventions.AuthorizeFolder("/CityManager");
   options.Conventions.AuthorizeFolder("/CountryManager");
   options.Conventions.AuthorizeFolder("/PropertyManager");
});

builder.Services.AddDefaultIdentity<CityBreaksUser>(options => {
    options.Password.RequireDigit = false;
    options.Password.RequireLowercase = false;
    options.Password.RequireNonAlphanumeric = false;
    options.Password.RequireUppercase = false;
})
    .AddRoles<IdentityRole>()
    .AddEntityFrameworkStores<CityBreaksContext>();

builder.Services.AddAuthorization(options =>
{
   options.AddPolicy("AdminPolicy", policyBuilder => policyBuilder.RequireRole("Admin"));
});

builder.Services.AddRazorPages(options => {
   options.Conventions.AuthorizeFolder("/RolesManager", "AdminPolicy");
});

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Development";
var builder = ConsoleApp.CreateBuilder(args);
builder.ConfigureServices((ctx, services) =>
{
    IConfiguration config = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("appsettings.json", false, true)
        .AddJsonFile($"appsettings.{environment}.json", true)
        .AddEnvironmentVariables()
        .Build();
    // AWS上のデータベースにつなげるための設定でなくてもよい
    var awsSecret = Environment.GetEnvironmentVariable("APCLUSTER_SECRET");
    var configurationConnectionString = config.GetConnectionString("DefaultConnection");
    // これは開発環境とステージング・本番用に接続文字列を適切に設定するために別途用意したメソッド
    var connectionString = DbConnectionStringService.GetConnectionStringByLoadBalancer(awsSecret, configurationConnectionString).Result;

    services.AddDbContext<ApplicationDbContext>(options => options.UseNpgsql(connectionString));

    // DIもできる: 適切な`using`を設定しよう
    services.AddScoped<IProductService, ProductService>();
});

var app = builder.Build();
app.AddAllCommandType();
app.Run();

{
  "profiles": {
    "MySolution": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://localhost:7024;http://localhost:5110",
      "environmentVariables": {
        "APBUCKET_NAME": "apbucket-name",
        "APBUCKET_CLOUDFRONT": "apbucket-cloudfront",
        "ASPNETCORE_ENVIRONMENT": "Development",
        "APCLUSTER_SECRET": "{\"password\":\"pass\",\"dbname\":\"mydb\",\"port\":5432,\"host\":\"localhost\",\"username\":\"user\"}"
      }
    }
  }
}

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");

dotnet new blazor -o BlazorApp -int Auto

dotnet new blazorwasm -o Blazor --pwa
dotnet new blazorwasm -o BlazorHosted --pwa --hosted

- @page "/counter"
+ @attribute [Route(Constants.CounterRoute)]

  <PropertyGroup>
    <!-- 略 -->

    <!-- Reduce output size -->
    <InvariantGlobalization>true</InvariantGlobalization>
    <WasmEmitSymbolMap>false</WasmEmitSymbolMap>
  </PropertyGroup>

dotnet add package Microsoft.EntityFrameworkCore --version 6.0.15
dotnet add package Microsoft.EntityFrameworkCore.InMemory

dotnet new tool-manifest
dotnet tool install dotnet-ef --version 6.0.15

dotnet tool uninstall --global dotnet-ef
dotnet tool install --global dotnet-ef --version 6.0.15

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace SportsStore.Models;

public class Product
{
    public long? ProductId { get; set; }

    [Required(ErrorMessage = "Please enter a product name")]
    public string Name { get; set; } = string.Empty;

    [Required(ErrorMessage = "Please enter a description")]
    public string Description { get; set; } = string.Empty;

    [Required]
    [Range(0.01, double.MaxValue,
        ErrorMessage = "Please enter a positive price")]
    [Column(TypeName = "decimal(8, 2)")]
    public decimal Price { get; set; }

    [Required(ErrorMessage = "Please specify a category")]
    public string Category { get; set; } = string.Empty;
}

namespace ConsoleApp1.Models
{
    public class ItemContext : DbContext
    {
        public DbSet<Item> Items { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Item>().HasQueryFilter(s => !s.IsDeleted);  // s.IsDeleted == false って書いてるのと一緒ですよん
        }
    }
}

SELECT MAX("Id") FROM "Products";
SELECT last_value FROM "Products_Id_seq";

SELECT SETVAL ('"Products_Id_seq"', (SELECT MAX("Id") FROM "Products"));
SELECT last_value FROM "Products_Id_seq";

public async Task<City> GetByNameAsync(string name)
{
    name = name.Replace("-"," ");
    return await _context.Cities
        .Include(c => c.Country)
        .Include(c => c.Properties.Where(p => p.AvailableFrom < DateTime.Now))
        .SingleOrDefaultAsync(c => EF.Functions.Collate(c.Name, "NOCASE") == name);
}

public async Task<Shop?> GetShopWithProductsByIdAsync(int id)
{
    return await _context.Shops
        .Join(_context.Products.Where(p => !p.IsDeleted),
            s => s.Id,
            p => p.ShopId,
            (s, p) => new {s, p})
        .GroupBy(x => x.s)
        .Select(x => new Shop
        {
            Id = x.Key.Id,
            Name = x.Key.Name,
            Products = x.Select(y => y.p).ToList()
        })
        .FirstOrDefaultAsync(x => x.Id == id);
}

        var shop = await _shopService.GetByIdAsync(Id); // この取得部分が大事
        if (shop == null) return NotFound();
        shop.Name = Name;
        shop.Place = Place;
        shop.IsOpen = IsOpen;
        shop.MaitreDTimeZoneId = TimeZoneId;
        shop.DiscountAmount = DiscountAmount;
        shop.DiscountRate = DiscountRate;
        shop.VatRate = VatRate;
        shop.PaymentMethods = PaymentMethods.Select(p => new PaymentMethod
        {
            ShopId = Id,
            Name = p
        }).ToList();

        try
        {
            await _shopService.UpdateAsync(shop);
        }
        catch (DbUpdateConcurrencyException e)
        {
            _logger.LogError("ERROR: {E}", e.Message);
            RedirectToPage("/Error");
        }

public void Configure(EntityTypeBuilder<Student> builder)
{
    builder.ToTable("Student");
    builder.Property(s => s.Age)
        .IsRequired(false);
    builder.Property(s => s.IsRegularStudent)
        .HasDefaultValue(true);

    builder.HasData
    (
        new Student
        {
            Id = Guid.NewGuid(),
            Name = "John Doe",
            Age = 30
        },
        new Student
        {
            Id = Guid.NewGuid(),
            Name = "Jane Doe",
            Age = 25
        },
        new Student
        {
            Id = Guid.NewGuid(),
            Name = "Mike Miles",
            Age = 28
        }
    );
}

using SportsStore.Models;
SeedData.EnsurePopulated(app);

    public class Book
    {
        public int BookId { get; set; }
        public string Title { get; set; }
        public Author Author { get; set; }
        public ICollection<BookCategory> BookCategories { get; set; }
    }
    public class Category
    {
        public int CategoryId { get; set; }
        public string CategoryName { get; set; }
        public ICollection<BookCategory> BookCategories { get; set; }
    }
    public class BookCategory
    {
        public int BookId { get; set; }
        public Book Book { get; set; }
        public int CategoryId { get; set; }
        public Category Category { get; set; }
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<BookCategory>()
            .HasKey(bc => new { bc.BookId, bc.CategoryId });
        modelBuilder.Entity<BookCategory>()
            .HasOne(bc => bc.Book)
            .WithMany(b => b.BookCategories)
            .HasForeignKey(bc => bc.BookId);
        modelBuilder.Entity<BookCategory>()
            .HasOne(bc => bc.Category)
            .WithMany(c => c.BookCategories)
            .HasForeignKey(bc => bc.CategoryId);
    }

public class Shop
{
    public int Id { get; set; }
    public string Name { get; set; } = default!;
}

public class OrderNumber
{
    [Key] public int ShopId { get; set; }
    [ForeignKey("ShopId")] public Shop Shop { get; set; } = default!;
    public int Number { get; set; }
}

dotnet ef database drop --force --context <データベースコンテキスト>

using Microsoft.AspNetCore.Identity;

namespace <ProjectName>.Models;

public class ApplicationUser : IdentityUser
{
    public string FirstName { get; set; } = string.Empty;

    public string LastName { get; set; } = string.Empty;

    public DateTime BirthDate { get; set; }

    public virtual IEnumerable<Article>? Articles { get; set; }
}


namespace <ProjectName>.Models;

public class Article
{
    public int ArticleId { get; set; }

    public string Title { get; set; } = string.Empty;

    public string Description { get; set; } = string.Empty;

    public string? UserId { get; set; }

    public virtual ApplicationUser? User { get; set; }
}