Whether you’re preparing for interviews or brushing up on concepts, here’s a curated list of the most commonly asked questions in .NET Full Stack roles:

🔹 .𝗡𝗘𝗧 / 𝗖# 𝗖𝗼𝗿𝗲 𝗖𝗼𝗻𝗰𝗲𝗽𝘁𝘀
1️⃣ .NET Framework vs .NET Core vs .NET 5/6/7
2️⃣ CLR, CTS, CLS
3️⃣ Value Types vs Reference Types
4️⃣ Boxing & Unboxing
5️⃣ async/await, Task vs ValueTask vs IAsyncEnumerable
6️⃣ Delegates, Func, Action, Predicate
7️⃣ Abstract Class vs Interface
8️⃣ Dependency Injection (DI) in .NET Core
9️⃣ Generics in C# (benefits)
🔟 IEnumerable vs IQueryable vs ICollection vs List

🔹 𝗔𝗦𝗣.𝗡𝗘𝗧 𝗠𝗩𝗖 / 𝗪𝗲𝗯 𝗔𝗣𝗜
1️⃣ Controller vs ControllerBase
2️⃣ Action Filters, Result Filters, Exception Filters
3️⃣ TempData vs ViewData vs ViewBag
4️⃣ Routing in MVC vs .NET Core
5️⃣ Model Binding & Validation
6️⃣ Middleware in ASP.NET Core
7️⃣ Authentication vs Authorization
8️⃣ JWT Authentication & Authorization Flow
9️⃣ Caching (In-Memory, Distributed, Redis)
🔟 API Versioning strategies

🔹 𝗘𝗻𝘁𝗶𝘁𝘆 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 𝗖𝗼𝗿𝗲
1️⃣ What is DbContext?
2️⃣ Code-First vs Database-First
3️⃣ EF Core Migrations
4️⃣ Eager vs Lazy vs Explicit Loading
5️⃣ Change Tracking
6️⃣ AsNoTracking() vs Tracking Queries
7️⃣ EF Core Transactions
8️⃣ Concurrency Handling in EF Core

🔹 𝗦𝗤𝗟 𝗦𝗲𝗿𝘃𝗲𝗿
1️⃣ ACID Properties of a Transaction
2️⃣ Clustered vs Non-Clustered Index
3️⃣ Stored Procedure vs Function
4️⃣ Inner Join vs Left Join vs Right Join vs Cross Join
5️⃣ Common Table Expression (CTE)
6️⃣ Indexes & Performance
7️⃣ Normalization vs Denormalization
8️⃣ Transactions & Isolation Levels
9️⃣ SQL Query Optimization
🔟 Deadlock & Handling

🔹 𝗔𝗻𝗴𝘂𝗹𝗮𝗿
1️⃣ AngularJS vs Angular
2️⃣ Components, Directives, Modules, Services
3️⃣ Data Binding (Interpolation, Property, Event, Two-way)
4️⃣ ngIf vs hidden
5️⃣ Dependency Injection in Angular
6️⃣ RxJS (Observable, Subject, BehaviorSubject)
7️⃣ Routing & Route Guards (AuthGuard, CanActivate, CanDeactivate)
8️⃣ Pipes: Pure vs Impure
9️⃣ Change Detection in Angular
🔟 Template-driven Forms vs Reactive Forms

💡 These questions are repeatedly asked across interviews for .NET Full Stack Developer roles.
👉 Save this list for revision.
👉 Share with someone who’s preparing for interviews.

It’s a design approach where the system’s behavior, UI, or logic is not hard-coded but instead comes from metadata (data about data) stored in configuration tables, files, or services.

👉 Instead of developers writing new code for every form, workflow, or report, the system reads metadata to know:

• What fields to show
• What types of inputs (textbox, dropdown, checkbox)
• Which validations to apply
• Which database table/column to bind
• Which workflows to follow

So the application is driven by configuration (metadata), not by rigid code.

🔹 Example

Imagine a system for registering customers.

• Hardcoded way: You write a form with Name, Age, Email fields in code.
• Metadata-driven way: A metadata table says:

The UI engine reads this table and automatically generates the form with correct fields, validations, and database binding.

If tomorrow you want to add Phone Number → just insert a row into the metadata table.
✅ No need to redeploy code.
✅ The UI + validation + DB save all work automatically.

🔹 Where It’s Used

• Low-code / No-code platforms (e.g., PowerApps, Mendix)
• Enterprise applications (ERP, CRM, HRMS)
• Form builders
• Workflow engines

🔹 Benefits

• 🚀 Flexibility — Change behavior without code changes.
• 🛠 Reusability — Same engine works for many screens.
• 📈 Faster delivery — Add fields/workflows quickly.
• 👨‍💼 Business empowerment — Non-developers can configure system.

🔹 Challenges

• 🧩 Complexity — You need a solid metadata model, otherwise it becomes confusing.
• 🐌 Performance — Reading metadata dynamically can slow down execution.
• 🔍 Debugging — Errors may be harder to trace because logic comes from config, not code.
• 📖 Learning curve — Developers must understand metadata structure well.

🔹 Real-World Example

Think of Salesforce:

• You don’t code every new field in CRM.
• You go to setup → add a field → instantly shows in UI, validates, saves to DB.
• That’s metadata-driven at scale.

👉 So in short:
Metadata-driven architecture shifts application logic from code to data, making systems more flexible, configurable, and faster to evolve.

အသုံးပြုရတာလွယ်ကူဖို့ နှင့် မြန်ဆန်ဖို့က အရေးကြီးတဲ့အပိုင်းမှာ ရှိနေတယ်

Redis ကိုသုံးရတဲ့ ရည်ရွယ်ချက်က လဲ အဲ့ထဲက အချက်တချက်ဖြစ်တဲ့ မြန်ဆန်ဖို့ဘဲ ဖြစ်ပါတယ်

ကျွန်တော်တို့မှာ ရှာချင်တဲ့အချက်တဲ့အချက်လက်တွေကများနေတယ် ဆိုပါစို့

တူညီတဲ့အချက်အလက်တွေကို ခနခန ရှာနေမယ်ဆိုရင် မလိုအပ်ဘဲ data တွေအများကြီးခေါ်နေတဲ့အတွက် ကျွန်တော်တို့ရဲ့ server က လေး လာနိုင်ပါတယ်

အဲ့လို တူညီတဲ့ အချက်အလက်တွေကို ခနခန ခေါ်နေပေမဲ့ ထပ်ခါထပ်ခါ database ထဲက data ကိုဆွဲမထုတ်ချင်ရင် cache တခု အနေနဲ့ပထမ တခါခေါ်ပီးသားကို သိမ်းထားပီး နောက်တခါ အဲ့တာကို ဘဲ ပြန်ခေါ်ရင် database ထဲကနေ ဆွဲမထုတ်ဘဲနဲ့ cache ကို ဆွဲထုတ်ပြလိုက်ရင် ကျွန်တော်တို့ရဲ့ server load က ကျသွားနိုင်မည်

အဲ့လိုသုံးချင်ရင် Eg အနေနဲ့ Redis ကို asp.net core web api နဲ့ ဘယ်လိုသုံးလဲ ဆိုတာကို အောက်ပါ တဆင့်ချင်းစီ လေ့လာနိုင်ပါတယ်

Step 1 : download and install Redis for window

Step 2 : run redis.exe. If so will display CMD with port 6379

Step 3 : install require package for asp.net core web api like below

dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package StackExchange.Redis

အပေါ်က ဟာတွေ ပီးပီဆိုရင် အောက် မှာ တဆင့်ချင်းစီကို ဆက်လုပ်ပေးပါ

အရင်ဆုံး appsetting ထဲမှာ “RedisURL”: “127.0.0.1:6379” ကိုထည့်ပါ

အတိုချုံးအနေနဲ့ ပြောရရင် သူ့မှာ သုံးခုရှိတယ်

1. cache ကို ရှာမည်

getCache()

2.မရှိရင် သိမ်းမည်

setCache(data, cacheData, expiredTime)

3. data အသစ် (သို့မဟုတ်) update ရိုက်ရင် removeCache လုပ်မည်

Logging provides a persistent record of what happened, which is crucial for debugging, monitoring and auditing.

Real-World Example: E-Commerce Payment System

Imagine you’re building an e-commerce platform, and a customer tries to make a payment. The payment process involves multiple steps:

1. Validate the payment details.
2. Save the transaction to the database.
3. Update the order status to “Paid.”

If something goes wrong during this process, you need to:

• Inform the user (via an exception).
• Log the error for later analysis.

Plan => planning what should we do for project

Define => define actual information

Analyze => analyzing the process is usable or not

Development Process => start development process

Testing => testing with api testing tools like postman

Deploy => publish and deploy project into the network

I am sharing some Important Angular Interview questions.

1. What are the key components of Angular?
2. Please explain the Life Cycle Hooks in Angular.
3. What is the use of Constructor in Angular?
4. What is Metadata in Angular?
5. What is Dependency injection in Angular?
6. What is pipe and how many pipes are there in Angular?
7. Please explain the difference between Pure pipe and Impure pipe in Angular.
8. How do you append tokens to each HTTP request?
9. What is the type of compiler in Angular?
10. How do you add Dynamic Script to Angular?
11. What are the class decorators in Angular?
12. What is the Subject in Angular and What type of it?
13. How many Types of validators in Angular?
14. What are the types of Injector hirarchy in Angular?
15. In which scenario change detection works?
16. What is Interceptor in Angular?
17. Types of data binding in Angular?
18. What is Lazy loading in Angular?
19. What is wild card routes?
20. What is directives in angular and how many types of it?
21. What is EventEmitter in Angular?
22. How to share data between parent and child components in Angular?
23. What is the use of Double Exclamation(!!)?
24. What is Angular material?
25. How to improve performance in Angular Application?

Imagine you are going to watch a movie at a theater. The lifecycle of the movie-going experience can be compared to the lifecycle hooks in Angular. Here’s how:

ngOnChanges (Change Detection)

• Real World: You decide to go to the movies, but you change your mind about which movie to watch.
• Angular: This hook is called when any of the component’s input properties change. It helps Angular detect and respond to changes in data.

ngOnInit (Initialization)

• Real World: You arrive at the movie theater, buy your ticket, and find your seat. This is the start of your movie experience.
• Angular: This hook is called once when the component is initialized. It’s a good place to set up initial data or fetch information from a server. Think of it as setting everything up before the movie starts.

ngDoCheck (Custom Change Detection)

• Real World: During the movie, you check your phone or make sure you have your popcorn. You’re making sure everything is going smoothly during the movie.
• Angular: This hook is triggered when Angular runs change detection. You can use it to implement custom change detection logic, checking whether something has changed that Angular might not have detected on its own.

ngAfterContentInit (Content Initialization)

• Real World: The previews and trailers start before the main movie begins.
• Angular: This hook is called after Angular projects external content (like ng-content) into the component’s view for the first time.

ngAfterContentChecked (Content Check)

• Real World: During the previews, you might check if you like the upcoming movies or adjust your seat for better viewing.
• Angular: This hook runs after every check of the projected content, ensuring that the content displayed is as expected.

ngAfterViewInit (View Initialization)

• Real World: The movie finally starts, and you begin watching it.
• Angular: This hook is called after Angular has fully initialized the component’s view and its child views. It’s a good place to interact with or manipulate DOM elements.

1. ngAfterViewChecked (View Check)

• Real World: During the movie, you might glance around to make sure the sound is good, the screen is clear, and everything is in order.
• Angular: This hook is called after Angular checks the component’s view and its child views. You can use it to ensure that the view has been updated correctly.

ngOnDestroy (Cleanup)

• Real World: The movie ends, and you leave the theater, taking your belongings with you.
• Angular: This hook is called just before the component is destroyed. It’s a good place to clean up resources, unsubscribe from observables, or detach event listeners.

In Code

Here is an example of how these lifecycle hooks might look in an Angular component:

In UTF-8:

• Common characters (e.g., English letters) use only 1 byte.
• Less common characters (e.g., special symbols or characters from other languages) may use 2, 3, or 4 bytes.

Why Use UTF-8?

1. Compatibility: UTF-8 is backward-compatible with ASCII, so any ASCII text is also valid UTF-8. This makes it easy to work with English text and other basic symbols without extra overhead.
2. Universal: It supports all characters, so you can work with text in any language (e.g., Chinese, Arabic, emojis).
3. Efficiency: For common characters, it uses only 1 byte, saving space compared to other encodings like UTF-16.

when i want to sent data to server, need to change from text to utf8

string text= “Hello”;

var utf8Example = Encoding.UTF8.GetBytes(text)

Result : 72 101 108 108 111

Here, each byte corresponds to the ASCII value of the characters "H", "e", "l", "l", "o"

Why Use UTF-8 in Web APIs?

When you send or receive text data in web applications, you often work with various languages and symbols. Using UTF-8 ensures that the text is encoded in a way that supports all characters and symbols, making it ideal for JSON data in HTTP requests.

For example, in this code snippet:

var data = new StringContent(json, Encoding.UTF8, “application/json”);

• Encoding.UTF8 ensures that the JSON string can include any character (e.g., special symbols, non-English characters) without issues.
• If you had text with special characters like "name": "José" or "greeting": "你好", UTF-8 encoding would correctly handle them.

Key Takeaway:

UTF-8 is a flexible and efficient encoding standard that allows your application to work with text from any language or symbol set, making it the best choice for modern web applications.

builder.Services.AddControllers()

.AddJsonOptions(opt =>

{

opt.JsonSerializerOptions.ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.IgnoreCycles;

});