گولنگ در مقابل C# - مقایسه Go و C#

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")
}