Using Examples

// File operations
using var fileStream = File.OpenRead("data.txt");
using var reader = new StreamReader(fileStream);
var content = reader.ReadToEnd();

// Database connections
using var connection = new SqlConnection(connectionString);
using var command = new SqlCommand("SELECT * FROM Users", connection);
connection.Open();
using var reader = command.ExecuteReader();
while (reader.Read()) {
    // Process data
}

// Multiple using statements
using (var file1 = File.OpenRead("file1.txt"))
using (var file2 = File.OpenRead("file2.txt"))
{
    // Use both files
}

// Using with HttpClient
using var client = new HttpClient();
var response = await client.GetAsync("https://api.example.com/data");

// Custom IDisposable
public class CustomResource : IDisposable
{
    private bool _disposed = false;
    
    public void UseResource()
    {
        if (_disposed) throw new ObjectDisposedException(nameof(CustomResource));
        // Use resource
    }
    
    public void Dispose()
    {
        if (!_disposed)
        {
            // Cleanup
            _disposed = true;
        }
    }
}

// Using with custom resource
using var resource = new CustomResource();
resource.UseResource();

Using Tips

• Use for any IDisposable resource
• Automatic cleanup (even with exceptions)
• Use declaration syntax (C# 8+)
• Avoid nesting when possible
• Consider using with try-catch when needed

Lambda Examples

// Basic syntax
(parameters) => expression
(parameters) => { statements }

// Examples
x => x * x                    // Single parameter
(x, y) => x + y              // Multiple parameters
() => DateTime.Now           // No parameters
x => { return x * x; }       // Statement lambda

// With LINQ
var adults = users.Where(u => u.Age >= 18);
var sorted = numbers.OrderBy(n => n);
var projected = users.Select(u => new { u.Name, u.Age });
var grouped = users.GroupBy(u => u.City);

// Event handlers
button.Click += (sender, e) => 
    Console.WriteLine("Button clicked");

// Func and Action
Func add = (a, b) => a + b;
Action print = s => Console.WriteLine(s);

// Expression-bodied members
public string Name => firstName + " " + lastName;
public int Sum() => a + b;

// Multiple statements
Func calculate = x =>
{
    var y = x * 2;
    return y + 5;
};

// Discard parameter
button.Click += (_, _) => HandleClick();

// Tuple returns
Func getMultiplied = x => x switch
{
    > 10 => x * 2,
    > 5 => x * 3,
    _ => x
};

Lambda Tips

• Keep lambdas short and readable
• Use meaningful parameter names
• Use discard _ for unused parameters
• Avoid side effects in expressions
• Use with LINQ for readability

GROUP BY Basics

-- Count by category
SELECT 
    category,
    COUNT(*) as product_count
FROM products
GROUP BY category;

-- Sum by customer
SELECT 
    customer_id,
    SUM(total) as total_spent,
    COUNT(*) as order_count
FROM orders
GROUP BY customer_id;

-- Average by department
SELECT 
    department,
    AVG(salary) as avg_salary
FROM employees
GROUP BY department;

-- Multiple groups
SELECT 
    year,
    month,
    SUM(total) as monthly_sales
FROM orders
GROUP BY year, month
ORDER BY year, month;

Advanced GROUP BY

-- GROUP BY with HAVING
SELECT 
    customer_id,
    SUM(total) as total_spent,
    COUNT(*) as order_count
FROM orders
GROUP BY customer_id
HAVING SUM(total) > 1000
AND COUNT(*) > 5;

-- GROUP BY with ROLLUP
SELECT 
    department,
    YEAR(hire_date) as year,
    COUNT(*) as employee_count
FROM employees
GROUP BY ROLLUP(department, YEAR(hire_date));

-- GROUP BY with CUBE
SELECT 
    department,
    job_title,
    COUNT(*) as employee_count
FROM employees
GROUP BY CUBE(department, job_title);

-- GROUP BY with GROUPING SETS
SELECT 
    department,
    job_title,
    COUNT(*) as employee_count
FROM employees
GROUP BY GROUPING SETS (
    (department, job_title),
    (department),
    (job_title),
    ()
);

-- Multiple aggregate functions
SELECT 
    category,
    COUNT(*) as count,
    SUM(price) as total_value,
    AVG(price) as avg_price,
    MIN(price) as min_price,
    MAX(price) as max_price
FROM products
GROUP BY category;

GROUP BY Tips

• Use for data analysis
• Use HAVING for group filtering
• Use multiple columns for detailed grouping
• Use ROLLUP for subtotals
• Index grouped columns for performance

Routing Basics

// Program.cs
var app = builder.Build();

// Basic routing
app.MapGet("/", () => "Hello World!");
app.MapGet("/users", () => new[] { new { Id = 1, Name = "Alice" } });
app.MapGet("/users/{id:int}", (int id) => new { Id = id, Name = $"User {id}" });
app.MapPost("/users", (User user) => Results.Created($"/users/{user.Id}", user));
app.MapPut("/users/{id:int}", (int id, User user) => Results.Ok(user));
app.MapDelete("/users/{id:int}", (int id) => Results.NoContent());

// Route constraints
app.MapGet("/users/{id:int}", (int id) => ...);
app.MapGet("/users/{name:alpha}", (string name) => ...);
app.MapGet("/users/{id:guid}", (Guid id) => ...);

// Route parameters
app.MapGet("/blog/{year:int}/{month:int}", (int year, int month) => ...);

// Route groups
var apiGroup = app.MapGroup("/api");
apiGroup.MapGet("/users", GetUsers);
apiGroup.MapGet("/users/{id:int}", GetUser);
apiGroup.MapPost("/users", CreateUser);

// Fallback route
app.MapFallback(() => Results.NotFound());

Advanced Routing

// Controller routing
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult GetUsers() { ... }
    
    [HttpGet("{id:int}")]
    public IActionResult GetUser(int id) { ... }
    
    [HttpPost]
    public IActionResult CreateUser([FromBody] User user) { ... }
    
    [HttpPut("{id:int}")]
    public IActionResult UpdateUser(int id, [FromBody] User user) { ... }
    
    [HttpDelete("{id:int}")]
    public IActionResult DeleteUser(int id) { ... }
}

// Route with optional parameter
[HttpGet("{id?}")]
public IActionResult GetUser(int? id) { ... }

// Route with default value
[HttpGet("{page=1}")]
public IActionResult GetUsers(int page) { ... }

// Route constraints
[HttpGet("{id:int}"]

// Route ordering
[HttpGet("popular")]  // Must come before "{id}"

// Custom routes
app.MapGet("/stats/{*path}", (string path) => ...);

Routing Tips

• Use clean, semantic URLs
• Use route constraints for validation
• Group related endpoints
• Use fallback for 404 handling
• Order specific routes before generic

Reset Types

# Soft Reset
git reset --soft HEAD~1
# Moves HEAD back
# Changes stay in staging

# Mixed Reset (default)
git reset --mixed HEAD~1
git reset HEAD~1
# Moves HEAD back
# Changes stay in working directory

# Hard Reset
git reset --hard HEAD~1
# Moves HEAD back
# Changes are lost (careful!)

# Reset to specific commit
git reset --hard commit-hash

# Unstage files (mixed)
git reset HEAD file.txt

# Discard changes (hard)
git reset --hard HEAD
git checkout -- file.txt

# Undo reset (reflog)
git reflog
git reset --hard HEAD@{1}

Reset Examples

# Undo last commit (keep changes)
git reset --soft HEAD~1
git status
# Changes still staged

# Undo last commit (unstage changes)
git reset HEAD~1
# Changes in working directory

# Undo last commit (lose changes)
git reset --hard HEAD~1
# Changes lost

# Undo multiple commits
git reset --hard HEAD~3

# Undo to specific commit
git log --oneline
# abc1234 Latest commit
# def5678 Previous commit
git reset --hard def5678

# Undo git add
git reset HEAD file.txt
git reset              # All files

# Undo git add (alternative)
git restore --staged file.txt

# Undo file changes
git checkout -- file.txt
git restore file.txt

# Undo git reset (reflog)
git reflog
# abc1234 HEAD@{0}: reset: moving to HEAD~1
# def5678 HEAD@{1}: commit: Latest commit
git reset --hard def5678

Reset Tips

• Use –soft to keep changes
• Use –hard carefully (loses changes)
• Use git reflog to undo reset
• Use for local, unpushed commits
• Don’t reset shared branches

Axios Setup

# Install
npm install axios

# Basic GET
import axios from 'axios';

axios.get('https://api.example.com/data')
    .then(response => console.log(response.data))
    .catch(error => console.error(error));

# POST
axios.post('https://api.example.com/data', {
    name: 'Alice',
    email: 'alice@example.com'
})
.then(response => console.log(response.data))
.catch(error => console.error(error));

# Async/Await
try {
    const response = await axios.get('https://api.example.com/data');
    console.log(response.data);
} catch (error) {
    console.error(error);
}

# Global defaults
axios.defaults.baseURL = 'https://api.example.com';
axios.defaults.headers.common['Authorization'] = 'Bearer token';
axios.defaults.timeout = 10000;

Axios Features

// Interceptors
axios.interceptors.request.use(config => {
    config.headers.Authorization = `Bearer ${token}`;
    return config;
});

axios.interceptors.response.use(
    response => response,
    error => {
        if (error.response?.status === 401) {
            // Handle unauthorized
        }
        return Promise.reject(error);
    }
);

// Cancel requests
const controller = new AbortController();
axios.get('/api/data', { signal: controller.signal });
controller.abort();

// Concurrent requests
const [users, posts] = await Promise.all([
    axios.get('/api/users'),
    axios.get('/api/posts')
]);

// Create instance
const api = axios.create({
    baseURL: 'https://api.example.com',
    timeout: 1000,
    headers: {'X-Custom-Header': 'foobar'}
});

// Progress tracking
axios.post('/api/upload', formData, {
    onUploadProgress: progressEvent => {
        const percent = (progressEvent.loaded / progressEvent.total) * 100;
        console.log(`Upload: ${percent}%`);
    }
});

// Automatic JSON transformation
axios.post('/api/data', { name: 'Alice' }); // No need to stringify

Axios Tips

• Use interceptors for auth and logging
• Use instances for different APIs
• Use async/await for readability
• Cancel requests when needed
• Handle errors globally

Hoisting Examples

// var hoisting
console.log(x); // undefined (not error)
var x = 5;

// Equivalent to:
var x;
console.log(x); // undefined
x = 5;

// function hoisting
sayHello(); // "Hello"
function sayHello() {
    console.log('Hello');
}

// function expression (not hoisted)
sayGoodbye(); // Error: not a function
var sayGoodbye = function() {
    console.log('Goodbye');
};

// let and const (temporal dead zone)
console.log(y); // ReferenceError
let y = 5;

// Temporal Dead Zone (TDZ)
// let/const are hoisted but not initialized
{
    // TDZ starts
    console.log(z); // ReferenceError
    let z = 10;
    // TDZ ends
}

// var vs let
console.log(a); // undefined
var a = 5;

console.log(b); // ReferenceError
let b = 5;

// Hoisting in functions
var name = 'Global';
function showName() {
    console.log(name); // undefined (not 'Global')
    var name = 'Local';
    console.log(name); // 'Local'
}
showName();

// Best Practice
// Declare variables at top of scope
// Use let and const instead of var
// Avoid relying on hoisting

Hoisting Rules

# var
- Hoisted
- Initialized as undefined
- Function scope

# let/const
- Hoisted
- Not initialized (TDZ)
- Block scope

# function declarations
- Fully hoisted
- Available anywhere

# function expressions
- Not hoisted
- Treated as variable

# Arrow functions
- Not hoisted
- Treated as variable

# Class declarations
- Hoisted
- TDZ applies

# Examples
// Class hoisting
const obj = new MyClass(); // ReferenceError
class MyClass {}

// Arrow function (not hoisted)
arrowFunc(); // TypeError
var arrowFunc = () => console.log('Hi');

// Function in block
if (true) {
    function foo() { return 1; }
} else {
    function foo() { return 2; }
}
console.log(foo()); // Varies by browser (avoid this)

// Best practices
- Use let/const instead of var
- Declare variables at top
- Avoid hoisting confusion
- Use function declarations for hoisting

Hoisting Tips

• Use let and const instead of var
• Declare variables at top of scope
• Understand TDZ for let/const
• Function declarations are hoisted
• Avoid relying on hoisting

Storage Methods

// LocalStorage (persistent)
localStorage.setItem('key', 'value');
const value = localStorage.getItem('key');
localStorage.removeItem('key');
localStorage.clear();

// SessionStorage (session only)
sessionStorage.setItem('key', 'value');
const value = sessionStorage.getItem('key');
sessionStorage.removeItem('key');
sessionStorage.clear();

// Store objects
const user = { name: 'Alice', age: 30 };
localStorage.setItem('user', JSON.stringify(user));
const userData = JSON.parse(localStorage.getItem('user'));

// Check if exists
if (localStorage.getItem('key') !== null) {
    // Key exists
}

// Get all keys
const keys = Object.keys(localStorage);
for (let key of keys) {
    console.log(key, localStorage.getItem(key));
}

// Event listener (other tabs)
window.addEventListener('storage', function(e) {
    console.log('Storage changed:', e.key, e.newValue);
});

Practical Examples

// Theme preference
function saveTheme(theme) {
    localStorage.setItem('theme', theme);
}
function getTheme() {
    return localStorage.getItem('theme') || 'light';
}

// Form data persistence
function saveFormData(formData) {
    sessionStorage.setItem('formData', JSON.stringify(formData));
}
function getFormData() {
    const data = sessionStorage.getItem('formData');
    return data ? JSON.parse(data) : {};
}

// Shopping cart
const cart = [
    { id: 1, name: 'Product 1', price: 99 },
    { id: 2, name: 'Product 2', price: 149 }
];
localStorage.setItem('cart', JSON.stringify(cart));
const savedCart = JSON.parse(localStorage.getItem('cart') || '[]');

// User session
function saveSession(user) {
    sessionStorage.setItem('session', JSON.stringify(user));
}
function getSession() {
    const session = sessionStorage.getItem('session');
    return session ? JSON.parse(session) : null;
}
function clearSession() {
    sessionStorage.removeItem('session');
}

// Remember me
function rememberMe(email) {
    if (email) {
        localStorage.setItem('rememberEmail', email);
    } else {
        localStorage.removeItem('rememberEmail');
    }
}

Storage Tips

• 5-10 MB storage limit
• String data only (use JSON)
• Not secure (plain text)
• Same-origin policy
• Not for sensitive data

Filter Functions

/* Blur */
filter: blur(5px);
filter: blur(2px);

/* Brightness */
filter: brightness(0.8);
filter: brightness(1.2);
filter: brightness(200%);

/* Contrast */
filter: contrast(1.5);
filter: contrast(200%);

/* Grayscale */
filter: grayscale(100%);
filter: grayscale(0.5);

/* Hue Rotate */
filter: hue-rotate(90deg);
filter: hue-rotate(180deg);

/* Invert */
filter: invert(100%);
filter: invert(0.8);

/* Opacity */
filter: opacity(0.5);
filter: opacity(80%);

/* Saturate */
filter: saturate(2);
filter: saturate(0.5);

/* Sepia */
filter: sepia(100%);
filter: sepia(0.8);

/* Multiple filters */
filter: blur(2px) brightness(1.2) saturate(1.5);

/* Drop shadow */
filter: drop-shadow(2px 2px 4px rgba(0,0,0,0.5));

Practical Examples

/* Hover effects */
.image:hover {
    filter: blur(2px) brightness(0.8);
}

/* Card hover */
.card:hover img {
    filter: scale(1.1) brightness(0.9);
}

/* Dark overlay */
.image-dark {
    filter: brightness(0.6) contrast(1.2);
}

/* Vintage effect */
.vintage {
    filter: sepia(0.8) saturate(0.5) contrast(1.1);
}

/* Neon glow */
.neon {
    filter: drop-shadow(0 0 10px #ff6b6b) brightness(1.2);
}

/* Blur background */
.hero-blur {
    filter: blur(8px);
    transform: scale(1.1);
}

/* Color pop */
.color-pop {
    filter: saturate(1.5) contrast(1.2);
}

/* Instagram-like filters */
/* Clarendon */
.clarendon {
    filter: contrast(1.2) brightness(1.1) saturate(1.3);
}

/* Gingham */
.gingham {
    filter: brightness(1.1) saturate(0.9) sepia(0.2);
}

/* Moon */
.moon {
    filter: grayscale(0.8) contrast(1.2) brightness(0.9);
}

Filter Tips

• Use for hover effects
• Use for image enhancements
• Combine multiple filters
• Use drop-shadow for realistic shadows
• Use sparingly for performance

Enable God Mode

# Create God Mode Folder
1. Right-click on Desktop
2. New → Folder
3. Name the folder:
   GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

# Access God Mode
- Double-click folder
- See all settings

# What's Inside
- Administrative Tools
- Action Center
- Backup and Restore
- Color Management
- Credential Manager
- Date and Time
- Devices and Printers
- Ease of Access
- File Explorer Options
- Fonts
- Internet Options
- Keyboard
- Mouse
- Network and Sharing
- Performance Options
- Power Options
- Programs and Features
- Regional Settings
- Security and Maintenance
- Sound
- Speech Recognition
- System
- Taskbar and Navigation
- User Accounts
- Windows Defender

Using God Mode

# Quick Access
- Pin to Quick Access
- Fast access to settings

# Search
- Search within God Mode
- Find settings fast

# Organization
- Grouped by category
- Alphabetical order
- Easy navigation

# Hidden Settings
- Access hidden settings
- Advanced controls
- Expert options

# Tips
- Pin to taskbar
- Create shortcut
- Use for troubleshooting
- Access rarely used settings
- Faster than Control Panel

# Common Uses
- Change power settings
- Manage user accounts
- Configure network
- Adjust performance
- Set default programs

God Mode Tips

• Keep on desktop for quick access
• Use for system administration
• Find hidden settings
• Search for specific settings
• Pin to Quick Access