// یک HTTP server ساده و سریع
package main

import (
    "net/http"
    "log"
)

func main() {
    http.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("OK"))
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// پردازش همزمان ۱۰۰۰ درخواست
func processRequests(requests []Request) {
    var wg sync.WaitGroup

    for _, req := range requests {
        wg.Add(1)
        go func(r Request) {
            defer wg.Done()
            // پردازش درخواست
            process(r)
        }(req)
    }

    wg.Wait()
}

# Dockerfile برای Go - فقط ۳ خط!
FROM golang:1.21 AS builder
COPY . .
RUN CGO_ENABLED=0 go build -o app

FROM scratch
COPY --from=builder /app /app
ENTRYPOINT ["/app"]

// ساده و type-safe
type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

func (u *User) Validate() error {
    if u.Email == "" {
        return errors.New("email required")
    }
    return nil
}

// این pattern در همه‌جا تکرار می‌شود
result, err := doSomething()
if err != nil {
    return err
}

روز اول:
├── یک سرور
├── یک دیتابیس
└── یک کدبیس ساده

وقتی به ۱۰,۰۰۰ کاربر رسیدید:
├── جدا کردن سرویس‌های پرترافیک
└── بهینه‌سازی Bottleneck ها

// حداقل تست برای یک سرویس Go
func TestCreateUser(t *testing.T) {
    // Arrange
    service := NewUserService(mockDB)

    // Act
    user, err := service.Create("test@example.com")

    // Assert
    if err != nil {
        t.Fatalf("expected no error, got %v", err)
    }
    if user.Email != "test@example.com" {
        t.Errorf("expected email test@example.com, got %s", user.Email)
    }
}

Scalable Architecture Checklist:
✓ Stateless Application Servers
✓ Database Connection Pooling
✓ Caching Strategy (even if not implemented)
✓ CDN برای static assets
✓ Load Balancer ready design

❌ اشتباه:
Service A → Database B (مستقیم)

✅ درست:
Service A → API Service B → Database B

Stack پیشنهادی:
├── ۱ VPS (4GB RAM, 2 vCPU)
├── Docker Compose
├── Nginx reverse proxy
├── PostgreSQL
└── Redis

Stack پیشنهادی:
├── ۲-۳ VPS (Application)
├── ۱ VPS (Database)
├── Object Storage (ابرآروان/S3)
├── CDN (ابرآروان)
├── Docker Swarm یا ساده‌تر
└── Load Balancer

Stack پیشنهادی:
├── Kubernetes Cluster (3+ nodes)
├── Managed Database یا Replicated
├── Object Storage
├── CDN + WAF
├── Monitoring (Prometheus/Grafana)
└── Logging (ELK/Loki)

Hybrid Stack:
├── Application Servers: Hetzner (قیمت بهتر)
├── CDN: ابرآروان (برای کاربران ایرانی)
├── Object Storage: ابرآروان
├── Database: ایران (data residency)
└── Backup: خارج از ایران

# terraform برای سرور جدید
resource "hcloud_server" "web" {
  name        = "web-1"
  server_type = "cx21"
  image       = "ubuntu-22.04"
  location    = "fsn1"
}

# docker-compose.yml برای Registry خصوصی
version: '3'
services:
  registry:
    image: registry:2
    ports:
      - "5000:5000"
    volumes:
      - ./data:/var/lib/registry
    environment:
      REGISTRY_STORAGE_DELETE_ENABLED: "true"

# .gitlab-ci.yml
stages:
  - test
  - build
  - deploy

variables:
  DOCKER_REGISTRY: registry.example.ir

test:
  stage: test
  image: golang:1.21
  script:
    - go test ./...

build:
  stage: build
  script:
    - docker build -t $DOCKER_REGISTRY/myapp:$CI_COMMIT_SHA .
    - docker push $DOCKER_REGISTRY/myapp:$CI_COMMIT_SHA

deploy:
  stage: deploy
  script:
    - kubectl set image deployment/myapp myapp=$DOCKER_REGISTRY/myapp:$CI_COMMIT_SHA
  only:
    - main

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Build
        run: |
          docker build -t myapp:$ .

      - name: Deploy
        run: |
          # Deploy to your server
          ssh user@server "docker pull && docker-compose up -d"

# نصب k3s روی سرور اول (master)
curl -sfL https://get.k3s.io | sh -

# اضافه کردن worker
curl -sfL https://get.k3s.io | K3S_URL=https://master:6443 K3S_TOKEN=xxx sh -

# استفاده از mirror
apiVersion: v1
kind: ConfigMap
metadata:
  name: registry-mirrors
data:
  registries.yaml: |
    mirrors:
      docker.io:
        endpoint:
          - "https://mirror.gcr.io"
          - "https://registry.example.ir"

┌─────────────────────────────────────────┐
│              Grafana                     │
│         (Visualization)                  │
└─────────────┬───────────────────────────┘
              │
    ┌─────────┴─────────┐
    │                   │
┌───┴───┐         ┌─────┴─────┐
│Prometheus│       │   Loki    │
│(Metrics) │       │  (Logs)   │
└───┬───┘         └─────┬─────┘
    │                   │
    └───────┬───────────┘
            │
    ┌───────┴───────┐
    │  Your Apps    │
    └───────────────┘

# Prometheus + Grafana
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install monitoring prometheus-community/kube-prometheus-stack

# Loki برای لاگ‌ها
helm repo add grafana https://grafana.github.io/helm-charts
helm install loki grafana/loki-stack

# رمزنگاری فایل
sops --encrypt --age $AGE_PUBLIC_KEY secrets.yaml > secrets.enc.yaml

# در CI/CD رمزگشایی
sops --decrypt secrets.enc.yaml | kubectl apply -f -

# Backup روزانه PostgreSQL
0 2 * * * pg_dump -h localhost -U postgres mydb | gzip > /backup/mydb-$(date +%Y%m%d).sql.gz

# ارسال به Object Storage
0 3 * * * rclone sync /backup arvan:my-bucket/postgres/

<?php

class User {
    public function __construct(
        private string $name,
        private int $age
    ) {}

    public function info(): string {
        return "{$this->name} - {$this->age} سال";
    }
}

// Array operations
$numbers = [1, 2, 3, 4, 5];
$squares = array_map(fn($n) => $n ** 2, $numbers);

// Database with PDO
$pdo = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
$users = $pdo->query('SELECT * FROM users')->fetchAll(PDO::FETCH_ASSOC);

// JSON response
header('Content-Type: application/json');
echo json_encode(['users' => $users]);

package main

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "net/http"
    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func (u User) Info() string {
    return fmt.Sprintf("%s - %d سال", u.Name, u.Age)
}

func main() {
    // Database connection
    db, _ := sql.Open("mysql", "user:pass@/test")
    defer db.Close()

    http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
        rows, _ := db.Query("SELECT name, age FROM users")
        defer rows.Close()

        var users []User
        for rows.Next() {
            var u User
            rows.Scan(&u.Name, &u.Age)
            users = append(users, u)
        }

        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(users)
    })

    http.ListenAndServe(":8080", nil)
}

<?php
// PHP-FPM: هر request یک process
// محدود به تعداد workers (مثلاً 50)

// برای async، نیاز به extension یا library:
// - Swoole
// - ReactPHP
// - Amp

// مثال با Swoole
$server = new Swoole\HTTP\Server("0.0.0.0", 9501);

$server->on("request", function ($request, $response) {
    // این async است!
    go(function () use ($response) {
        $result = Co\Http\get('https://api.example.com/data');
        $response->end($result->body);
    });
});

$server->start();

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // هر request در goroutine جداگانه
        var wg sync.WaitGroup
        results := make([]string, 3)

        urls := []string{
            "https://api1.example.com",
            "https://api2.example.com",
            "https://api3.example.com",
        }

        // Fetch همه‌ی URL‌ها همزمان
        for i, url := range urls {
            wg.Add(1)
            go func(idx int, u string) {
                defer wg.Done()
                resp, _ := http.Get(u)
                defer resp.Body.Close()
                results[idx] = u
            }(i, url)
        }

        wg.Wait()
        fmt.Fprintf(w, "Done: %v", results)
    })

    http.ListenAndServe(":8080", nil)
}

# روش سنتی
# آپلود فایل‌ها به هر shared hosting

# روش مدرن (Docker)
FROM php:8.3-fpm
COPY . /var/www/html
RUN composer install --no-dev

# Build
go build -o app main.go

# اجرا - همین!
./app

# Docker
FROM scratch
COPY app /app
CMD ["/app"]

<?php
// routes/api.php
use App\Models\User;
use Illuminate\Http\Request;

Route::get('/users', function () {
    return User::all();
});

Route::get('/users/{id}', function ($id) {
    return User::findOrFail($id);
});

Route::post('/users', function (Request $request) {
    $validated = $request->validate([
        'name' => 'required|string',
        'email' => 'required|email|unique:users',
    ]);

    return User::create($validated);
});

package main

import (
    "fmt"
    "net/http"
    "github.com/gin-gonic/gin"
)

type User struct {
    ID    uint   `json:"id"`
    Name  string `json:"name" binding:"required"`
    Email string `json:"email" binding:"required,email"`
}

var users = []User{
    {ID: 1, Name: "علی", Email: "ali@example.com"},
}

func main() {
    r := gin.Default()

    r.GET("/users", func(c *gin.Context) {
        c.JSON(http.StatusOK, users)
    })

    r.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        for _, u := range users {
            if fmt.Sprint(u.ID) == id {
                c.JSON(http.StatusOK, u)
                return
            }
        }
        c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
    })

    r.POST("/users", func(c *gin.Context) {
        var user User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        user.ID = uint(len(users) + 1)
        users = append(users, user)
        c.JSON(http.StatusCreated, user)
    })

    r.Run(":8080")
}

// تعریف کلاس
class User {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    info() {
        return `${this.name} - ${this.age} سال`;
    }
}

// Async/Await
async function fetchUsers() {
    try {
        const response = await fetch('https://api.example.com/users');
        const users = await response.json();
        return users;
    } catch (error) {
        console.error('Error:', error);
    }
}

// Arrow functions
const greet = (name) => `سلام ${name}!`;

const user = new User('علی', 25);
console.log(user.info());

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func (u User) Info() string {
    return fmt.Sprintf("%s - %d سال", u.Name, u.Age)
}

func fetchUsers() ([]User, error) {
    resp, err := http.Get("https://api.example.com/users")
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var users []User
    if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
        return nil, err
    }
    return users, nil
}

func greet(name string) string {
    return fmt.Sprintf("سلام %s!", name)
}

func main() {
    user := User{Name: "علی", Age: 25}
    fmt.Println(user.Info())
}

const express = require('express');
const app = express();

// همه requestها در یک thread پردازش می‌شوند
app.get('/heavy', async (req, res) => {
    // این کد thread را block نمی‌کند
    const data = await fetchFromDB();
    res.json(data);
});

// مشکل: CPU-intensive کار
app.get('/compute', (req, res) => {
    // این thread اصلی را BLOCK می‌کند!
    const result = heavyComputation();
    res.json({ result });
});

app.listen(3000);

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func main() {
    http.HandleFunc("/heavy", func(w http.ResponseWriter, r *http.Request) {
        // هر request در goroutine جداگانه
        data := fetchFromDB()
        w.Write(data)
    })

    http.HandleFunc("/compute", func(w http.ResponseWriter, r *http.Request) {
        // CPU-intensive هم مشکلی ندارد!
        result := heavyComputation()
        fmt.Fprintf(w, "Result: %d", result)
    })

    // پردازش موازی
    http.HandleFunc("/parallel", func(w http.ResponseWriter, r *http.Request) {
        var wg sync.WaitGroup
        results := make([]int, 4)

        for i := 0; i < 4; i++ {
            wg.Add(1)
            go func(idx int) {
                defer wg.Done()
                results[idx] = compute(idx)
            }(i)
        }

        wg.Wait()
        fmt.Fprintf(w, "Results: %v", results)
    })

    http.ListenAndServe(":8080", nil)
}

// خطاها فقط در runtime مشخص می‌شوند
function processUser(user) {
    // user می‌تواند هر چیزی باشد!
    return user.name.toUpperCase();
}

processUser({ name: 'علی' });  // OK
processUser({ naam: 'علی' }); // Runtime Error!
processUser(null);            // Runtime Error!

// TypeScript کمک می‌کند ولی اختیاری است

type User struct {
    Name string
}

func processUser(user User) string {
    // user حتماً User است
    return strings.ToUpper(user.Name)
}

// کامپایل نمی‌شود!
// processUser(nil)
// processUser(map[string]string{})

async function fetchData() {
    try {
        const response = await fetch(url);
        if (!response.ok) {
            throw new Error(`HTTP ${response.status}`);
        }
        return await response.json();
    } catch (error) {
        console.error('Error:', error.message);
        throw error;
    }
}

// Promise chains
fetchData()
    .then(data => process(data))
    .catch(error => handleError(error));

// Callback hell (قدیمی)
fs.readFile('file.txt', (err, data) => {
    if (err) {
        // ...
    }
});

func fetchData(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, fmt.Errorf("fetch failed: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
    }

    data, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("read failed: %w", err)
    }

    return data, nil
}

// استفاده
data, err := fetchData("https://api.example.com")
if err != nil {
    log.Printf("Error: %v", err)
    return
}
// استفاده از data

# Dockerfile برای Node.js
FROM node:20-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .

CMD ["node", "index.js"]

# Dockerfile برای Go (Multi-stage)
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o main .

FROM scratch
COPY --from=builder /app/main /main
CMD ["/main"]

const express = require('express');
const app = express();

app.use(express.json());

let users = [{ id: 1, name: 'علی', email: 'ali@example.com' }];

app.get('/users', (req, res) => {
    res.json(users);
});

app.get('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    if (!user) return res.status(404).json({ error: 'Not found' });
    res.json(user);
});

app.post('/users', (req, res) => {
    const user = { id: users.length + 1, ...req.body };
    users.push(user);
    res.status(201).json(user);
});

app.listen(3000, () => console.log('Server running on :3000'));

package main

import (
    "net/http"
    "strconv"
    "github.com/gin-gonic/gin"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

var users = []User{
    {ID: 1, Name: "علی", Email: "ali@example.com"},
}

func main() {
    r := gin.Default()

    r.GET("/users", func(c *gin.Context) {
        c.JSON(http.StatusOK, users)
    })

    r.GET("/users/:id", func(c *gin.Context) {
        id, err := strconv.Atoi(c.Param("id"))
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid ID"})
            return
        }
        for _, u := range users {
            if u.ID == id {
                c.JSON(http.StatusOK, u)
                return
            }
        }
        c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
    })

    r.POST("/users", func(c *gin.Context) {
        var user User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        user.ID = len(users) + 1
        users = append(users, user)
        c.JSON(http.StatusCreated, user)
    })

    r.Run(":8080")
}

import java.util.ArrayList;
import java.util.List;

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public String info() {
        return String.format("%s - %d سال", name, age);
    }

    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        users.add(new User("علی", 25));
        users.add(new User("سارا", 30));

        for (User user : users) {
            System.out.println(user.info());
        }
    }
}

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func (u User) Info() string {
    return fmt.Sprintf("%s - %d سال", u.Name, u.Age)
}

func main() {
    users := []User{
        {Name: "علی", Age: 25},
        {Name: "سارا", Age: 30},
    }

    for _, user := range users {
        fmt.Println(user.Info())
    }
}

// Go - HTTP Server
func handler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello"))
}

// Java - Spring Boot
@GetMapping("/")
public String handler() {
    return "Hello";
}

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    // ایجاد 100,000 goroutine
    for i := 0; i < 100000; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        // Java 21+ Virtual Threads
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 100000; i++) {
                final int id = i;
                executor.submit(() -> {
                    System.out.println("Worker " + id + " done");
                });
            }
        }
    }
}

# Build برای Linux
GOOS=linux GOARCH=amd64 go build -o app

# Build برای Windows
GOOS=windows GOARCH=amd64 go build -o app.exe

# اجرا - بدون هیچ dependency
./app

# Build
mvn package

# اجرا - نیاز به JVM
java -jar app.jar

# یا با GraalVM Native Image (جدید)
native-image -jar app.jar

package main

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

var users = []User{
    {ID: 1, Name: "علی", Email: "ali@example.com"},
}

func main() {
    r := gin.Default()

    r.GET("/users", func(c *gin.Context) {
        c.JSON(http.StatusOK, users)
    })

    r.POST("/users", func(c *gin.Context) {
        var user User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        users = append(users, user)
        c.JSON(http.StatusCreated, user)
    })

    r.Run(":8080")
}

@RestController
@RequestMapping("/users")
public class UserController {

    private List<User> users = new ArrayList<>(
        List.of(new User(1, "علی", "ali@example.com"))
    );

    @GetMapping
    public List<User> getUsers() {
        return users;
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        users.add(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

@Data
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private String email;
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace MyApp
{
    public class User
    {
        public string Name { get; set; }
        public int Age { get; set; }

        public string Info() => $"{Name} - {Age} سال";
    }

    public class Program
    {
        public static void Main()
        {
            var users = new List<User>
            {
                new User { Name = "علی", Age = 25 },
                new User { Name = "سارا", Age = 30 }
            };

            // LINQ
            var adults = users.Where(u => u.Age >= 18)
                              .Select(u => u.Info());

            foreach (var info in adults)
            {
                Console.WriteLine(info);
            }
        }
    }
}

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

func (u User) Info() string {
    return fmt.Sprintf("%s - %d سال", u.Name, u.Age)
}

func main() {
    users := []User{
        {Name: "علی", Age: 25},
        {Name: "سارا", Age: 30},
    }

    // Filter manually (Go is explicit)
    for _, u := range users {
        if u.Age >= 18 {
            fmt.Println(u.Info())
        }
    }
}

// Async/Await
async Task<string> FetchDataAsync()
{
    using var client = new HttpClient();
    return await client.GetStringAsync("https://api.example.com");
}

// Pattern Matching (C# 11)
string Describe(object obj) => obj switch
{
    int n when n > 0 => "Positive",
    int n when n < 0 => "Negative",
    string s => $"String: {s}",
    null => "Null",
    _ => "Unknown"
};

// Records (Immutable types)
public record Person(string Name, int Age);

// Nullable reference types
string? nullableName = null;

// Extension methods
public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string? s)
        => string.IsNullOrEmpty(s);
}

// Goroutines برای async
func fetchData() (string, error) {
    resp, err := http.Get("https://api.example.com")
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    return string(body), err
}

// Type switch (مشابه pattern matching)
func describe(v interface{}) string {
    switch x := v.(type) {
    case int:
        if x > 0 {
            return "Positive"
        }
        return "Non-positive"
    case string:
        return "String: " + x
    case nil:
        return "Nil"
    default:
        return "Unknown"
    }
}

// Generics (از Go 1.18)
func Filter[T any](slice []T, predicate func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // Start 10 workers
    for w := 1; w <= 10; w++ {
        go worker(w, jobs, results)
    }

    // Send 50 jobs
    go func() {
        for j := 1; j <= 50; j++ {
            jobs <- j
        }
        close(jobs)
    }()

    // Collect results
    for a := 1; a <= 50; a++ {
        fmt.Println(<-results)
    }
}

using System;
using System.Linq;
using System.Threading.Channels;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var jobs = Channel.CreateBounded<int>(100);
        var results = Channel.CreateBounded<int>(100);

        // Start 10 workers
        var workers = Enumerable.Range(1, 10)
            .Select(_ => Worker(jobs.Reader, results.Writer))
            .ToArray();

        // Send 50 jobs
        var producer = Task.Run(async () =>
        {
            for (int j = 1; j <= 50; j++)
            {
                await jobs.Writer.WriteAsync(j);
            }
            jobs.Writer.Complete();
        });

        // Wait and collect
        await producer;
        await Task.WhenAll(workers);
        results.Writer.Complete();

        await foreach (var result in results.Reader.ReadAllAsync())
        {
            Console.WriteLine(result);
        }
    }

    static async Task Worker(ChannelReader<int> jobs, ChannelWriter<int> results)
    {
        await foreach (var job in jobs.ReadAllAsync())
        {
            await results.WriteAsync(job * 2);
        }
    }
}

# Build for different platforms
dotnet publish -r linux-x64
dotnet publish -r osx-arm64
dotnet publish -r win-x64

# Self-contained (بدون نیاز به runtime)
dotnet publish -r linux-x64 --self-contained

# Native AOT (جدید - مشابه Go)
dotnet publish -r linux-x64 -p:PublishAot=true

# Build for different platforms
GOOS=linux GOARCH=amd64 go build -o app-linux
GOOS=darwin GOARCH=arm64 go build -o app-mac
GOOS=windows GOARCH=amd64 go build -o app.exe

# همیشه self-contained!

using Microsoft.AspNetCore.Mvc;

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

var users = new List<User>
{
    new(1, "علی", "ali@example.com")
};

app.MapGet("/users", () => users);

app.MapGet("/users/{id}", (int id) =>
    users.FirstOrDefault(u => u.Id == id) is User user
        ? Results.Ok(user)
        : Results.NotFound());

app.MapPost("/users", (User user) =>
{
    var newUser = user with { Id = users.Count + 1 };
    users.Add(newUser);
    return Results.Created($"/users/{newUser.Id}", newUser);
});

app.Run();

record User(int Id, string Name, string Email);

package main

import (
    "net/http"
    "strconv"
    "github.com/gin-gonic/gin"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

var users = []User{
    {ID: 1, Name: "علی", Email: "ali@example.com"},
}

func main() {
    r := gin.Default()

    r.GET("/users", func(c *gin.Context) {
        c.JSON(http.StatusOK, users)
    })

    r.GET("/users/:id", func(c *gin.Context) {
        id, _ := strconv.Atoi(c.Param("id"))
        for _, u := range users {
            if u.ID == id {
                c.JSON(http.StatusOK, u)
                return
            }
        }
        c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
    })

    r.POST("/users", func(c *gin.Context) {
        var user User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        user.ID = len(users) + 1
        users = append(users, user)
        c.JSON(http.StatusCreated, user)
    })

    r.Run(":8080")
}

package main

import (
    "fmt"
    "net/http"
    "time"
)

func main() {
    // یک وب‌سرور ساده با همزمانی
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        go processRequest(r)  // Goroutine!
        fmt.Fprintf(w, "سلام!")
    })

    http.ListenAndServe(":8080", nil)
}

func processRequest(r *http.Request) {
    time.Sleep(time.Second)
    fmt.Println("Request processed:", r.URL.Path)
}