DEV Community: Sanjeevi Subramani

Low Level Design GitHub Materials

Sanjeevi Subramani — Fri, 17 Jun 2022 09:53:47 +0000

𝟏) 𝐓𝐇𝐄 𝐋𝐋𝐃

Low level Design / Machine Coding Question Collections

What is Machine Coding Round ?

Machine Coding Round has become very popular interview round in most Product and startup companies like Flipkart, Cleartrip, navi and Udaan,the way the round is structured is the candidate will be provided with a Problem statement and the minimum set of features which needs to implemented within the 90 min window period, we as a candidate need to identity the data models, the service interfaces which will be consumed by the clients and other set of functions and classes, we should be able to present the same to the panel with are design choices / design patterns being made / used and the complete working code.

What is the purpose behind this LLD repo ?

During my recent Preparation, found out that there was no single resources where we get a collections of all the questions and the corresponding Answers, so currently updating the repo with all the materials I found out from the web and the Questions which has been asked during my interview. feel free to contribute any questions you have got during your recent interview.There other useful YT channel and Git repo which are attached in the resources section.

What is target Audience, do all companies ask ?

If you are currently targeting/looking out for any SDE - I,II opportunities. It totally depends on the company you interviewing with, you can check with the HR if they evaluate via machine coding round, but certain companies do ask a object oriented design round where they focus only on one particular feature and DB design as well, so its good get practiced with few problems beforehand.

Below are the list of LLD problem which are asked during my machine coding rounds from tech companies and the resources I collected.

Note : page is under construction, you can click on the individual packages to view all the questions and solutions.

| Low Level Design Question

| Question Link to PDF / Drive

| Company Asked

| Credits to author

Frequently asked Problems

Contribute

Contributions welcome!

If you found this resource helpful, give it a 🌟 otherwise contribute to it and give it a .

https://github.com/kumaransg/LLD

𝟐) 𝐋𝐎𝐖-𝐋𝐄𝐕𝐄𝐋 𝐃𝐄𝐒𝐈𝐆𝐍 𝐏𝐑𝐈𝐌𝐄𝐑

low-level-design-primer

Motivation

Learn low level design of system at scale. prepare for the low level design (LLD) / Machine Coding round interviews.

Learn to design low level system

Learning low level design of scalable systems will help you become better engineer.

This repo is an organized collection of resources to help you learn low level design of systesm's.

Resources

Low level Design Questions
Low level Design Solutions
Low Level Design Resources #TODO
Add new questions
Improve new questions
add new solutions
Fix errors
Improve sections
Add new sections

Under development

Interested in adding a section or helping complete one in-progress? Contribute!

how to guide and study material along with various resources.
add more questions and improve exisiting questions.
add solutions for the problems along with their detailed explaination (maybe video)

Credits

Credits and sources are provided throughout this repo.

Special thanks to:

Donne Martin
System Design Primer
Cracking the Coding Interview
Leetcode
GeeksforGeeks
G Balasubramanian
Udit Agarwal ## Contact Info Feel free to contact me to discuss any issues, questions, or comments.

My contact info can be found on my Github Page

License

TODO

https://github.com/prasadgujar/low-level-design-primer

𝟑)𝐀𝐰𝐞𝐬𝐨𝐦𝐞 𝐒𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 𝐈𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰

Awesome Software Engineering Interview

Motivation

This repository aims at providing collated content at a single place to prepare for Software Engineering interviews.

Content

Under development

Low level design questions - Company Wise
Top interview questions - Company Wise
How to ace Behavioural interview rounds
Mock interview platforms
Resume building

Contributing

Feel free to submit pull requests to help with:

Add new questions/topics
Improve new questions/topics
Fix errors
Improve sections
Add new sections

Contact info

Feel free to contact me to discuss any issues, questions, or comments.

License

I am providing code and resources in this repository to you under an open source license. Because this is my personal repository, the license you receive to my code and resources is from me and not my employer (Microsoft).

Copyright 2017 Karan Garg

Creative Commons Attribution 4.0 International License (CC BY 4.0)

http://creativecommons.org/licenses/by/4.0/

https://github.com/imkgarg/Awesome-Software-Engineering-Interview

𝟒)𝐂𝐚𝐜𝐡𝐞 𝐋𝐨𝐰 𝐋𝐞𝐯𝐞𝐥 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧

Cache - Low level system design

Repository for low level system design of a cache

Video explanation

https://youtu.be/B7iCXl_KSoM

Problem statement

Check here

https://github.com/anomaly2104/cache-low-level-system-design

𝟓)𝐂𝐡𝐞𝐬𝐬 𝐋𝐨𝐰-𝐋𝐞𝐯𝐞𝐥 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧

Chess - Low level system design

Video Explanation

https://youtu.be/RVHNcng0oF0

Problem Statements

Problem Statement

Further enhancements

Implement checkmate feature.
Write more unit tests.
Support special move of pawn where it can go diagonal when it kills.
At many places, we are evaluating conditions like:
- OR Operation : We are allowed to do something if any condition out of given conditions fulfill.
- And Operation : We are allowed to do something if all conditions fulfill. Try to improve the design for this.
Add history of moves for each player.
Add support for casteling move.
Can we remove putting currentCell in Piece? How about introducing something like position?
- A piece will have a position and you can always get the cell back from board using this position.

https://github.com/anomaly2104/chess-low-level-system-design

𝟔)𝐓𝐡𝐞 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧

System Design:

Introduction:

What is system?

A system is a loosely used term for an architecture or collection of software or technology that communicate with each other or interact with each other in order to serve a certain set of users with a certain set of requirements.
A system can be defined and built keeping these three factors in mind:
1. The user of the systems
2. The requirements of those users, and
3. The components that are chosen in order to build that system to serve those users and their requirements.

What is design?

Design is a process of understanding the user requirements and selecting the components, modules, and software technologies how they are going to be intertwined and communicating with each other to actually serve the need of the system.

Components of System Design:

Components are the basic building blocks of system components.
It could be divided into two parts:
1. Logical entities:
2. Data
3. Databases
4. Applications
5. Cache
6. Message Queues
7. Infra
8. Communication Protocol
9. Requests (API, RPC, etc.)
10. Tangible entities:
11. Text, images, videos..
12. MongoDB, MySQL, Cassandra..
13. Java, Golang, Python, React..
14. Redis, MemeCache..
15. Kafka, RabbitMQ..
16. AWS, GCP, Azure..
17. APIs, RPCs, Messages..

Client Server Architecture:

Client-server architecture is a computing model in which the server hosts, delivers and manages most ofthe resources and services to be consumed by the client.
Client: a piece ofsoftware or application that takes the input and sends request to the servers.
Server: a piece ofsoftware that receives and processes requestsfrom clients.

- Load balancer: responsible for distributing incoming network traffic across a group of backend servers to optimize resource usage.

A typical topological data flow goes as follows:

Client requests data from server
Load balancer routes the request to the appropriate server
Server processes the request client
Server queries appropriate database for some data
Database returns the queried data back to the server
The server processes the data and sends the data back to the client
This process repeats
- #### Types of Architecture:
Thin client:
- A thin client is designed to be especially small so that the bulk of the data processing occurs on the server.
- Example: Ecommerce, streaming applications.
Thick client:
- A thick client (fat client) is one that will perform the bulk of the processing in client/server applications. With thick clients, there is no need for continuous server communications as it is mainly communicating archival storage information to the server.
- Example: Gaming apps, video editing software.

Tier based architecture:
1-Tier:
- It is the simplest one as it is equivalent to running the application on the personal computer.
2-Tier:
- It is like Client-Server architecture, where communication takes place between client and server.
3-Tier:
- The 3-tier architecture has three different layers.
  - Presentation layer
  - Business Logic layer
  - Database layer
N-Tier:
- An N-Tier Application program is one that is distributed among three or more separate computers in a distributed network.

Proxies:

Proxy is an intermediary server between client and the internet.
Proxy servers allow to hide, conceal and make your network id anonymous by hiding your IP address.
Proxy servers offers the following basic functionalities:
- Firewall and network data filtering.
- Network connection sharing
- Data caching
Types of proxy:
- Forward Proxy
- In this the client requests its internal network server to forward to the internet.
- Reverse Proxy
- In this the requests are forwarded to one or more proxy servers and the response from the proxy server is retrieved as if it came directly from the original server.

Data and Data Flow:

Different formats of data (representation):
- In Business Layer:
- Texts, Videos, Images, etc.
- In Application Layer:
- JSON/XML
- In Data Stores:
- Databases, Tables, Indexes, Cache, Queues, etc.
- Network Layer:
- Packets.
- Hardware Layer:
- 0s and 1s.

Data Generation:
- Users
- Internal Data (System populates on their own).
- Insights

Data Flow Methods:
- APIs.
- Messages.
- Events.

Factors to be considered:
- Type of data
- Volume
- Consumption/Retrieval
- Security

Types of System (Examples):
- Authorization System
- Streaming System
- Transactional System
- Heavy Compute System

Databases:

Types of databases:

If we consider data as people, in terms of buildings, then the way those buildings house people can be said as databases.
Some common types of databases are:
- Relational
- Non-relational
- File type
- Network, etc.

Anatomy of applications and services:

Applications or services performs certain tasks, and at different layers they have different responsibility.
- Tech stack:
- All the codes in applications are written in some languages using some frameworks.
- Any application can be written solely with the use of language. But frameworks do most of the bootstrapping so we can use this feature to make an application on the top of the framework.
- Responsibilities:
- Client app:
  - Render UI.
  - Handle interactions.
  - Collect data.
  - Communicate with backend (API) to fetch and store data.
  - Render static data/informations.
- Backend app:
  - Expose API endpoints.
  - House business logics.
  - Handle data modelling/transformation.
  - Interact with data stores.
  - Interact with other services.
Elements/factors of application development:
- Feature requirements.
- Layer.
- Tech Stack.
- Code structure/design pattern.
- Data store interactions.
- Performance/cost.
- Deployment.
- Monitoring.
- Operational excellence/reliability.

Application Programming Interface (API):

An API is a set of defined rules that explain how computers or applications communicate with one another.
Advantages:
- Communication.
- Abstraction.
- Platform agnostic.
Examples:
- Private APIs: The hidden APIs. Not accessible to everyone.
- Public APIs: Available to public. (Ex: Google maps api)
- Web APIs: Superset of public and private APIs.
- SDK/Library APIs
Factors to consider:
- API contracts
- Documentation
- Data format
- Security
Standards:
- REST:
- Stands for REpresentational State Transfer.
- Guidelines:
  - Client Server.
  - Cacheable.
  - Layered.
  - Stateless.
  - Uniform Interface.
  - Code on demand.
- RPC
- SOAP

Caching:

A hardware or software component which helps in serving the data which is either frequently requested or it is expensive to compute on, so cache stores the computed response and saves the cost of computing.
Cache hit: If a response for a request is available in cache memory, it is called a cache hit.
Cache miss: If a response for a request is not available in cache memory, it is called a cache miss.
Invalidation and eviction:
- Invalidation:
- The data that is kept in cache is not there for forever, it is volatile.
- The data is going to change at some point of time, hence we need to update the cache as well.
- The process of updating the data in cache by replacing the old value with new value is called data invalidation.
- Methods to invalidate:
  - Cache expiry (TTL: Time to live).
  - Remove the cache. (When a new request come, cache miss will happen, and data will be fetched.)
  - Update the cache.
- Eviction:
- A cache eviction algorithm is a way of deciding which element to evict when the cache is full.
- Catch eviction methods:
  - FIFO.
  - LRU.
  - LFU.
Cache Patterns:
Where can be keep cache?

MESSAGE QUEUE:

Message queue

Performance Metrics (used to evaluate how good the system is performing):

Throughput
- Throughput is the number of actions executed or results produced in a certain amount of time.
- In system design, throughput comes into picutre when we need to understand how many API calls are being served in a particular amount of time.
Bandwidth
- Bandwidth is the maximum amount of data that can travel through a 'channel'.
Latency
- Latency is the time required to perform some action or to produce some result.
Response Time
- Response time is the time between a client sending a request and receiving a response. It is the sum of round trip latency and service time.
EXAMPLES (analogies):
- Water Analogy:
- Latency is the amount of time it takes to travel through the tube.
- Bandwidth is how wide the tube is.
- The amount of water flow will be your throughput
- Vehicle Analogy:
- Vehicle travel time from source to destination is latency.
- Types of Roadways are bandwidth.
- Number of Vehicles traveling is throughput.

Performance metrics of different components:

Applications:
- API Response Time
- Throughput of APIs
- Error occurences
- Bug/defect in the code
Databases:
- Time taken by various database queries
- Number of queries executed per unit time(or throughput)
- Memory
Caches:
- Latency of writing to cache
- Number of cache eviction and invalidation
- Memory of cache instance
Message Queues:
- Rate of production and consumption
- Fraction of stale or unprocessed messages
- Number of consumers affects bandwidth and throughput
Workers:
- Time taken for job completion
- Resources used in processing
Server instances:
- Memory/RAM
- CPU

Fault v/s Failure:

Fault is the cause, failure is the effect.

Scaling:

The ability to handle more request by buying more machines/bigger machines.
Key features:
- Able to handle the increased load.
- Not complex to implement and maintain.
- Performance shouldn' takr a hit or rather performance should increase.
Vertical Scaling:
- When we increase the capacity of existing resource it is vertical scaling.
Horizontal Scaling:
- When we increase the number of resources it is horizontal scaling.
Horizontal v/s Vertical Scaling:

| Horizontal | Vertical | |------------|----------| |Need load balancers.|Load balancers not needed.| |Resilient.|Single point of failure.| |Slow remote procedure calls.|Fast inter process communication.| |Data inconsistency.|Data consistent.| |Scales well as uses increases.| Hardware limit.|

Database Replication:

Replication: To have a copy.
Having exact copy of data present in other databases in other machines.
The database that has main source of writes/updates becomes the primary db. (Master)
The database which has the copies from the primary db's is called the secondary database. (Slave)
Why do we need replication?
- Having replicas helps in tolerating faults.
- Having replicas helps in reducing latency.
- Replica databases can be used for read queries, whereas the primary one can be used for write queries. (Gain application performance)
Replication lag:
- The time it takes for the value to be copied from the primary to secondary database.
- If replication lag is huge, then it becomes a problem.
- Replicas will give inconsistent data.
- To overcome this there are several consistenct models:
  - Synchronous replication:
  - All replicas have to be updated before host is acknowledged.
  - Advantages:
    - No lag.
    - Data is always consistent.
  - Disadvantage:
    - Performance might take a hit, because every write will have to wait for all replicas to get updated as well as acknowledge. (High latency)
    - If any replica goes down, and couldn't give any acknowledgement, write will fail.
  - Asynchronous replication:
  - Host is acknowledged after primary database is updated. Replicas update asynchronously.
  - Advantage:
    - Write opeartion becomes faster.
  - Disadvantage:
    - If any replica fails, system will be in a inconsistent state.
  - Semi-synchronous replication:
  - Whenever a new write is issued, the primary database will update the value to all the replicas, and will wait for one of the replicas to acknowledge.

CAP (Consistency, Availability, and Partitioning)

Consistency:
- In a consistent system, once a client writes a value to any server and gets a response, it expects to get that value (or a fresher value) back from any server it reads from.
Availability:
- In an available system, if the client sends a request to a server and the server has not crashed, then the server must eventually respond to the client. The server is not allowed to ignore the client's requests.
Partitioning:
- The system continues to function and upholds its consistency guarantees in spite of network partitions.
- If we can tolerate the partition, and even though if partition happens and system can still be available and consistent is called partition tolerance.
CAP theorem (Brewer Theorem):
- Any network shared system wants to have these three properties.
- In such a system, having all three properties is nearly impossible.
- We need to sacrifice one of them.
- Partition tolerance happens due to network failures, and we do not have complete control over network failures.
- Hence, partition tolerance becomes a mandatory property to support.

Database Sharding

https://github.com/sanyathisside/System-Design

𝟕)𝐒𝐚𝐦𝐩𝐥𝐞 𝐩𝐫𝐨𝐛𝐥𝐞𝐦𝐬 𝐟𝐨𝐫 𝐋𝐋𝐃

LLD implemented for following sample problems

https://github.com/imk13/low-level-design

𝟖) 𝐒𝐜𝐚𝐥𝐞𝐫 𝐀𝐜𝐚𝐝𝐞𝐦𝐲 𝐍𝐨𝐭𝐞𝐬 𝐟𝐨𝐫 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧

https://github.com/naqushab/ScalerAcademy/tree/develop/Useful

𝟗) 𝐋𝐋𝐃 𝐑𝐞𝐬𝐨𝐮𝐫𝐜𝐞𝐬

Low-level Design

Resources

work@tech Machine Coding section

[Youtube] Christopher - Design patterns in OOPS

[Youtube] The Code Mate - LLD Series

[Youtube] Derek Banas - OOPS Playlist

RefactoringGuru Website

Head first Design patterns - Book summary (Principles and patterns)

[Youtube] Udit Agarwal LLD playlist

[Youtube] Design patterns and SOLID

[Youtube] Google's Clean code talks

Educative's Grokking Object-oriented Design Interview

[Youtube] Success in Tech

[Youtube] Low level System design

[Youtube] Low Level Design by Amazonian

[Youtube] SDE Skills - Object oriented design

Design Patterns for Humans [PHP] [Github]

Design patterns implemented in Java [Github]

[Medium] How to approach Object Oriented Design Questions step by step

[Rooftop Slushie] How to approach an LLD question for SDE1?

[Hashnode] Blog series on Software Design - by Maxi Contieri

[Hashnode] Blog series on Code smells - by Maxi Contieri

[Github] Design patterns - Code examples

Credits

This repo is just a collection of Low-level Design resources available on the Internet and these resources are created by their respective owners.

License

https://github.com/sbvkrishna/low-level-design

Reference

Contributed by

https://www.linkedin.com/in/ansh-/

How to Setup Azure Front door for ASP.NET MVC Webapp hosted in Azure App Service with Azure AD Authentication

Sanjeevi Subramani — Thu, 16 Jun 2022 09:59:51 +0000

Create Webapp - Azure App Service

Create a webapp - azure app service to host the webapp we are creating.

Create Azure AD protected Webapp

Create a dotnet core webapp with Azure AD authentication using Open ID connect.

Follow this article to create a webapp with Azure AD:

https://docs.microsoft.com/en-us/azure/active-directory/develop/tutorial-v2-asp-webapp

Create Azure Front Door

Create Front Door endpoint

Create Front door origin group

Create Front door origin

Front door settings look like this after all above steps

In this we have to update the host header to empty so that the

Update redirect Uri in Azure AD

Update the redirect Uri in Azure AD with the Front door endpoint url

Update Webapp with the redirect Uri of Front door

When the Web App sits behind Azure Front Door, we need to configure the redirect_uri in the /authorize request to be the Front Door's address.

In the code below we override the "OnRedirectToIdentityProvider" event and inject the Front Door's address. When I was trying this out, I simply hardcoded the address but ideally, you'd extract it from the headers that Front Door injects into the request.

This is the code I used when trying to authenticate my dotnet core Server App (.net 6) running on an Azure App Service, Protected by Azure AD, running behind Azure Front Door.

public void ConfigureServices(IServiceCollection services)
{
    // ... existing code

    services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
                .AddMicrosoftIdentityWebApp(Configuration.GetSection("AzureAd"))
                .EnableTokenAcquisitionToCallDownstreamApi(new[] { "User.Read" })
                .AddInMemoryTokenCaches();

    services.Configure<OpenIdConnectOptions>(OpenIdConnectDefaults.AuthenticationScheme, options =>
    {
        options.Events = new OpenIdConnectEvents
        {
            OnRedirectToIdentityProvider = (context) =>
            {   
                // Override the redirect_uri
                // Ideally extract this from config 
                // Or context.Request.Headers["X-Forwarded-Host"]
                // see: https://docs.microsoft.com/en-us/azure/frontdoor/front-door-http-headers-protocol#front-door-to-backend

                context.ProtocolMessage.RedirectUri 
                    = "https://YOUR-FRONT-DOOR-or-APP-GATEWAY/signin-oidc";
                return Task.FromResult(0);
            }
        };
    });

    services.Configure<ForwardedHeadersOptions>(options =>
    {
        options.ForwardedHeaders = ForwardedHeaders.XForwardedFor |
                        ForwardedHeaders.XForwardedProto;
        options.KnownNetworks.Clear();
        options.KnownProxies.Clear();
    });

    // ... existing code
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ... existing code

    // Don't forget to add this ...
    app.UseForwardedHeaders();

    // ... existing code
}

When the code works, the "redirect_uri" param should point to your Front Door/Gateway as shown here.

Reference

https://stackoverflow.com/questions/61733729/authentication-with-azure-ad-redirect-uri-is-incorrect-using-frontdoor

Create Dotnet 6 API with Swagger UI

Sanjeevi Subramani — Tue, 22 Mar 2022 11:28:35 +0000

Tutorial: Create a minimal web API with ASP.NET Core

Minimal APIs are architected to create HTTP APIs with minimal dependencies. They are ideal for microservices and apps that want to include only the minimum files, features, and dependencies in ASP.NET Core.

This tutorial teaches the basics of building a minimal web API with ASP.NET Core. For a tutorial on creating a web API project based on controllers that contains more features, see Create a web API.

Overview

This tutorial creates the following API:

| API | Description | Request body | Response body |
| GET / | Browser test, "Hello World" | None | Hello World! |
| GET /todoitems | Get all to-do items | None | Array of to-do items |
| GET /todoitems/complete | Get completed to-do items | None | Array of to-do items |
| GET /todoitems/{id} | Get an item by ID | None | To-do item |
| POST /todoitems | Add a new item | To-do item | To-do item |
| PUT /todoitems/{id} | Update an existing item | To-do item | None |
| DELETE /todoitems/{id} | Delete an item | None | None |

Prerequisites

Visual Studio

Create a Web API project

Start Visual Studio 2022 and select Create a new project.
In the Create a new project dialog:
- Enter API in the Search for templates search box.
- Select the ASP.NET Core Web API template and select Next.

Name the project TodoApi and select Next.
In the Additional information dialog:

Examine the code

The Program.cs file contains the following code:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

var summaries = new[]
{
    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};

app.MapGet("/weatherforecast", () =>
{
    var forecast = Enumerable.Range(1, 5).Select(index =>
       new WeatherForecast
       (
           DateTime.Now.AddDays(index),
           Random.Shared.Next(-20, 55),
           summaries[Random.Shared.Next(summaries.Length)]
       ))
        .ToArray();
    return forecast;
})
.WithName("GetWeatherForecast");

app.Run();

internal record WeatherForecast(DateTime Date, int TemperatureC, string? Summary)
{
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

The project template creates a WeatherForecast API with support for Swagger. Swagger is used to generate useful documentation and help pages for web APIs.

The following highlighted code adds support for Swagger:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

Run the app

Press Ctrl+F5 to run without the debugger.

Visual Studio launches the Kestrel web server.

The Swagger page /swagger/index.html is displayed. Select GET > Try it out> Execute. The page displays:

The Curl command to test the WeatherForecast API.
The URL to test the WeatherForecast API.
The response code, body, and headers.
A drop down list box with media types and the example value and schema.

Copy and paste the Request URL in the browser: https://localhost:<port>/WeatherForecast. JSON similar to the following is returned:

[
  {
    "date": "2021-10-19T14:12:50.3079024-10:00",
    "temperatureC": 13,
    "summary": "Bracing",
    "temperatureF": 55
  },
  {
    "date": "2021-10-20T14:12:50.3080559-10:00",
    "temperatureC": -8,
    "summary": "Bracing",
    "temperatureF": 18
  },
  {
    "date": "2021-10-21T14:12:50.3080601-10:00",
    "temperatureC": 12,
    "summary": "Hot",
    "temperatureF": 53
  },
  {
    "date": "2021-10-22T14:12:50.3080603-10:00",
    "temperatureC": 10,
    "summary": "Sweltering",
    "temperatureF": 49
  },
  {
    "date": "2021-10-23T14:12:50.3080604-10:00",
    "temperatureC": 36,
    "summary": "Warm",
    "temperatureF": 96
  }
]

Update the generated code

This tutorial focuses on creating a web API, so we'll delete the Swagger code and the WeatherForecast code. Replace the contents of the Program.cs file with the following:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

The following highlighted code creates a Web application builder and a application with preconfigured defaults:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

The following code creates an HTTP GET endpoint / which returns Hello World!:

app.MapGet("/", () => "Hello World!");

app.Run(); runs the app.

Remove the two "launchUrl": "swagger", lines from the Properties/launchSettings.json file. When the launchUrl isn't specified, the web browser requests the / endpoint.

Run the app. Hello World! is displayed. The updated Program.cs file contains a minimal but complete app.

Add NuGet packages

NuGet packages must be added to support the database and diagnostics used in this tutorial.

From the Tools menu, select NuGet Package Manager > Manage NuGet Packages for Solution.
Select the Browse tab, and verify that Include prerelease is checked.
Enter Microsoft.EntityFrameworkCore.InMemory in the search box, and then select Microsoft.EntityFrameworkCore.InMemory.
Select the Project checkbox in the right pane and then select Install.
Follow the preceding instructions to add the Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore package.

Add the API code

Replace the contents of the Program.cs file with the following code:

using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<TodoDb>(opt => opt.UseInMemoryDatabase("TodoList"));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.MapGet("/todoitems", async (TodoDb db) =>
    await db.Todos.ToListAsync());

app.MapGet("/todoitems/complete", async (TodoDb db) =>
    await db.Todos.Where(t => t.IsComplete).ToListAsync());

app.MapGet("/todoitems/{id}", async (int id, TodoDb db) =>
    await db.Todos.FindAsync(id)
        is Todo todo
            ? Results.Ok(todo)
            : Results.NotFound());

app.MapPost("/todoitems", async (Todo todo, TodoDb db) =>
{
    db.Todos.Add(todo);
    await db.SaveChangesAsync();

    return Results.Created($"/todoitems/{todo.Id}", todo);
});

app.MapPut("/todoitems/{id}", async (int id, Todo inputTodo, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id);

    if (todo is null) return Results.NotFound();

    todo.Name = inputTodo.Name;
    todo.IsComplete = inputTodo.IsComplete;

    await db.SaveChangesAsync();

    return Results.NoContent();
});

app.MapDelete("/todoitems/{id}", async (int id, TodoDb db) =>
{
    if (await db.Todos.FindAsync(id) is Todo todo)
    {
        db.Todos.Remove(todo);
        await db.SaveChangesAsync();
        return Results.Ok(todo);
    }

    return Results.NotFound();
});

app.Run();

class Todo
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public bool IsComplete { get; set; }
}

class TodoDb : DbContext
{
    public TodoDb(DbContextOptions<TodoDb> options)
        : base(options) { }

    public DbSet<Todo> Todos => Set<Todo>();
}

The model and database context classes

The sample app contains the following model:

class Todo
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public bool IsComplete { get; set; }
}

A model is a class that represents data that the app manages. The model for this app is the Todo class.

The sample app also contains the following database context class:

class TodoDb : DbContext
{
    public TodoDb(DbContextOptions<TodoDb> options)
        : base(options) { }

    public DbSet<Todo> Todos => Set<Todo>();
}

The database context is the main class that coordinates Entity Framework functionality for a data model. This class is created by deriving from the DB context class.

The following highlighted code adds the database context to the dependency injection (DI) container and enables displaying database-related exceptions:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<TodoDb>(opt => opt.UseInMemoryDatabase("TodoList"));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();
var app = builder.Build();

The DI container provides access to the database context and other services.

The following code creates an HTTP POST endpoint /todoitems to add data to the in-memory database:

app.MapPost("/todoitems", async (Todo todo, TodoDb db) =>
{
    db.Todos.Add(todo);
    await db.SaveChangesAsync();

    return Results.Created($"/todoitems/{todo.Id}", todo);
});

Install Postman to test the app

This tutorial uses Postman to test the API.

Install Postman
Start the web app.
Start Postman.
Disable SSL certificate verification
- From File > Settings ( General tab), disable SSL certificate verification.

[!WARNING] Re-enable SSL certificate verification after testing the controller.

Test posting data

The following instructions post data to the app:

Create a new request.
Set the HTTP method to POST.
Set the URI to https://localhost:<port>/todoitems. For example: https://localhost:5001/todoitems
Select the Body tab.
Select raw.
Set the type to JSON.
In the request body enter JSON for a to-do item:
Select Send.

Examine the GET endpoints

The sample app implements several GET endpoints using calls to MapGet:

| API | Description | Request body | Response body |
| GET / | Browser test, "Hello World" | None | Hello World! |
| GET /todoitems | Get all to-do items | None | Array of to-do items |
| GET /todoitems/{id} | Get an item by ID | None | To-do item |

app.MapGet("/", () => "Hello World!");

app.MapGet("/todoitems", async (TodoDb db) =>
    await db.Todos.ToListAsync());

app.MapGet("/todoitems/complete", async (TodoDb db) =>
    await db.Todos.Where(t => t.IsComplete).ToListAsync());

app.MapGet("/todoitems/{id}", async (int id, TodoDb db) =>
    await db.Todos.FindAsync(id)
        is Todo todo
            ? Results.Ok(todo)
            : Results.NotFound());

Test the GET endpoints

Test the app by calling the two endpoints from a browser or Postman. For example:

GET https://localhost:5001/todoitems
GET https://localhost:5001/todoitems/1

The call to GET /todoitems produces a response similar to the following:

[
  {
    "id": 1,
    "name": "Item1",
    "isComplete": false
  }
]

Test the GET endpoints with Postman

Create a new request.
Set the HTTP method to GET.
Set the request URI to https://localhost:<port>/todoitems. For example, https://localhost:5001/todoitems.
Select Send.

This app uses an in-memory database. If the app is restarted, the GET request doesn't return any data. If no data is returned, first POST data to the app.

Return values

ASP.NET Core automatically serializes the object to JSON and writes the JSON into the body of the response message. The response code for this return type is 200 OK, assuming there are no unhandled exceptions. Unhandled exceptions are translated into 5xx errors.

The return types can represent a wide range of HTTP status codes. For example, GET /todoitems/{id} can return two different status values:

If no item matches the requested ID, the method returns a 404 status Not found error code.
Otherwise, the method returns 200 with a JSON response body. Returning item results in an HTTP 200 response.

Examine the PUT endpoint

The sample app implements a single PUT endpoint using MapPut:

app.MapPut("/todoitems/{id}", async (int id, Todo inputTodo, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id);

    if (todo is null) return Results.NotFound();

    todo.Name = inputTodo.Name;
    todo.IsComplete = inputTodo.IsComplete;

    await db.SaveChangesAsync();

    return Results.NoContent();
});

This method is similar to the MapPost method, except it uses HTTP PUT. A successful response returns 204 (No Content). According to the HTTP specification, a PUT request requires the client to send the entire updated entity, not just the changes. To support partial updates, use HTTP PATCH.

Test the PUT endpoint

This sample uses an in-memory database that must be initialized each time the app is started. There must be an item in the database before you make a PUT call. Call GET to ensure there's an item in the database before making a PUT call.

Update the to-do item that has Id = 1 and set its name to "feed fish":

{
  "Id": 1,
  "name": "feed fish",
  "isComplete": false
}

Examine the DELETE endpoint

The sample app implements a single DELETE endpoint using MapDelete:

app.MapDelete("/todoitems/{id}", async (int id, TodoDb db) =>
{
    if (await db.Todos.FindAsync(id) is Todo todo)
    {
        db.Todos.Remove(todo);
        await db.SaveChangesAsync();
        return Results.Ok(todo);
    }

    return Results.NotFound();
});

Use Postman to delete a to-do item:

Set the method to DELETE.
Set the URI of the object to delete (for example https://localhost:5001/todoitems/1).
Select Send.

Prevent over-posting

Currently the sample app exposes the entire Todo object. Production apps typically limit the data that's input and returned using a subset of the model. There are multiple reasons behind this and security is a major one. The subset of a model is usually referred to as a Data Transfer Object (DTO), input model, or view model. DTO is used in this article.

A DTO may be used to:

Prevent over-posting.
Hide properties that clients are not supposed to view.
Omit some properties in order to reduce payload size.
Flatten object graphs that contain nested objects. Flattened object graphs can be more convenient for clients.

To demonstrate the DTO approach, update the Todo class to include a secret field:

public class Todo
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public bool IsComplete { get; set; }
    public string? Secret { get; set; }
}

The secret field needs to be hidden from this app, but an administrative app could choose to expose it.

Verify you can post and get the secret field.

Create a DTO model:

public class TodoItemDTO
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public bool IsComplete { get; set; }

    public TodoItemDTO() { }
    public TodoItemDTO(Todo todoItem) =>
    (Id, Name, IsComplete) = (todoItem.Id, todoItem.Name, todoItem.IsComplete);
}

Update the code to use TodoItemDTO:

using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDatabaseDeveloperPageExceptionFilter();
builder.Services.AddDbContext<TodoDb>(opt => opt.UseInMemoryDatabase("TodoList"));
var app = builder.Build();

app.MapGet("/todoitems", async (TodoDb db) =>
    await db.Todos.Select(x => new TodoItemDTO(x)).ToListAsync());

app.MapGet("/todoitems/{id}", async (int id, TodoDb db) =>
    await db.Todos.FindAsync(id)
        is Todo todo
            ? Results.Ok(new TodoItemDTO(todo))
            : Results.NotFound());

app.MapPost("/todoitems", async (TodoItemDTO todoItemDTO, TodoDb db) =>
{
    var todoItem = new Todo
    {
        IsComplete = todoItemDTO.IsComplete,
        Name = todoItemDTO.Name
    };

    db.Todos.Add(todoItem);
    await db.SaveChangesAsync();

    return Results.Created($"/todoitems/{todoItem.Id}", new TodoItemDTO(todoItem));
});

app.MapPut("/todoitems/{id}", async (int id, TodoItemDTO todoItemDTO, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id);

    if (todo is null) return Results.NotFound();

    todo.Name = todoItemDTO.Name;
    todo.IsComplete = todoItemDTO.IsComplete;

    await db.SaveChangesAsync();

    return Results.NoContent();
});

app.MapDelete("/todoitems/{id}", async (int id, TodoDb db) =>
{
    if (await db.Todos.FindAsync(id) is Todo todo)
    {
        db.Todos.Remove(todo);
        await db.SaveChangesAsync();
        return Results.Ok(new TodoItemDTO(todo));
    }

    return Results.NotFound();
});

app.Run();

public class Todo
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public bool IsComplete { get; set; }
    public string? Secret { get; set; }
}

public class TodoItemDTO
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public bool IsComplete { get; set; }

    public TodoItemDTO() { }
    public TodoItemDTO(Todo todoItem) =>
    (Id, Name, IsComplete) = (todoItem.Id, todoItem.Name, todoItem.IsComplete);
}

class TodoDb : DbContext
{
    public TodoDb(DbContextOptions<TodoDb> options)
        : base(options) { }

    public DbSet<Todo> Todos => Set<Todo>();
}

Verify you can't post or get the secret field.

Use JsonOptions

The following code uses Json Options:

using Microsoft.AspNetCore.Http.Json;

var builder = WebApplication.CreateBuilder(args);

// Configure JSON options
builder.Services.Configure<JsonOptions>(options =>
{
    options.SerializerOptions.IncludeFields = true;
});

var app = builder.Build();

app.MapGet("/", () => new Todo { Name = "Walk dog", IsComplete = false });

app.Run();

class Todo
{
    // These are public fields instead of properties.
    public string? Name;
    public bool IsComplete;
}

The following code uses Json Serializer Options:

using System.Text.Json;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var options = new JsonSerializerOptions(JsonSerializerDefaults.Web);

app.MapGet("/", () => Results.Json(new Todo {
                      Name = "Walk dog", IsComplete = false }, options));

app.Run();

class Todo
{
    public string? Name { get; set; }
    public bool IsComplete { get; set; }
}

The preceding code uses web defaults, which converts property names to camel case.

Test minimal API

For an example of testing a minimal API app, see this GitHub sample.

Reference:

https://docs.microsoft.com/en-us/aspnet/core/tutorials/min-web-api?view=aspnetcore-6.0&tabs=visual-studio

Configurable Retry logic for SQL server connection in Dotnet C#

Sanjeevi Subramani — Thu, 24 Feb 2022 14:23:39 +0000

The implementation in this sample is as simple as possible to demonstrate step-by-step customization. It doesn't include advanced practices like thread safety, async, and concurrency. For a deep-dive into a real implementation, you can study the pre-defined retry logic in the Microsoft.Data.SqlClient GitHub repository.

Define custom configurable retry logic classes:

Enumerator: Define a fixed sequence of time intervals and extend the acceptable range of times from two minutes to four minutes.

public class CustomEnumerator : SqlRetryIntervalBaseEnumerator
{
    // Set the maximum acceptable time to 4 minutes
    private readonly TimeSpan _maxValue = TimeSpan.FromMinutes(4);

    public CustomEnumerator(TimeSpan timeInterval, TimeSpan maxTime, TimeSpan minTime)
        : base(timeInterval, maxTime, minTime) {}

    // Return fixed time on each request
    protected override TimeSpan GetNextInterval()
    {
        return GapTimeInterval;
    }

    // Override the validate method with the new time range validation
    protected override void Validate(TimeSpan timeInterval, TimeSpan maxTimeInterval, TimeSpan minTimeInterval)
    {
        if (minTimeInterval < TimeSpan.Zero || minTimeInterval > _maxValue)
        {
            throw new ArgumentOutOfRangeException(nameof(minTimeInterval));
        }

        if (maxTimeInterval < TimeSpan.Zero || maxTimeInterval > _maxValue)
        {
            throw new ArgumentOutOfRangeException(nameof(maxTimeInterval));
        }

        if (timeInterval < TimeSpan.Zero || timeInterval > _maxValue)
        {
            throw new ArgumentOutOfRangeException(nameof(timeInterval));
        }

        if (maxTimeInterval < minTimeInterval)
        {
            throw new ArgumentOutOfRangeException(nameof(minTimeInterval));
        }
    }
}

Retry logic: Implement retry logic on any command that isn't part of an active transaction. Lower the number of retries from 60 to 20.

public class CustomRetryLogic : SqlRetryLogicBase
{
    // Maximum number of attempts
    private const int maxAttempts = 20;

    public CustomRetryLogic(int numberOfTries,
                             SqlRetryIntervalBaseEnumerator enumerator,
                             Predicate<Exception> transientPredicate)
    {
        if (!(numberOfTries > 0 && numberOfTries <= maxAttempts))
        {
            // 'numberOfTries' should be between 1 and 20.
            throw new ArgumentOutOfRangeException(nameof(numberOfTries));
        }

        // Assign parameters to the relevant properties
        NumberOfTries = numberOfTries;
        RetryIntervalEnumerator = enumerator;
        TransientPredicate = transientPredicate;
        Current = 0;
    }

    // Prepare this object for the next round
    public override void Reset()
    {
        Current = 0;
        RetryIntervalEnumerator.Reset();
    }

    public override bool TryNextInterval(out TimeSpan intervalTime)
    {
        intervalTime = TimeSpan.Zero;
        // First try has occurred before starting the retry process. 
        // Check if retry is still allowed
        bool result = Current < NumberOfTries - 1;

        if (result)
        {
            // Increase the number of attempts
            Current++;
            // It's okay if the RetryIntervalEnumerator gets to the last value before we've reached our maximum number of attempts.
            // MoveNext() will simply leave the enumerator on the final interval value and we will repeat that for the final attempts.
            RetryIntervalEnumerator.MoveNext();
            // Receive the current time from enumerator
            intervalTime = RetryIntervalEnumerator.Current;
        }
        return result;
    }
}

Provider: Implements a retry provider that retries on synchronous operations without a Retrying event. Adds TimeoutException to the existing SqlException transient exception error numbers.

public class CustomProvider : SqlRetryLogicBaseProvider
{
    // Preserve the given retryLogic on creation
    public CustomProvider(SqlRetryLogicBase retryLogic)
    {
        RetryLogic = retryLogic;
    }

    public override TResult Execute<TResult>(object sender, Func<TResult> function)
    {
        // Create a list to save transient exceptions to report later if necessary
        IList<Exception> exceptions = new List<Exception>();
        // Prepare it before reusing
        RetryLogic.Reset();
        // Create an infinite loop to attempt the defined maximum number of tries
        do
        {
            try
            {
                // Try to invoke the function
                return function.Invoke();
            }
            // Catch any type of exception for further investigation
            catch (Exception e)
            {
                // Ask the RetryLogic object if this exception is a transient error
                if (RetryLogic.TransientPredicate(e))
                {
                    // Add the exception to the list of exceptions we've retried on
                    exceptions.Add(e);
                    // Ask the RetryLogic for the next delay time before the next attempt to run the function
                    if (RetryLogic.TryNextInterval(out TimeSpan gapTime))
                    {
                        Console.WriteLine($"Wait for {gapTime} before next try");
                        // Wait before next attempt
                        Thread.Sleep(gapTime);
                    }
                    else
                    {
                        // Number of attempts has exceeded the maximum number of tries
                        throw new AggregateException("The number of retries has exceeded the maximum number of attempts.", exceptions);
                    }
                }
                else
                {
                    // If the exception wasn't a transient failure throw the original exception
                    throw;
                }
            }
        } while (true);
    }

    public override Task<TResult> ExecuteAsync<TResult>(object sender, Func<Task<TResult>> function, CancellationToken cancellationToken = default)
    {
        throw new NotImplementedException();
    }

    public override Task ExecuteAsync(object sender, Func<Task> function, CancellationToken cancellationToken = default)
    {
        throw new NotImplementedException();
    }
}

Create a retry provider instance consisting of the defined custom types:

public static SqlRetryLogicBaseProvider CreateCustomProvider(SqlRetryLogicOption options)
{
    // 1. create an enumerator instance
    CustomEnumerator customEnumerator = new CustomEnumerator(options.DeltaTime, options.MaxTimeInterval, options.MinTimeInterval);
    // 2. Use the enumerator object to create a new RetryLogic instance
    CustomRetryLogic customRetryLogic = new CustomRetryLogic(5, customEnumerator, (e) => TransientErrorsCondition(e, options.TransientErrors));
    // 3. Create a provider using the RetryLogic object
    CustomProvider customProvider = new CustomProvider(customRetryLogic);
    return customProvider;
}

The following function will evaluate an exception by using the given list of retryable exceptions and the special TimeoutException exception to determine if it's retryable:'

// Return true if the exception is a transient fault.
private static bool TransientErrorsCondition(Exception e, IEnumerable<int> retriableConditions)
{
    bool result = false;

    // Assess only SqlExceptions
    if (retriableConditions != null && e is SqlException ex)
    {
        foreach (SqlError item in ex.Errors)
        {
            // Check each error number to see if it is a retriable error number
            if (retriableConditions.Contains(item.Number))
            {
                result = true;
                break;
            }
        }
    }
    // Other types of exceptions can also be assessed
    else if (e is TimeoutException)
    {
        result = true;
    }
    return result;
}

Use the customized retry logic:

Define the retry logic parameters:

// Define the retry logic parameters
var options = new SqlRetryLogicOption()
{
    // Tries 5 times before throwing an exception
    NumberOfTries = 5,
    // Preferred gap time to delay before retry
    DeltaTime = TimeSpan.FromSeconds(1),
    // Maximum gap time for each delay time before retry
    MaxTimeInterval = TimeSpan.FromSeconds(20),
    // SqlException retriable error numbers
    TransientErrors = new int[] { 4060, 1024, 1025}
};

Use the customized retry logic:

Define the retry logic parameters:

// Define the retry logic parameters
var options = new SqlRetryLogicOption()
{
    // Tries 5 times before throwing an exception
    NumberOfTries = 5,
    // Preferred gap time to delay before retry
    DeltaTime = TimeSpan.FromSeconds(1),
    // Maximum gap time for each delay time before retry
    MaxTimeInterval = TimeSpan.FromSeconds(20),
    // SqlException retriable error numbers
    TransientErrors = new int[] { 4060, 1024, 1025}
};

Create a custom retry provider:

// Create a custom retry logic provider
SqlRetryLogicBaseProvider provider = CustomRetry.CreateCustomProvider(options);

Assign the retry provider to the SqlConnection.RetryLogicProvider or SqlCommand.RetryLogicProvider:

// Assumes that connection is a valid SqlConnection object 
// Set the retry logic provider on the connection instance
connection.RetryLogicProvider = provider;
// Establishing the connection will trigger retry if one of the given transient failure occurs.
connection.Open();

Don't forget to enable the configurable retry logic switch before using it. For more information, see Enable configurable retry logic.

Reference :

https://docs.microsoft.com/en-us/sql/connect/ado-net/configurable-retry-logic-core-apis-sqlclient?view=sql-server-ver15

Managed Identity in Dotnet Core API deployed in Azure App Service to Azure SQL Server

Sanjeevi Subramani — Thu, 10 Feb 2022 11:52:06 +0000

1. Grant database access to Azure AD user

First, enable Azure Active Directory authentication to SQL Database by assigning an Azure AD user as the admin of the server. This user is different from the Microsoft account you used to sign up for your Azure subscription. It must be a user that you created, imported, synced, or invited into Azure AD. For more information on allowed Azure AD users, see Azure AD features and limitations in SQL Database.

If your Azure AD tenant doesn't have a user yet, create one by following the steps at Add or delete users using Azure Active Directory.

Find the object ID of the Azure AD user using the az ad user list and replace . The result is saved to a variable.

azureaduser=$(az ad user list --filter "userPrincipalName eq '<user-principal-name>'" --query [].objectId --output tsv)

Add this Azure AD user as an Active Directory admin using az sql server ad-admin create command in the Cloud Shell. In the following command, replace with the server name (without the .database.windows.net suffix).

az sql server ad-admin create --resource-group myResourceGroup --server-name <server-name> --display-name ADMIN --object-id $azureaduser

2. Set up your dev environment

Visual Studio for Windows is integrated with Azure AD authentication. To enable development and debugging in Visual Studio, add your Azure AD user in Visual Studio by selecting File > Account Settings from the menu, and select Sign in or Add.

To set the Azure AD user for Azure service authentication, select Tools > Options from the menu, then select Azure Service Authentication > Account Selection. Select the Azure AD user you added and select OK.

Older way of using System.Data.SqlClient before new version of Microsoft.Data.SqlClient version came to picture

using Azure.Core;
using Azure.Identity;
using Microsoft.Azure.Services.AppAuthentication;

namespace DummyApi
{
    public class AzureSqlAuthTokenService : IDBAuthTokenService
    { 
        // See https://docs.microsoft.com/azure/active-directory/managed-identities-azure-resources/services-support-managed-identities#azure-sql
        private static readonly string[] _azureSqlScopes = new[]
        {
        "https://database.windows.net//.default"
        };

        private static readonly TokenCredential _credential = new ChainedTokenCredential(
            new ManagedIdentityCredential(),
            new EnvironmentCredential());

        public string GetToken()
        {
            AzureServiceTokenProvider provider = new AzureServiceTokenProvider(serviceProviderConnection);
            var token = provider.GetAccessTokenAsync("https://database.windows.net/").Result;
            return token;
        }
    }
}

In Above code "serviceProviderConnection" will have following value when debugging in local Visual Studio:

RunAs=Developer; DeveloperTool=VisualStudio

It will be updated to following when deployed to App Service:

RunAs=App

Refer full values in this link :

https://docs.microsoft.com/en-us/dotnet/api/overview/azure/service-to-service-authentication#connection-string-support

How to call the above code when connecting to SQLConnection - follow this:


                using (SqlConnection _connection = new SqlConnection())
                {
                    _connection.ConnectionString = sqlConnectionString;
                    _connection.AccessToken = authTokenService.GetToken();

                    _connection.Open();

                    // do some stuff with the sqlconnection to read or write record in SQL.

                    _connection.Close();

                    return true;
                }

3. Modify your project - new way of using Microsoft.Data.SqlClient

In Visual Studio, open the Package Manager Console and add the NuGet package Microsoft.Data.SqlClient

Install-Package Microsoft.Data.SqlClient -Version 4.0.1

Token creation part is handled by this library by default.

In the ASP.NET Core and SQL Database tutorial, the MyDbConnection connection string in appsettings.json isn't used at all yet. The local environment and the Azure environment both get connection strings from their respective environment variables in order to keep connection secrets out of the source file. But now with Active Directory authentication, there are no more secrets. In appsettings.json, replace the value of the MyDbConnection connection string with:

"Server=tcp:<server-name>.database.windows.net;Authentication=Active Directory Default; Database=<database-name>;"



                using (SqlConnection _connection = new SqlConnection(sqlConnectionString))
                {
                    _connection.Open();

                    // do some stuff with the sqlconnection to read or write record in SQL.

                    _connection.Close();

                    return true;
                }

4. Use managed identity connectivity

Next, you configure your App Service app to connect to SQL Database with a system-assigned managed identity.

Enable managed identity on app

To enable a managed identity for your Azure app, use the az webapp identity assign command in the Cloud Shell. In the following command, replace .

az webapp identity assign --resource-group myResourceGroup --name <app-name>

Here's an example of the output:

{
  "additionalProperties": {},
  "principalId": "21dfa71c-9e6f-4d17-9e90-1d28801c9735",
  "tenantId": "72f988bf-86f1-41af-91ab-2d7cd011db47",
  "type": "SystemAssigned"
}

Grant permissions to managed identity

In the Cloud Shell, sign in to SQL Database by using the SQLCMD command. Replace with your server name, with the database name your app uses, and and with your Azure AD user's credentials.

sqlcmd -S <server-name>.database.windows.net -d <db-name> -U <aad-user-name> -P "<aad-password>" -G -l 30

In the SQL prompt for the database you want, run the following commands to grant the permissions your app needs. For example,

CREATE USER [<identity-name>] FROM EXTERNAL PROVIDER;
ALTER ROLE db_datareader ADD MEMBER [<identity-name>];
ALTER ROLE db_datawriter ADD MEMBER [<identity-name>];
ALTER ROLE db_ddladmin ADD MEMBER [<identity-name>];
GO

is the name of the managed identity in Azure AD. If the identity is system-assigned, the name is always the same as the name of your App Service app. For a deployment slot, the name of its system-assigned identity is /slots/. To grant permissions for an Azure AD group, use the group's display name instead (for example, myAzureSQLDBAccessGroup).

Type EXIT to return to the Cloud Shell prompt.

5. Publish your changes

All that's left now is to publish your changes to Azure.

Reference:

https://docs.microsoft.com/en-us/azure/app-service/tutorial-connect-msi-sql-database?tabs=windowsclient%2Cefcore%2Cdotnet

Bot Framework chatbot in VNET using Directline Extension and App Service

Sanjeevi Subramani — Sun, 23 Jan 2022 15:33:15 +0000

Enable Direct Line App Service extension

The complete code is available in this GitHub Repo:

https://github.com/SSanjeevi/VirtualAssistantDirectlineExtn

Update bot code

In Visual Studio, open your bot project.
Allow your app to use named pipes:
Open the Startup.cs file. In the Configure method, add a call to the UseNamedPipes method.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseDefaultFiles()
        .UseStaticFiles()
        .UseWebSockets()
         // Allow the bot to use named pipes.
        .UseNamedPipes(System.Environment.GetEnvironmentVariable("APPSETTING_WEBSITE_SITE_NAME") + ".directline");
        .UseRouting()
        .UseAuthorization()
        .UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });

    // app.UseHttpsRedirection();
}

Save the Startup.cs file.
Deploy your updated bot to Azure.

Enable bot Direct Line App Service extension

In the Azure portal, go to your Azure Bot resource.
From the left panel menu under Bot management select Channels to configure the Azure Bot Service channels your bot accepts messages from.
If it is not already enabled, select the Direct Line channel and follow instructions to enable the channel.
In the Connect to channels table select the Edit link on the Direct Line row.
Scroll down to the App Service extension Keys section.
Select the Show link to reveal one of the keys. Copy this value for use later.
Go to the home page, select App Services at the top of the page. Alternatively, display the portal menu and then select the App Services menu item, in the left panel. Azure displays the App Services page.
In the search box enter your Azure Bot resource name. Your resource will be listed.
Notice that if you hover over the icon or the menu item, you get the list of the last resources you viewed. Chances are your Azure Bot resource will be listed.
Select your resource link.
In the Settings section, select the Configuration menu item.
In the right panel, add the following settings:

Name - Value DirectLineExtensionKey - The value of the App Service extension key you copied earlier. DIRECTLINE_EXTENSION_VERSION - latest

If your bot is hosted in a sovereign or otherwise restricted Azure cloud, where you don't access Azure via the public portal, you will also need to add the following setting:
Still within the Configuration section, select the General settings section and turn on Web sockets.
Select Save to save the settings. This restarts the Azure App Service.

Confirm the extension and the bot are configured

In your browser, navigate to https://.azurewebsites.net/.bot. If everything is correct, the page will return this JSON content: {"v":"123","k":true,"ib":true,"ob":true,"initialized":true}. This is the information you obtain when everything works correctly, where
v displays the build version of the Direct Line App Service extension.
k determines whether the extension can read an extension key from its configuration. initialized determines whether the extension can use the extension key to download the bot metadata from Azure Bot Service.
ib determines whether the extension can establish an inbound connection with the bot.
ob determines whether the extension can establish an outbound connection with the bot.

Use Web Chat with the Direct Line App Service extension

Generally speaking, the approach is the same as before. With the exception that in version 4.9.1 or later of Web Chat there is built-in support for establishing a two-way WebSocket, which instead of connecting to https://directline.botframework.com/ connects directly to the Direct Line App Service extension hosted with your bot. The Direct Line URL for your bot will be https://.azurewebsites.net/.bot/, the Direct Line endpoint on your app service extension. If you configure your own domain name, or your bot is hosted in a sovereign Azure cloud, substitute in the appropriate URL and append the /.bot/ path to access the Direct Line App Service extension's REST APIs.

Exchange the secret for a token by following the instructions in the Authentication article. Instead of obtaining a token at https://directline.botframework.com/v3/directline/tokens/generate, you will generate the token directly from your Direct Line App Service extension at https://.azurewebsites.net/.bot/v3/directline/tokens/generate.

For an example that shows how to fetch a token see Web Chat Samples.

<!DOCTYPE html>
<html lang="en-US">
  <head>
    <title>Web Chat</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <script
      crossorigin="anonymous"
      src="https://cdn.botframework.com/botframework-webchat/latest/webchat-minimal.js"
    ></script>
    <style>
      html,
      body {
        background-color: #f7f7f7;
        height: 100%;
      }

      body {
        margin: 0;
      }

      #webchat {
        box-shadow: 0 0 10px rgba(0, 0, 0, 0.05);
        height: 100%;
        margin: auto;
        max-width: 480px;
        min-width: 360px;
      }
    </style>
  </head>
  <body>
    <div id="webchat" role="main"></div>
    <script>
      (async function() {
        <!-- NOTE: It is highly recommended to replace the below fetch with a call to your own token service as described in step 2 above, and to avoid exposing your channel secret in client side code. -->
        const res = await fetch('https://<your_app_service>.azurewebsites.net/.bot/v3/directline/tokens/generate', { method: 'POST', headers:{'Authorization':'Bearer ' + '<Your Bot's Direct Line channel secret>'}});
        const { token } = await res.json();

        window.WebChat.renderWebChat(
          {
            directLine: await window.WebChat.createDirectLineAppServiceExtension({
              domain: 'https://<your_app_service>.azurewebsites.net/.bot/v3/directline',
              token
            })
          },
          document.getElementById('webchat')
        );

        document.querySelector('#webchat > *').focus();
      })().catch(err => console.error(err));
    </script>
  </body>
</html>

In the JavaScript bot implementation, make sure that WebSockets are enabled in the web.config file, as shown below.

<configuration>
    <system.webServer>
        <webSocket enabled="true"/>
        ...
    </system.webServer>
</configuration>

Troubleshooting

In this GitHub Repo i have integrated the SeriLog so that any issue you face after implementing this you can see the logs in log stream in app service by following this article:

https://lkgforit.com/troubleshooting-by-writing-logs-at-the-application-start-for-net-core-app-using-serilog-14a1914701af

Thanks.

Microsoft Loop New Product in Office 365 - Looks stunning

Sanjeevi Subramani — Wed, 29 Dec 2021 09:19:28 +0000

Introducing Microsoft Loop

Think, plan, and create - together

https://www.microsoft.com/en-us/microsoft-loop?ms.url=microsoftcommicrosoft-loop

Microsoft Loop is a new app that combines a powerful and flexible canvas with portable components that stay in sync and move freely across Microsoft 365 apps.

https://youtu.be/BkhaV46HM2E

Work together, even when youre apart

Cocreate, build on each others ideas, and add a little personality. Loop is an entirely new way to work togetherdesigned for the hybrid world.

See everything in one place

Organize what you need for your project, such as files, links, and data from other apps, in a single workspace. Work in chat, meetings, or documents using portable components that are always up to date.

Stay in sync and on track

Jump in, catch up, and get going with Loop. Connect naturally with emojis and expressions. Easily collaborate and track progress with notifications, highlighted changes, status labels, and task lists.

Microsoft Loop meets you where you are

Loop components

Collaborate in the flow of work with Loop components. Work together on lists, tables, notes, or even a customer sales opportunity from Dynamics 365 on a Loop page or in a chat, email, meeting, or document. Loop components in Microsoft 365 apps are rolling out now.

Implementing Middleware in Bot Framework Composer

Sanjeevi Subramani — Tue, 28 Dec 2021 12:33:57 +0000

Implementing Middleware in Bot Framework Composer

https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-concept-middleware?view=azure-bot-service-4.0

Handling state in middleware

A common method to save state is to call the save changes method at the end of the turn handler. Here is a diagram with a focus on the call.

The problem with this approach is that any state updates made from some custom middleware that happens after the bot's turn handler has returned will not be saved to durable storage. The solution is to move the call to the save changes method to after the custom middleware has completed by adding an instance of the auto-save changes middleware to the beginning of the middleware stack, or at least before any of the middleware that might update state. The execution is shown below.

Add the state management objects that will need updating to a bot state set object, and then use that when you create your auto-save changes middleware.

Creating Middleware for Composer Bot

Create a class file
Inherit this interface - Microsoft.Bot.Builder.IMiddleware
Implement OnTurnAsync Method like below code sample
You will have access to context, Activity and other stuffs you do in bot framework library implementations
To Access config values use this config_val.AppsettingKeyName
To Access user Activity use context.Activity
To Access user message use context.Activity.Text
To Access config values use this config_val.AppsettingKeyName if the appsettings json file contains the key name as 'AppsettingKeyName'


    public class SampleMiddleware : Microsoft.Bot.Builder.IMiddleware
    {
        private readonly IConfiguration config_val;

        public SampleMiddleware (IConfiguration iconfig)
        {
            config_val = iconfig;
        }

        public virtual async Task OnTurnAsync(ITurnContext context, NextDelegate nextTurn, CancellationToken cancellationToken)
        {
            // Condition to filter based on message or event
            if (context.Activity.Type == "message")
            {
                    var userText = context.Activity.Text;
                    // Do some stuff here with Activity or user input text

                    // To Access config values use this 
                    config_val.AppsettingKeyName

                    // use below code if you want to run the default flow happens remove below code if / 
                    //you don't want to trigger bot action and end the turn.
                    await nextTurn(cancellationToken).ConfigureAwait(false);
            }
        }
   }

Initiate the Middleware in Startup of Composer Bot

Initialize the middleware in the startup.cs file inside the ConfigureServices method like below code snippet.


        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers().AddNewtonsoftJson();
            services.AddBotRuntime(Configuration);

            //code to initialize middleware
            services.AddSingleton<IMiddleware, SampleMiddleware>();
        }

Thanks Happy Coding :)

Create custom actions in Bot Framework Composer

Sanjeevi Subramani — Fri, 24 Dec 2021 08:15:35 +0000

Create custom actions

In Bot Framework Composer, actions are the main contents of a trigger. Composer provides different types of actions, such as Send a response, Ask a question, and Create a condition. Besides these built-in actions, additional actions can be added through packages or by creating components that includes custom actions.

This article explains how to create a custom action that multiplies two inputs together.

Setup the component project

To create a custom action (or any component), first setup a new project, and add the necessary package dependencies for working with adaptive dialogs and the Bot Framework SDK.

Locate the .sln file for the bot, and open it in an editor (like Visual Studio or Visual Studio Code).
Add a new project named MultiplyDialog to your solution. In Visual Studio right-click on the solution in the Solution Explorer and select Add > New Project. Use the Class Library project template.
Add a reference to the Microsoft.Bot.Builder.Adaptive.Runtime package. Use the same version as the bot depends on.

<PackageReference Include="Microsoft.Bot.Builder.Dialogs.Adaptive.Runtime" Version="4.13.1" />
Add a project reference from the bot project to the component project. Right-click on the <myBot> project and select Add > Project Reference. Choose the MultiplyDialog project and click OK.

Build the entire solution to restore all packages and validate the dependency tree.

Create the custom action

Actions in Composer are special implementations of the Dialog base class. This allows each action in the trigger to be pushed onto the dialog stack, and executed in turn.

In the new project, rename the Class1.cs file to MultiplyDialog.cs, and update it's contents to look like the below:

using System;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using AdaptiveExpressions.Properties;
using Microsoft.Bot.Builder.Dialogs;
using Newtonsoft.Json;

public class MultiplyDialog : Dialog
{
    [JsonConstructor]
    public MultiplyDialog([CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
        : base()
    {
        // enable instances of this command as debug break point
        RegisterSourceLocation(sourceFilePath, sourceLineNumber);
    }

    [JsonProperty("$kind")]
    public const string Kind = "MultiplyDialog";

    [JsonProperty("arg1")]
    public NumberExpression Arg1 { get; set; }

    [JsonProperty("arg2")]
    public NumberExpression Arg2 { get; set; }

    [JsonProperty("resultProperty")]
    public StringExpression ResultProperty { get; set; }

    public override Task<DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
    {
        var arg1 = Arg1.GetValue(dc.State);
        var arg2 = Arg2.GetValue(dc.State);

        var result = Convert.ToInt32(arg1) * Convert.ToInt32(arg2);
        if (this.ResultProperty != null)
        {
            dc.State.SetValue(this.ResultProperty.GetValue(dc.State), result);
        }

        return dc.EndDialogAsync(result: result, cancellationToken: cancellationToken);
    }
}

Create the schema file

The .schema file for the component is a partial schema that will be merged into the main .schema file for the bot. Although it is possible to edit the main sdk.schema file for the bot directly, doing so is not recommended. Merging partial schema files will isolate changes, allow for easier recovery from errors, and enable easier packaging of your component for reuse.

Create a new file in the project named MultiplyDialog.schema and update the contents to the below:

{
    "$schema": "https://schemas.botframework.com/schemas/component/v1.0/component.schema",
    "$role": "implements(Microsoft.IDialog)",
    "title": "Multiply",
    "description": "This will return the result of arg1*arg2",
    "type": "object",
    "additionalProperties": false,
    "properties": {
        "arg1": {
            "$ref": "schema:#/definitions/integerExpression",
            "title": "Arg1",
            "description": "Value from callers memory to use as arg 1"
        },
        "arg2": {
            "$ref": "schema:#/definitions/integerExpression",
            "title": "Arg2",
            "description": "Value from callers memory to use as arg 2"
        },
        "resultProperty": {
            "$ref": "schema:#/definitions/stringExpression",
            "title": "Result",
            "description": "Value from callers memory to store the result"
        }
    }
}

Create the BotComponent class

The adaptive runtime will dynamically discover and inject components at startup time.

Create a new MultiplyDialogBotComponent.cs file in the project and update the contents to

using Microsoft.Bot.Builder;
using Microsoft.Bot.Builder.Dialogs.Declarative;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

public class MultiplyDialogBotComponent : BotComponent
{
     public override void ConfigureServices(IServiceCollection services, IConfiguration configuration)
     {
         // Anything that could be done in Startup.ConfigureServices can be done here.
         // In this case, the MultiplyDialog needs to be added as a new DeclarativeType.
         services.AddSingleton<DeclarativeType>(sp => new DeclarativeType<MultiplyDialog>(MultiplyDialog.Kind));
     }
}

In the appsettings.json file of the bot project (located at \settings)to include the MultiplyDialogBotComponent in the runtimeSettings/components array.

"runtimeSettings": {
   "components": [
      {
         "name": "MultiplyDialog"
      }
   ]
}

Build the entire solution to validate everything was added correctly.

Merge schema files

The final step is to merge the partial schema file from the MultiplyDialog project into the main sdk.schema file for the bot. This makes the custom action available for use in Composer.

Navigate to the schemas folder in the myBot project. This folder contains a PowerShell script and a bash script. Use an elevated PowerShell terminal to execute the PowerShell script. You will need to either copy/paste the contents of the script, or ensure your execution-policy allows for running unsigned scripts.
To validate the script executed successfully, search for MultiplyDialog inside the MyBot\schemas\sdk.schema file and validate that the partial schema from the MultiplyDialog.schema file is included in sdk.schema.

Test

Open the bot project in Composer to test the added custom action. If the project is already loaded, return to Home in Composer, and reload the project.

Open the bot in Composer. Select a trigger add the custom action to.
Select + under the trigger node to see the actions menu. Then choose Custom Actions > Multiply.
On the Properties panel on the right side, enter two numbers in the argument fields: Arg1 and Arg2. Enter "dialog.result" in the Result property field.
Add a Send a response action. Enter "The result is: ${dialog.result}" in the Language Generation editor.
Select Start Bot to test the bot in Web Chat. When triggered, the bot will respond with the test result entered in the previous step.

How to pass Appsettings settings to Custom Action

You can just use the settings scope memory. for example "settings.yourSettings". Please refer to the custom action sample:

StringExpression yourSettings = "settings.yoursettings"
var yourSettingsValue = yourSettings.GetValue(dc.State);

If you sent an multi element json element as collection you can send while passing in parameter:

json(settings.yourSettings)

In Appsettings


  "yourSettings": {
    "value1": true
}

In custom Action

[JsonProperty("appSettings")]
public ValueExpression AppSettings { get; set; }

dynamic appSettings = AppSettings.GetValue(dc.State);

var yourAppsettings = appSettings["yourSettings"]

var value1 = appSettings["yourSettings"]["value1"]

Power BI Report on Bot Analytics for Chatbot in Bot Framework Composer

Sanjeevi Subramani — Wed, 15 Dec 2021 10:34:55 +0000

Tutorial: View analytics with Power BI

Intro

Purpose

The BOT framework Composer sample provides a Power BI template that can be used to understand how your bot is performing.

Overall usage

Personalize your experience for your brand and customers.

All dialogs overview

All dialogs' popularity and status based off of SDK telemetry

Dialog overview

Review a specific dialog's popularity and status

LUIS intents

A count of LUIS intents per day

All conversation metrics

Highlights the average number of conversations per unique user and the average duration by day

Conversations drill down

Per conversation, this highlights the dialogs triggered and common utterances

Transcript

Review interactions, sessions, and the transcript between a bot and its users

Demographics

See where users are connecting to your bot

Word Cloud

Commonly user queries

Sentiment analysis

Average user sentiment results provided by LUIS

QnA Maker insights

Insights on matched user queries with QnA Maker

User feedback

Insights on user submitted feedback

Prerequisites

Install Power BI Desktop
Download the Bot Composer analytics Power BI template
Create a Bot in Composer to deploy your Azure resources

Time To Complete

10 minutes

Scenario

A Power BI dashboard showing Application Insights telemetry captured from a Bot Composer BOT.

Tutorial: View analytics with Power BI

Get your Application Insights Application ID

Log in to the Azure Portal.
Navigate to the Application Insights resource created.
In the sidebar, navigate to Configure > API Access on the sidebar.
Copy the Application ID for the next step.

Tutorial: View analytics with Power BI

Open the Power BI template

Open the Bot Composer analytics template and paste your Application Insights Application ID.
After loading the tables with your populated data, you should now see insights from your Virtual Assistant.

Note: You may run into authentication issues when opening the template, particularly if you have opened the template previously using another Application ID. If so, perform the following steps to re-authenticate the template with your Application Insights service:

Open the Template
File > Options and Settings > Data Source Settings
Click "Global permissions"
Click on anything resembling "api.logalytics.io" and Clear Permissions > Clear Permissions > Delete
Close and Re-open the Template
Paste your Application Insights AppId
Click Load
Important: Select Organizational Account > Sign In > Connect

Additional Telemetry

By default, a Bot composer Bot based project collects personally identifiable information (e.g. Conversation drill-down and transcripts) which will lead to the respective sections in the PowerBI dashboard to function as expected. If you wish to not collect this information make the changes to appsettings.json by following this article: https://docs.microsoft.com/en-us/composer/how-to-capture-telemetry?tabs=v2x#configure-telemetry

Raised a PR to Bot Framework Composer: https://github.com/microsoft/BotFramework-Composer/pull/8641

Enterprise Application Development with C# 9 and .NET 5: Enhance your C# and .NET skills by mastering the process of...

Sanjeevi Subramani — Fri, 10 Dec 2021 14:23:23 +0000

Key Features

Explore the advanced features of C# and .NET 5 to enhance your code and productivity Follow clear and easy instructions for building an end-to-end enterprise application Learn how to build scalable web applications and host them on the cloud

Book Description

.NET Core is one of the most popular programming platforms in the world for an increasingly large community of developers thanks to its excellent cross-platform support. This book will show you how to confidently use the features of .NET 5 with C# 9 to build robust enterprise applications.

Throughout the book, you'll work on creating an enterprise app and adding a key component to the app with each chapter, before nally getting it ready for testing and deployment. You'll learn concepts relating to advanced data structures, the Entity Framework Core, parallel programming, and dependency injection. As you progress, you'll cover various authentication and authorization schemes provided by .NET Core to make your apps and APIs secure. Next, you'll build web apps using ASP.NET Core 5 and deploy them on the cloud while working with various cloud components using Azure. The book then shows you how to use the latest Microsoft Visual Studio 2019 and C# 9 to simplify developer tasks, and also explores tips and tricks in Visual Studio 2019 to improve your productivity. Later, you'll discover various testing techniques such as unit testing and performance testing as well as dierent methods to deploy enterprise apps.

By the end of this book, youll be able to create enterprise apps using the powerful features of .NET 5 and deploy them on the cloud.

What you will learn

Design enterprise apps by making the most of the latest features of .NET 5 Discover dierent layers of an app, such as the data layer, API layer, and web layer Explore end-to-end architecture, implement an enterprise web app using .NET and C# 9, and deploy the app on Azure Focus on the core concepts of web application development such as dependency injection, caching, logging, conguration, and authentication, and implement them in .NET 5 Integrate the new .NET 5 health and performance check APIs with your app Understand how .NET 5 works and contribute to the .NET 5 platform

Who this book is for

If you are a developer, architect, or senior programmer who wants to leverage the features of .NET 5 and the C# language, as well as grasp essential techniques to build your skills, then this C# .NET 5 book is for you. Beginner to intermediate-level knowledge of the .NET framework and C# programming is required to understand the concepts covered in this book more effectively.

Designing and Architecting the Enterprise Application
Introducing .NET 5 Core and Standard
Introducing C# 9
Threading and Asynchronous Operations
Dependency Injection in .NET
Configuration in .NET Core
Logging in .NET 5
Understanding Caching
Working with Data in .NET 5
Creating an ASP.NET Core 5 Web API
Creating an ASP.NET Core 5 Web Application
Understanding Authentication
Understanding Authorization
Health and Diagnostics
Testing
Deploying the Application in Azure

Buy Here

https://packt.link/821x8

https://packt.link/SUSXs

Authors

https://www.amazon.com/Ravindra-Akella/e/B08T97LYCV/ref=dp_byline_cont_book_1

https://www.amazon.com/Arun-Kumar-Tamirisa/e/B08X4ZWZLR/ref=dp_byline_cont_book_2

https://www.amazon.com/Suneel-Kumar-Kunani/e/B08TCHBP9J/ref=dp_byline_cont_book_3

Generate Adaptive Card for Bot Framework UI using C#

Sanjeevi Subramani — Sun, 05 Dec 2021 15:21:07 +0000

Getting Started

An Adaptive Card is a JSON-serialized card object model.

Adaptive Card structure

The basic structure of a card is as follows:

AdaptiveCard - The root object describes the AdaptiveCard itself, including its element makeup, its actions, how it should be spoken, and the schema version required to render it.
body - The body of the card is made up of building-blocks known as elements. Elements can be composed in nearly infinite arrangements to create many types of cards.
actions - Many cards have a set of actions a user may take on it. This property describes those actions which typically get rendered in an "action bar" at the bottom.

Example Card

This sample card which includes a single line of text followed by an image.

{
    "type": "AdaptiveCard",
    "version": "1.0",
    "body": [
        {
            "type": "TextBlock",
            "text": "Here is a ninja cat"
        },
        {
            "type": "Image",
            "url": "http://adaptivecards.io/content/cats/1.png"
        }
    ]
}

`Type` property

Every element has a type property which identifies what kind of object it is. Looking at the above card, you can see we have two elements, a TextBlock and an Image.

All Adaptive Card elements stack vertically and expand to the width of their parent (think display: block in HTML). However, you can use a ColumnSet to create side-by-side columns of containers.

Adaptive Elements

The most fundamental elements are:

TextBlock - adds a block of text with properties to control what the text looks like
Image - adds an image with properties to control what the image looks like

Container elements

Cards can also have containers, which arrange a collection of child elements.

Container - Defines a a collection of elements
ColumnSet/Column - Defines a collection of columns, each column is a container
FactSet - Container of Facts
ImageSet - Container of Images so that UI can show appropriate photo gallery experience for a collection of images.

Input elements

Input elements allow you to ask for native UI to build simple forms:

Input.Text - get text content from the user
Input.Date - get a Date from the user
Input.Time - get a Time from the user
Input.Number - get a Number from the user
Input.ChoiceSet - Give the user a set of choices and have them pick
Input.Toggle - Give the user a single choice between two items and have them pick

Actions

Actions add buttons to the card. These can perform a variety of actions, like opening a URL or submitting some data.

Action.OpenUrl - the button opens an external URL for viewing
Action.ShowCard - Requests a sub-card to be shown to the user.
Action.Submit - Ask for all of the input elements to be gathered up into an object which is then sent to you through some method defined by the host application.

Example Action.Submit : With Skype, an Action.Submit will send a Bot Framework bot activity back to the bot with the Value property containing an object with all of the input data on it.

For more details look at

https://adaptivecards.io

Sample Adaptive Card in C Sharp

We have Adaptive card library in Nuget which we can use for this purpose.

Let's see the code how it looks:

    public static AdaptiveCard GenerateAdaptivePromptCard(List<Item> listOfOptions)
    {
        List<AdaptiveChoice> categoryChoices = new List<AdaptiveChoice>();
        foreach (var item in listOfOptions)
        {
            categoryChoices.Add(new AdaptiveChoice
            {
                Title = item.Label,
                Value = item.Value,
            });
        }

        var columns = new AdaptiveColumn
        {
            Separator = true,
        };
        columns.Items.Add(new AdaptiveTextBlock
        {
            Text = "text",
            Wrap = true,
            Weight = AdaptiveTextWeight.Bolder,
            Size = AdaptiveTextSize.Large,
        });
        columns.Items.Add(new AdaptiveTextBlock
        {
            Text = "reprompt message",
            Wrap = true,
            Weight = AdaptiveTextWeight.Lighter,
            Size = AdaptiveTextSize.Default,
        });

        columns.Items.Add(new AdaptiveTextBlock
        {
            Text = "text block message",
            Wrap = true,
        });
        columns.Items.Add(new AdaptiveChoiceSetInput
        {
            Id = "12432",
            Style = AdaptiveChoiceInputStyle.Compact,
            IsMultiSelect = false,
            Choices = categoryChoices,
            Value = categoryId,
        });
        columns.Items.Add(new AdaptiveTextInput
        {
            Id = "234324",
            Value = "test",
            IsRequired = true,
        });
        columns.Items.Add(new AdaptiveTextInput
        {
            Id = DescriptionLabel,
            Value = "value",
            IsMultiline = true,
            IsRequired = true,
            Height = AdaptiveHeight.Stretch,
        });

        var columnSet = new AdaptiveColumnSet();
        columnSet.Columns.Add(columns);

        var container = new AdaptiveContainer();
        container.Style = AdaptiveContainerStyle.Emphasis;
        container.Items.Add(columnSet);

        var mainCard = new AdaptiveCard(new AdaptiveSchemaVersion(1, 0));
        mainCard.Body.Add(container);

        mainCard.Actions.Add(new AdaptiveSubmitAction
        {
            Title = "sample submit action",
        });

        return mainCard;
    }

Here i have used the following classes and properties from the NuGet library to generate and customize them.

AdaptiveChoice
AdaptiveColumn
AdaptiveTextBlock
AdaptiveTextWeight
AdaptiveTextSize
AdaptiveChoiceInputStyle
AdaptiveChoiceSetInput
AdaptiveTextInput
AdaptiveHeight
AdaptiveColumnSet
AdaptiveContainer
AdaptiveContainerStyle
AdaptiveSubmitAction
AdaptiveSchemaVersion

Like the above code we can customize the Adaptive Card in C#.

Thanks.

DEV Community: Sanjeevi Subramani

Low Level Design GitHub Materials

𝟏) 𝐓𝐇𝐄 𝐋𝐋𝐃

Low level Design / Machine Coding Question Collections

What is Machine Coding Round ?

What is the purpose behind this LLD repo ?

What is target Audience, do all companies ask ?

Below are the list of LLD problem which are asked during my machine coding rounds from tech companies and the resources I collected.

Note : page is under construction, you can click on the individual packages to view all the questions and solutions.

Frequently asked Problems

Contribute

𝟐) 𝐋𝐎𝐖-𝐋𝐄𝐕𝐄𝐋 𝐃𝐄𝐒𝐈𝐆𝐍 𝐏𝐑𝐈𝐌𝐄𝐑

low-level-design-primer

Motivation

Learn to design low level system

Resources

Under development

Credits

License

𝟑)𝐀𝐰𝐞𝐬𝐨𝐦𝐞 𝐒𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 𝐈𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰

Awesome Software Engineering Interview

Motivation

Content

Under development

Contributing

Contact info

License

𝟒)𝐂𝐚𝐜𝐡𝐞 𝐋𝐨𝐰 𝐋𝐞𝐯𝐞𝐥 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧

Cache - Low level system design

Video explanation

Problem statement

𝟓)𝐂𝐡𝐞𝐬𝐬 𝐋𝐨𝐰-𝐋𝐞𝐯𝐞𝐥 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧

Chess - Low level system design

Video Explanation

Problem Statements

Further enhancements

𝟔)𝐓𝐡𝐞 𝐒𝐲𝐬𝐭𝐞𝐦 𝐃𝐞𝐬𝐢𝐠𝐧

System Design:

Introduction:

What is system?

What is design?

Components of System Design:

Client Server Architecture:

- Load balancer: responsible for distributing incoming network traffic across a group of backend servers to optimize resource usage.

A typical topological data flow goes as follows:

- Example: Gaming apps, video editing software.

Tier based architecture:

Proxies:

Types of proxy:

Data and Data Flow:

Different formats of data (representation):

- 0s and 1s.

Data Generation:

- Insights

Data Flow Methods:

- Events.

Factors to be considered:

- Security

Types of System (Examples):

Databases:

Types of databases:

Anatomy of applications and services:

Application Programming Interface (API):

Caching:

MESSAGE QUEUE:

Performance Metrics (used to evaluate how good the system is performing):

Throughput

Bandwidth

Latency

Response Time

EXAMPLES (analogies):

Performance metrics of different components:

Applications:

Databases:

Caches:

Message Queues:

Workers:

Server instances:

Fault v/s Failure:

Scaling: