People Who Code

check UserExistsParallel Parallel Checks (Faster)

async function checkUserExistsParallel(email, phone) {

try {

const checks = [];

if (email) {

checks.push(

getDocs(query(

collection(db, 'users'),

where('email', '==', email),

limit(1)

))

);

}

if (phone) {

checks.push(

getDocs(query(

collection(db, 'users'),

where('phone', '==', phone),

limit(1)

))

);

}

const snapshots = await Promise.all(checks);

const results = {

exists: snapshots.some(snap => !snap.empty),

byEmail: email ? !snapshots[0].empty : false,

byPhone: phone ? !snapshots[email ? 1 : 0].empty : false

};

return results;

} catch (error) {

console.error("Error checking user existence:", error);

return { exists: false, byEmail: false, byPhone: false, error: error.message };

}

Check checkUserExists Both and Return All Matches Angular

async function checkUserExists(email, phone) {

try {

const results = { exists: false, byEmail: false, byPhone: false };

// Check by email if provided

if (email) {

const emailQuery = query(

collection(db, 'users'),

where('email', '==', email),

limit(1)

);

const emailSnapshot = await getDocs(emailQuery);

if (!emailSnapshot.empty) {

results.exists = true;

results.byEmail = true;

}

// Check by phone if provided (always checks both)

if (phone) {

const phoneQuery = query(

collection(db, 'users'),

where('phone', '==', phone),

limit(1)

);

const phoneSnapshot = await getDocs(phoneQuery);

if (!phoneSnapshot.empty) {

results.exists = true;

results.byPhone = true;

}

return results;

} catch (error) {

console.error("Error checking user existence:", error);

return { exists: false, byEmail: false, byPhone: false, error: error.message };

}

// Usage

const result = await checkUserExists('test@example.com', '+1234567890');

console.log(result);

// Possible outputs:

// { exists: true, byEmail: true, byPhone: false } - email exists

// { exists: true, byEmail: false, byPhone: true } - phone exists

// { exists: true, byEmail: true, byPhone: true } - both exist

// { exists: false, byEmail: false, byPhone: false } - neither exists

Angular detected that HttpClient is not configured to use fetch APIs. It's strongly

NG02801: Angular detected that HttpClient is not configured to use fetch APIs. It's strongly recommended to enable fetch for applications that use Server-Side Rendering for better performance and compatibility. To enable fetch, add the withFetch() to the provideHttpClient() call at the root of the applicati

Solution:

import { NgModule } from '@angular/core';

import { BrowserModule } from '@angular/platform-browser';

import { HttpClientModule, provideHttpClient, withFetch } from '@angular/common/http';

import { AppComponent } from './app.component';

@NgModule({

declarations: [AppComponent],

imports: [BrowserModule, HttpClientModule],

providers: [

// Configure HttpClient to use fetch

provideHttpClient(withFetch()),

bootstrap: [AppComponent],

})

export class AppModule {}

IIS server training slash issue solution with example

This web.config file configures the behavior of a web application, specifically for a web server like IIS (Internet Information Services). It includes URL rewriting rules for handling URLs, file caching, and MIME type configurations. Here’s a breakdown of the configuration:

1. XML Declaration

xml

<?xml version="1.0" encoding="UTF-8"?>

This defines the XML version and encoding used in the file.

2. System Web Server Configuration

xml

<system.webServer>

This section contains settings related to the web server, such as URL rewriting and static content settings.

3. URL Rewrite Rules

The rules inside the <rewrite> tag are used to modify the URL requests before they reach the application. These rules handle common issues such as removing trailing slashes, redirecting, and serving the correct content.

Rule 1: Remove Trailing Slash

xml

<rule name="RemoveTrailingSlash" stopProcessing="true">
  <match url="(.*)/$" />
  <conditions>
    <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
    <add input="{REQUEST_FILENAME}/index.html" matchType="IsFile" negate="true" />
  </conditions>
  <action type="Redirect" redirectType="Permanent" url="{R:1}" />
</rule>

Purpose: This rule removes a trailing slash from URLs that do not point to directories or the index.html file.
Action: If the URL ends with a / but is not a directory or doesn't resolve to index.html, it will redirect to the same URL without the trailing slash.
Example: /about/ → /about

Rule 2: Rewrite Directory to `index.html`

xml

<rule name="RewriteDirectoryToIndexHtml" stopProcessing="true">
  <match url="^(.*)$" />
  <conditions>
    <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
    <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
    <add input="{REQUEST_FILENAME}/index.html" matchType="IsFile" />
  </conditions>
  <action type="Rewrite" url="{R:1}/index.html" />
</rule>

Purpose: This rule checks if a directory is requested, but there is no file or directory with that name. If the directory exists and contains an index.html, it rewrites the request to load the index.html file.
Example: /about/ → /about/index.html

Rule 3: Redirect to Clean URL (No Trailing Slash)

xml

<rule name="RedirectToCleanURL" stopProcessing="true">
  <match url="^(.*)$" />
  <conditions>
    <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
    <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
    <add input="{REQUEST_URI}" pattern="/$" negate="true" />
    <add input="{REQUEST_FILENAME}/index.html" matchType="IsFile" />
  </conditions>
  <action type="Redirect" redirectType="Permanent" url="{R:1}/" />
</rule>

Purpose: This rule ensures that a directory is redirected to a clean URL with a trailing slash if it is not a file and it has an index.html file.
Example: /about → /about/

Rule 4: Angular Routes (Fallback)

xml

<rule name="Angular Routes" stopProcessing="true">
  <match url=".*" />
  <conditions logicalGrouping="MatchAll">
    <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
    <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
  </conditions>
  <action type="Rewrite" url="index.html" />
</rule>

Purpose: This rule is specifically for Single Page Applications (SPA) like Angular. If the request does not correspond to an existing file or directory, the request is rewritten to serve index.html, allowing the Angular router to handle the routing.
Example: /about → index.html (Angular router processes it)

4. Static Content Configuration

The <staticContent> section manages the configuration for static files like images, fonts, and JSON files.

xml

<clientCache cacheControlMode="UseMaxAge" cacheControlMaxAge="7.00:00:00" />

Purpose: This sets the cache control headers to instruct browsers to cache static content for 7 days.

xml

<remove fileExtension=".json" />
<mimeMap fileExtension=".json" mimeType="application/json" />
<remove fileExtension=".woff" />
<mimeMap fileExtension=".woff" mimeType="application/font-woff" />
<remove fileExtension=".woff2" />
<mimeMap fileExtension=".woff2" mimeType="application/font-woff2" />

Purpose: These lines modify the MIME type configuration for certain file extensions:
- .json files are mapped to application/json.
- .woff files are mapped to application/font-woff.
- .woff2 files are mapped to application/font-woff2.
The remove statements ensure that previous mappings are cleared before setting the new ones.

<?xml version="1.0" encoding="UTF-8"?>

<configuration>

<system.webServer>

<rewrite>

<rules>

<rule name="RemoveTrailingSlash" stopProcessing="true">

<match url="(.*)/$" />

<conditions>

<add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />

<add input="{REQUEST_FILENAME}/index.html" matchType="IsFile" negate="true" />

</conditions>

<action type="Redirect" redirectType="Permanent" url="{R:1}" />

</rule>

<rule name="RewriteDirectoryToIndexHtml" stopProcessing="true">

<match url="^(.*)$" />

<conditions>

<add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />

<add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />

<add input="{REQUEST_FILENAME}/index.html" matchType="IsFile" />

</conditions>

<action type="Rewrite" url="{R:1}/index.html" />

</rule>

<rule name="RedirectToCleanURL" stopProcessing="true">

<match url="^(.*)$" />

<conditions>

<add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />

<add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />

<add input="{REQUEST_URI}" pattern="/$" negate="true" />

<add input="{REQUEST_FILENAME}/index.html" matchType="IsFile" />

</conditions>

<action type="Redirect" redirectType="Permanent" url="{R:1}/" />

</rule>

<rule name="Angular Routes" stopProcessing="true">

<match url=".*" />

<conditions logicalGrouping="MatchAll">

<add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />

<add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />

</conditions>

<action type="Rewrite" url="index.html" />

</rule>

</rules>

</rewrite>

<staticContent>

<clientCache cacheControlMode="UseMaxAge" cacheControlMaxAge="7.00:00:00" />

<remove fileExtension=".json" />

<mimeMap fileExtension=".json" mimeType="application/json" />

<remove fileExtension=".woff" />

<mimeMap fileExtension=".woff" mimeType="application/font-woff" />

<remove fileExtension=".woff2" />

<mimeMap fileExtension=".woff2" mimeType="application/font-woff2" />

</staticContent>

</system.webServer>

</configuration>

Summary of Functionality

Trailing Slash Handling: Removes unnecessary trailing slashes from URLs and redirects to the clean version.
Directory to index.html: Ensures that directory requests are properly served with index.html if available.
Clean URLs: Ensures directories have trailing slashes for cleaner URLs.
SPA Fallback: Redirects non-file and non-directory requests to index.html for SPA routing (e.g., Angular).
Static File Caching: Caches static content for 7 days and configures MIME types for fonts and JSON.

Some Tricky SQL Server questions that often trip up developers

1. NULL Handling

Question:

What is the result of SELECT NULL = NULL in SQL Server?
Answer:
It returns NULL, not TRUE or FALSE. Use IS NULL instead:

SELECT CASE WHEN NULL IS NULL THEN 'TRUE' ELSE 'FALSE' END; -- Returns 'TRUE'

2. Implicit Conversion Pitfalls

Question:
Why does SELECT 5 + '5' return 10, but SELECT '5' + 5 throws an error?
Answer:
SQL Server implicitly converts the string '5' to an integer in the first case but fails in the second because '5' is treated as a string first. Use explicit casting:

SELECT CAST('5' AS INT) + 5; -- Returns 10

3. The "Halloween Problem"

Question:
What happens if you run this query?

UPDATE Employees SET Salary = Salary * 1.1 WHERE Salary < 5000;

Answer:
If an employee’s updated salary crosses the 5000 threshold during the update, they might be updated multiple times (due to how the query plan scans the data). Use WITH (TABLOCK) or split the query into batches.

4. JOINs vs. WHERE Clauses

Question:
What’s the difference between these two queries?

-- Query 1
SELECT * FROM TableA LEFT JOIN TableB ON A.ID = B.ID WHERE B.ID IS NOT NULL;

-- Query 2
SELECT * FROM TableA INNER JOIN TableB ON A.ID = B.ID;

Answer:
Both return the same result, but Query 1 is less efficient because it performs a LEFT JOIN and then filters out NULLs. Query 2 uses an INNER JOIN directly.

5. The "Gaps and Islands" Problem

Question:
How do you find gaps in a sequence of numbers (e.g., missing order IDs)?
Tricky Answer:
Use LEAD() or LAG():

WITH CTE AS (
  SELECT OrderID, NextOrderID = LEAD(OrderID) OVER (ORDER BY OrderID)
  FROM Orders
)
SELECT GapStart = OrderID + 1, GapEnd = NextOrderID - 1
FROM CTE
WHERE NextOrderID - OrderID > 1;

6. Deadlocks and Locking

Question:
Why does this query cause a deadlock?

-- Session 1
BEGIN TRAN;
UPDATE TableA SET Col1 = 1 WHERE ID = 1;
UPDATE TableB SET Col2 = 2 WHERE ID = 1;

-- Session 2 (run concurrently)
BEGIN TRAN;
UPDATE TableB SET Col2 = 2 WHERE ID = 1;
UPDATE TableA SET Col1 = 1 WHERE ID = 1;

Answer:
Each transaction holds a lock on one table and waits for the other. Use consistent update order or SET DEADLOCK_PRIORITY.

7. CTE Recursion Limits

Question:
What happens if you run this recursive CTE?

WITH CTE AS (
  SELECT 1 AS Number
  UNION ALL
  SELECT Number + 1 FROM CTE WHERE Number < 1000
)
SELECT * FROM CTE OPTION (MAXRECURSION 0);

Answer:
By default, SQL Server limits recursion to 100 levels. MAXRECURSION 0 removes the limit but risks infinite loops.

8. MERGE Statement Gotchas

Question:
Can the MERGE statement cause primary key violations?
Answer:
Yes! If multiple source rows match the same target row, MERGE can attempt duplicate inserts. Always deduplicate source data first.

9. String Splitting

Question:
What’s wrong with using STRING_SPLIT in SQL Server 2016+?
Answer:
STRING_SPLIT doesn’t guarantee the order of output rows. Use OPENJSON or a custom splitter for ordered results.

**10. The "COUNT(*) vs. COUNT(Column)" Trap**

Question:
What’s the difference between COUNT(*) and COUNT(Column)?
Answer:

COUNT(*) counts all rows.
COUNT(Column) counts non-NULL values in that column.

11. The "NOLOCK" Hint Myth

Question:
Does WITH (NOLOCK) make queries faster?
Answer:
Yes, but it allows dirty reads (uncommitted data) and is not a substitute for proper isolation levels. Use READ COMMITTED SNAPSHOT instead.

12. Paging with OFFSET-FETCH

Question:
Why does OFFSET 1000 ROWS FETCH NEXT 10 ROWS ONLY perform poorly?
Answer:
It scans all previous rows (1000+10). Use keyset pagination instead:

SELECT * FROM Orders WHERE OrderID > @LastSeenID ORDER BY OrderID FETCH NEXT 10 ROWS ONLY;

13. The "UPDATE with JOIN" Surprise

Question:
What does this query do?

UPDATE A
SET A.Col1 = B.Col2
FROM TableA A
INNER JOIN TableB B ON A.ID = B.ID;

Answer:
It updates TableA using values from TableB where IDs match. The syntax is valid but often confuses developers expecting a WHERE clause.

14. The "DISTINCT" Misconception

Question:
Does SELECT DISTINCT remove duplicates from the entire row?
Answer:
Yes, but it’s resource-heavy. Use GROUP BY with aggregates or window functions for better control.

15. The "DATETIME vs. DATETIME2" Quirk

Question:
Why does WHERE DateColumn = '2023-10-01' fail for DATETIME?
Answer:
DATETIME has a time component (3.33ms precision). Use CAST to DATE:

WHERE CAST(DateColumn AS DATE) = '2023-10-01';

Bonus: The "Ghost Records" Issue

Question:
Why does a table’s size not reduce after deleting rows?
Answer:
SQL Server marks rows as "ghost records" for potential rollbacks. Rebuild the index or use ALTER TABLE ... REBUILD.

How to Prepare for Tricky SQL Questions

Understand Execution Plans: Use SET SHOWPLAN_TEXT ON to analyze query logic.
Test Edge Cases: Try NULLs, duplicates, and empty datasets.
Master Window Functions: ROW_NUMBER(), RANK(), and LEAD()/LAG().
Learn Isolation Levels: READ UNCOMMITTED, SNAPSHOT, etc.

HTTP response status codes

HTTP response status codes indicate whether a specific HTTP request has been successfully completed. Responses are grouped in five classes:

Informational responses (100 – 199)
Successful responses (200 – 299)
Redirection messages (300 – 399)
Client error responses (400 – 499)
Server error responses (500 – 599)

Advanced .NET Scenario-Based Questions and Answers

Memory Leak in a WPF Application

Scenario:
A WPF application's memory usage increases over time, even when idle. The application uses event subscriptions, but events are not unsubscribed. How would you diagnose and resolve this issue?

Answer:

Cause: Event subscribers hold strong references to publishers. If not unsubscribed, publishers outlive subscribers, keeping them in memory.
Diagnosis: Use a memory profiler (e.g., dotMemory, Visual Studio Diagnostic Tools) to inspect object retention graphs. Look for lingering EventHandler references.

Fix:

Unsubscribe events explicitly when no longer needed.
Use weak event patterns (e.g., WeakEventManager).

// Before (leaks):
publisher.Event += SubscriberMethod;

// Fix:
publisher.Event -= SubscriberMethod; // Unsubscribe when done

// Or use WeakEventManager:
WeakEventManager<PublisherType, EventArgs>.AddHandler(publisher, nameof(publisher.Event), SubscriberMethod);

2. Async Deadlock in ASP.NET

Scenario:
An ASP.NET MVC action uses Task.Result to call an async method, causing deadlocks. How would you refactor this?

Answer:

Cause: Blocking on async code (e.g., Result/Wait()) in a synchronous context deadlocks due to thread pool exhaustion.

Fix: Replace blocking calls with async/await throughout the call chain.

// Before (deadlocks):
public ActionResult GetData() {
    var data = SomeAsyncMethod().Result;
    return View(data);
}

// After (async all the way):
public async Task<ActionResult> GetData() {
    var data = await SomeAsyncMethod();
    return View(data);
}

3. High CPU in Parallel.ForEach

Scenario:
A Parallel.ForEach loop processes a large collection but causes high CPU due to thread contention. How do you optimize it?

Answer:

Cause: Shared resources or fine-grained work items cause excessive locking.

Optimizations:

Use Partitioner.Create to reduce overhead.
Avoid shared state; use thread-local variables (ThreadLocal<T>).

var partitioner = Partitioner.Create(data, EnumerablePartitionerOptions.NoBuffering);
Parallel.ForEach(partitioner, item => Process(item));

// Or use concurrent collections:
var results = new ConcurrentBag<ResultType>();
Parallel.ForEach(data, item => results.Add(Process(item)));

4. Captive Dependency in DI

Scenario:
A singleton service in ASP.NET Core injects a scoped service, causing the scoped instance to behave like a singleton. How do you fix this?

Answer:

Cause: Scoped services injected into singletons become captive, as their lifespan is extended.

Fix: Use IServiceScopeFactory to resolve scoped services within the singleton.

public class SingletonService {
    private readonly IServiceScopeFactory _scopeFactory;
    public SingletonService(IServiceScopeFactory scopeFactory) => _scopeFactory = scopeFactory;

    public void Method() {
        using var scope = _scopeFactory.CreateScope();
        var scopedService = scope.ServiceProvider.GetRequiredService<IScopedService>();
        scopedService.DoWork();
    }
}

5. Optimizing Slow LINQ Queries on Large Data

Scenario:
A LINQ-to-Objects query on a 1-million-item collection is slow. How would you optimize it?

Answer:

Optimizations:

Use PLINQ (AsParallel()) for CPU-bound work.
Replace class with struct and use Span<T> to reduce heap allocations.

// PLINQ example:
var results = data.AsParallel()
                 .Where(item => item.IsValid)
                 .Select(item => Transform(item))
                 .ToList();

// Span<T> example (for stack-based processing):
Span<DataItem> span = dataArray.AsSpan();
foreach (ref var item in span) {
    Process(ref item); // Avoids boxing and heap allocations
}

6. Secure Password Handling

Scenario:
How would you securely hash passwords in a .NET application to prevent exposure if the database is compromised?

Answer:

Best Practice: Use Rfc2898DeriveBytes (PBKDF2) with a high iteration count.

public string HashPassword(string password) {
    byte[] salt = new byte[16];
    using (var rng = RandomNumberGenerator.Create()) {
        rng.GetBytes(salt);
    }
    var pbkdf2 = new Rfc2898DeriveBytes(password, salt, 100000, HashAlgorithmName.SHA256);
    byte[] hash = pbkdf2.GetBytes(32);
    return Convert.ToBase64String(salt) + ":" + Convert.ToBase64String(hash);
}

1. XML Declaration

2. System Web Server Configuration

3. URL Rewrite Rules

Rule 1: Remove Trailing Slash

Rule 2: Rewrite Directory to index.html

Rule 3: Redirect to Clean URL (No Trailing Slash)

Rule 4: Angular Routes (Fallback)

4. Static Content Configuration

Summary of Functionality

1. NULL Handling

2. Implicit Conversion Pitfalls

3. The "Halloween Problem"

4. JOINs vs. WHERE Clauses

5. The "Gaps and Islands" Problem

6. Deadlocks and Locking

7. CTE Recursion Limits

8. MERGE Statement Gotchas

9. String Splitting

10. The "COUNT(*) vs. COUNT(Column)" Trap

11. The "NOLOCK" Hint Myth

12. Paging with OFFSET-FETCH

13. The "UPDATE with JOIN" Surprise

14. The "DISTINCT" Misconception

15. The "DATETIME vs. DATETIME2" Quirk

Bonus: The "Ghost Records" Issue

How to Prepare for Tricky SQL Questions

2. Async Deadlock in ASP.NET

3. High CPU in Parallel.ForEach

4. Captive Dependency in DI

5. Optimizing Slow LINQ Queries on Large Data

6. Secure Password Handling

Best for you

Rule 2: Rewrite Directory to `index.html`

**10. The "COUNT(*) vs. COUNT(Column)" Trap**