Developer Advocate

public interface ITenantProvider
{
    Guid TenantId { get; }
}

public class TenantProvider : ITenantProvider
{
    private readonly IHttpContextAccessor _httpContextAccessor;

    public TenantProvider(IHttpContextAccessor accessor)
    {
        _httpContextAccessor = accessor;
    }

    public Guid TenantId =>
        Guid.Parse(_httpContextAccessor.HttpContext.User.FindFirst("tenant_id").Value);
}

public interface ITenantEntity
{
    Guid TenantId { get; set; }
}

public class Product : ITenantEntity
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Guid TenantId { get; set; }
    // سایر فیلدها...
}

public class AppDbContext : DbContext
{
    private readonly ITenantProvider _tenantProvider;

    public AppDbContext(DbContextOptions<AppDbContext> options, ITenantProvider tenantProvider)
        : base(options)
    {
        _tenantProvider = tenantProvider;
    }

    public DbSet<Product> Products { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // فیلتر همه Entityهای tenant-aware:
        foreach (var entityType in modelBuilder.Model.GetEntityTypes()
            .Where(e => typeof(ITenantEntity).IsAssignableFrom(e.ClrType)))
        {
            // مقدار پارامتر Query Filter را برای EF Core توضیح می‌دهیم
            var method = typeof(AppDbContext).GetMethod(nameof(SetGlobalQueryForTenant), BindingFlags.NonPublic | BindingFlags.Instance)
                .MakeGenericMethod(entityType.ClrType);

            method.Invoke(this, new object[] { modelBuilder });
        }
    }

    // این تابع با Reflection برای هر entity فراخوانی می‌شود
    private void SetGlobalQueryForTenant<TEntity>(ModelBuilder modelBuilder) where TEntity : class, ITenantEntity
    {
        modelBuilder.Entity<TEntity>().HasQueryFilter(x => x.TenantId == _tenantProvider.TenantId);
    }
}

  public class OrderService(ILogger<OrderService> logger, IUnitOfWork unitOfWork)
  {
      public void PlaceOrder(Order order)
      {
          logger.LogInformation("Placing order...");
          unitOfWork.Save(order);
      }
  }
  

  public class Product(string name, decimal price)
  {
      public string Name => name;
      public decimal Price => price;
  }
  

  public class Entity(Guid id)
  {
      public Guid Id => id;
  }

  public class User(Guid id, string username) : Entity(id)
  {
      public string Username => username;
  }
  

CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    data JSONB
);

{
  "title": "Logitech MX Master 3",
  "description": "Wireless mouse for advanced users",
  "category": "Mouse"
}

CREATE INDEX idx_products_search 
ON products
USING GIN (
    to_tsvector('english',
        coalesce(data->>'title', '') || ' ' || coalesce(data->>'description', '')
    )
);

SELECT *
FROM products
WHERE to_tsvector('english', 
        coalesce(data->>'title', '') || ' ' || coalesce(data->>'description', '')
      ) @@ plainto_tsquery('english', 'wireless advanced');

context.Products
    .Where(p =>
        EF.Functions.ToTsVector("english", 
            (string)p.Data["title"] + " " + (string)p.Data["description"]
        )
        .Matches(EF.Functions.PlainToTsQuery("english", "wireless advanced"))
    )
    .ToList();

// این یک Server Component است و فقط در سرور اجرا می‌شود.
export default async function LatestPosts() {
  const posts = await getLatestPostsFromDatabase();
  return (
    <ul>
      {posts.map(post => <li key={post.id}>{post.title}</li>)}
    </ul>
  );
}

// این یک Client Component است، مثلاً برای تعامل لحظه‌ای.
'use client';

export function LikeButton({ postId }) {
  // منطق state و event handling اینجا قرار می‌گیرد
  // ...
}

public class ProductDto
{
    public Guid Id { get; set; }
    public required string Name { get; set; }
    public decimal Price { get; set; }
}

[ApiController]
[Route("api/products")]
public class ProductController : ControllerBase
{
    [HttpGet]
    public ActionResult<IEnumerable<ProductDto>> Get() => ...;
}

TypeSync --input MyProject.dll --output types/api.d.ts
// یا:
dotnet njsonschema codegenerate-ts --input MyProject.dll --output api.ts

export interface ProductDto {
    id: string;
    name: string;
    price: number;
}

import { ProductDto } from './types/api';

async function fetchProducts(): Promise<ProductDto[]> {
  const res = await fetch('/api/products');
  return res.json();
}

// مصرف در komponent:
const { data } = useQuery<ProductDto[]>('products', fetchProducts);

// روش سنتی
[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern int MessageBoxW(IntPtr hWnd, string text, string caption, uint type);

// روش مدرن
[LibraryImport("user32.dll", SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
public static partial int MessageBoxW(IntPtr hWnd, string text, string caption, uint type);

  <PackageReference Include="System.Runtime.InteropServices" Version="7.0.0" />
  

var builder = WebApplication.CreateBuilder(args);

// Dependency Injection با سبک جدید
builder.Services.AddDbContext<AppDbContext>(o => /* ... */);
builder.Services.AddScoped<IWeatherService, WeatherService>();

var app = builder.Build();

// OpenAPI integration (در ۳ خط!)
app.MapGet("/weather/{city}", async (string city, IWeatherService svc) =>
{
    var report = await svc.GetWeatherAsync(city);
    return report is null ? Results.NotFound() : Results.Ok(report);
})
.WithName("GetWeather") // قابلیت‌های پیشرفته مثل tagging و versioning!
.Produces<WeatherReport>(StatusCodes.Status200OK)
.Produces(StatusCodes.Status404NotFound);

app.Run();

app.Use(async (context, next) =>
{
    context.Response.Headers.Add("Content-Security-Policy",
        "default-src 'self'; script-src 'self'; style-src 'self'; object-src 'none';");
    await next();
});

app.Use(async (context, next) =>
{
    var nonce = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
    context.Items["CspNonce"] = nonce;

    context.Response.Headers.Add("Content-Security-Policy",
        $"default-src 'self'; script-src 'self' 'nonce-{nonce}';");
    await next();
});

<script nonce="@Context.Items["CspNonce"]">
    // اسکریپت امن اینجا قرار می‌گیرد
</script>

public class SimpleRateLimiter
{
    private readonly MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
    private readonly int _maxAttempts = 5;
    private readonly TimeSpan _timeWindow = TimeSpan.FromMinutes(5);

    public bool IsAllowed(string key)
    {
        var value = _cache.GetOrCreate(key, entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = _timeWindow;
            return 0;
        });

        int current = (int)value;
        if (current >= _maxAttempts)
            return false;

        _cache.Set(key, current + 1, TimeSpan.FromMinutes(5));
        return true;
    }
}

var limiter = new SimpleRateLimiter();
if (!limiter.IsAllowed(Request.HttpContext.Connection.RemoteIpAddress.ToString()))
    return Unauthorized("Too many login attempts, please wait.");

    public class Customer(string name, string email)
    {
        public string Name { get; } = name;
        public string Email { get; } = email;
    }
    

    public class OrderService(ILogger logger, IOrderRepository repository) { /* ... */ }
    

    public class BaseProcessor(string contextPath) { /* ... */ }
    public class FileProcessor(string contextPath, string filePath) : BaseProcessor(contextPath) { /* ... */ }
    

.github/
  actions/
    sync-version/
      action.yml
      index.js
      package.json

name: Sync Version to AssemblyInfo
description: Update version in AssemblyInfo.cs from git tag
runs:
  using: 'node16'
  main: 'index.js'
inputs:
  file-path:
    description: 'Path to AssemblyInfo.cs'
    required: true
  version-regex:
    description: 'Regex pattern for AssemblyVersion'
    required: false
    default: '(?<=\[assembly: AssemblyVersion\(")(.+?)(?="\)\])'

const core = require('@actions/core');
const fs = require('fs');

try {
    const filePath = core.getInput('file-path', { required: true });
    const versionRegex = new RegExp(core.getInput('version-regex'), 'g');
    const gitRef = process.env.GITHUB_REF || '';
    // استخراج نسخه از تگ: refs/tags/v1.2.3 -> 1.2.3
    const versionMatch = gitRef.match(/refs\/tags\/v?(\d+\.\d+\.\d+)/);
    if (!versionMatch) {
        core.setFailed('No version tag found in GITHUB_REF.');
        return;
    }
    const version = versionMatch[1];

    let text = fs.readFileSync(filePath, 'utf8');
    text = text.replace(versionRegex, version);
    fs.writeFileSync(filePath, text, 'utf8');
    core.info(`Version in ${filePath} synced to ${version}`);
} catch (error) {
    core.setFailed(error.message);
}

- name: Sync version in AssemblyInfo
  uses: ./.github/actions/sync-version
  with:
    file-path: 'src/MyProject/Properties/AssemblyInfo.cs'

public interface IOrderService
{
    Task<OrderResult> PlaceOrderAsync(OrderCommand command, CancellationToken token);
}

public class PlaceOrderCommandHandler : IRequestHandler<PlaceOrderCommand, OrderResult>
{
    private readonly IOrderService _orderService;

    public PlaceOrderCommandHandler(IOrderService orderService)
    {
        _orderService = orderService;
    }

    public async Task<OrderResult> Handle(PlaceOrderCommand command, CancellationToken cancellationToken)
    {
        return await _orderService.PlaceOrderAsync(command, cancellationToken);
    }
}

var activeUserNames = users
    .Where(u => u.IsActive)
    .Select(u => u.Name)
    .ToList();

var userNames = users
    .Select(u => u.Name)
    .Where(name => users.First(x => x.Name == name).IsActive)
    .ToList();

var activeUserNames = users
    .Where(u => u.IsActive)
    .Select(u => u.Name)
    .ToList();

{
  "name": "Full-Stack .NET & React DevContainer",
  "image": "mcr.microsoft.com/devcontainers/dotnet:8.0", // داکر ایمیج رسمی .NET 8
  "features": {
    "ghcr.io/devcontainers/features/node:1": {
      "version": "18"
    }
  },
  "postCreateCommand": "dotnet tool restore && npm install --prefix ClientApp",
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-dotnettools.csharp",
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode"
      ]
    }
  },
  "ports": [
    5000, // پورت پیش‌فرض ASP.NET
    3000  // پورت پیش‌فرض React - قابل تنظیم با توجه به پروژه
  ],
  "forwardPorts": [5000, 3000],
  "remoteUser": "vscode"
}

// قیمت‌گذاری سفارش، به تکرار در چند سرویس مختلف
if (order.Type == OrderType.Express) {
    price += 20000;
    // کدهای مشابه در چندین کلاس
}

public interface IPricingStrategy {
    int Calculate(Order order);
}

public class ExpressPricingStrategy : IPricingStrategy {
    public int Calculate(Order order) => order.BasePrice + 20000;
}
// تزریق اینترفیس به جای تکرار منطق

builder.Services.AddOpenTelemetry()
    .WithMetrics(metrics =>
    {
        metrics.AddAspNetCoreInstrumentation();
        metrics.AddPrometheusExporter(); // export metrcis for Prometheus
    })
    .WithTracing(tracing =>
    {
        tracing.AddAspNetCoreInstrumentation();
        tracing.AddJaegerExporter(); // distributed tracing
    });

public class IntegrationEvent
{
    public Guid Id { get; set; }
    public string Type { get; set; }
    public string Payload { get; set; }
    public DateTime OccurredAt { get; set; }
}

public class AppDbContext : DbContext
{
    public DbSet<IntegrationEvent> OutboxEvents { get; set; }
    // ... سایر موجودیت‌ها
}

// سرویس دامین:
public async Task PlaceOrderAsync(Order order)
{
    using var trx = await db.Database.BeginTransactionAsync();

    db.Orders.Add(order);

    db.OutboxEvents.Add(new IntegrationEvent {
        Id = Guid.NewGuid(),
        Type = "OrderPlaced",
        Payload = Serialize(order),
        OccurredAt = DateTime.UtcNow
    });

    await db.SaveChangesAsync();
    await trx.CommitAsync();
}

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Console.WriteLine("Concurrency (هم‌زمانی):");        
        ConcurrencyExample();

        Console.WriteLine("\nParallelism (موازی):");
        ParallelismExample();
    }

    static void ConcurrencyExample()
    {
        for (int i = 1; i <= 3; i++)
        {
            // هر Task بلافاصله استارت می‌زند اما Scheduler می‌تواند آن‌ها را روی یک Thread اجرا کند
            Task.Run(() => DoWork($"Task {i} (concurrent)"));
        }
        Thread.Sleep(1500); // منتظر ماندن برای تکمیل نمایش
    }

    static void ParallelismExample()
    {
        // Parallel.For واقعی روی چند هسته اجرا می‌شود (در صورت وجود منابع)
        Parallel.For(1, 4, i =>
        {
            DoWork($"Parallel Task {i}");
        });
    }

    static void DoWork(string name)
    {
        Console.WriteLine($"{name} شروع شد در ThreadId: {Thread.CurrentThread.ManagedThreadId}");
        Thread.Sleep(500); // شبیه‌سازی پردازش
        Console.WriteLine($"{name} پایان یافت در ThreadId: {Thread.CurrentThread.ManagedThreadId}");
    }
}

public class MessageSentEventArgs : EventArgs
{
    public string Recipient { get; }
    public string Body { get; }

    public MessageSentEventArgs(string recipient, string body)
    {
        Recipient = recipient;
        Body = body;
    }
}

public class NotificationService
{
    public event EventHandler<MessageSentEventArgs>? MessageSent;

    public void Send(string recipient, string body)
    {
        // ارسال پیام فرضی
        // ...

        OnMessageSent(new MessageSentEventArgs(recipient, body));
    }

    protected virtual void OnMessageSent(MessageSentEventArgs e)
    {
        MessageSent?.Invoke(this, e);
    }
}

var notifications = new NotificationService();

// ثبت dynamic handler با lambda inline
notifications.MessageSent += (sender, e) =>
{
    Console.WriteLine($"🔔 پیام به {e.Recipient}: {e.Body}");
};

// اجرای رخداد
notifications.Send("ali@domain.com", "سلام علی!");

/*
🔔 پیام به ali@domain.com: سلام علی!
*/

  services.AddSingleton<NotificationService>();
  notifications.MessageSent += scopedHandler.HandleAsync;
  

private static readonly HttpClient _httpClient = new HttpClient
{
    Timeout = TimeSpan.FromSeconds(5)
};

dotnet publish -r linux-x64 -c Release /p:PublishAot=true