My.Boilerplate.Codes.2026

KO | EN

gitlite — search

#python #hacktoberfest #typescript #llm #machine-learning #rust #deep-learning #linux #docker #java #kubernetes #awesome-list #vue #mcp

My.Boilerplate.Codes.2026

(★ 97)

.NET projelerimde sıklıkla kullandığım temel kod parçalarını içermektedir

My.Boilerplate.Codes.2026 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# .NET Boilerplate Kodları

Bu documentation, .NET projelerimde sıklıkla kullandığım temel kod parçalarını içermektedir.

## İçindekiler

1. [Entity Base Sınıfı](#entity-base-sınıfı)
2. [SaveChanges Override](#savechanges-override)
3. [Global Query Filters](#global-query-filters)
4. [Password Hashing](#password-hashing)
5. [Validation Behavior](#validation-behavior)
6. [Permission Behavior](#permission-behavior)
7. [Exception Handler](#exception-handler)
8. [OData](#odata)

---

## Entity Base Sınıfı

Tüm entity'lerin türetileceği temel sınıf ve IdentityId value object'i içerir. Soft delete özelliği ve audit alanlarını yönetir.

```csharp
public abstract class Entity
{
    public Entity()
    {
        Id = Guid.CreateVersion7();
    }
    public Guid Id { get; private set; }
    public Guid CreatedBy { get; private set; } = default!;
    public DateTimeOffset CreatedAt { get; private set; } = default!;
    public Guid? UpdatedBy { get; private set; }
    public DateTimeOffset? UpdatedAt { get; private set; }
    public Guid? DeletedBy { get; private set; }
    public DateTimeOffset? DeletedAt { get; private set; }
    public bool IsDeleted { get; private set; }

public void Delete()
    {
        IsDeleted = true;
    }
}
```

---

## SaveChanges Override

DbContext'te SaveChangesAsync metodunu override ederek audit alanlarının otomatik doldurulmasını sağlar.

```csharp
public interface IUserContext
{
    Guid GetUserId();
}

public sealed class UserContext(IHttpContextAccessor httpContextAccessor)
    : IUserContext
{
    public Guid GetUserId()
    {
        var userIdString = httpContextAccessor
            .HttpContext?
            .User
            .FindFirstValue(ClaimTypes.NameIdentifier);

if (userIdString is null)
        {
            throw new UnauthorizedAccessException();
        }

return Guid.Parse(userIdString);
    }
}
```
```csharp
builder.Services.AddHttpContextAccessor();
builder.Services.AddScoped<IUserContext, UserContext>();
```

```csharp
public sealed class AuditSaveChangesInterceptor(
    IUserContext userContext)
    : SaveChangesInterceptor
{
    public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
        DbContextEventData eventData,
        InterceptionResult<int> result,
        CancellationToken cancellationToken = default)
    {
        var context = eventData.Context;

if (context is null)
            return base.SavingChangesAsync(
                eventData,
                result,
                cancellationToken);

var userId = userContext.GetUserId();

foreach (var entry in context.ChangeTracker.Entries<Entity>())
        {
            if (entry.State == EntityState.Added)
            {
                entry.Property(p => p.CreatedAt).CurrentValue =
                    DateTimeOffset.UtcNow;

entry.Property(p => p.CreatedBy).CurrentValue =
                    userId;
            }

if (entry.State == EntityState.Modified)
            {
                if (entry.Property(p => p.IsDeleted).CurrentValue)
                {
                    entry.Property(p => p.DeletedAt).CurrentValue =
                        DateTimeOffset.UtcNow;

entry.Property(p => p.DeletedBy).CurrentValue =
                        userId;
                }
                else
                {
                    entry.Property(p => p.UpdatedAt).CurrentValue =
                        DateTimeOffset.UtcNow;

entry.Property(p => p.UpdatedBy).CurrentValue =
                        userId;
                }
            }

if (entry.State == EntityState.Deleted)
            {
                throw new InvalidOperationException(
                    "Db'den direkt silme işlemi yapamazsınız.");
            }
        }

return base.SavingChangesAsync(
            eventData,
            result,
            cancellationToken);
    }
}
```

```csharp
builder.Services.AddScoped<AuditSaveChangesInterceptor>();

builder.Services.AddDbContext<ApplicationDbContext>(
    (sp, options) =>
{
    options.AddInterceptors(
        sp.GetRequiredService<AuditSaveChangesInterceptor>());
});
```

---

## Global Query Filters

Soft delete özelliğine sahip tüm entity'lere otomatik olarak query filter uygular.

```csharp
public static class ExtensionMethods
{
    public static void ApplyGlobalFilters(this ModelBuilder modelBuilder)
    {
        foreach (var entityType in modelBuilder.Model.GetEntityTypes())
        {
            var clrType = entityType.ClrType;

if (typeof(Entity).IsAssignableFrom(clrType))
            {
                var parameter = Expression.Parameter(clrType, "e");
                var property = Expression.Property(parameter, nameof(IHasSoftDelete.IsDeleted));
                var condition = Expression.Equal(property, Expression.Constant(false));
                var lambda = Expression.Lambda(condition, parameter);

entityType.SetQueryFilter(lambda);
            }
        }
    }
}
```

Uygulamak için Dbcontext OnModelCreating'de bu metodu çağırıyoruz.
```csharp
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.ApplyGlobalFilters();
    base.OnModelCreating(modelBuilder);
}
```

---

## Password Hashing

Şifreleri güvenli bir şekilde hash'lemek için kullanılan Password value object'i.

```csharp
public sealed record Password
{
    private Password()
    {
    }

public Password(string password)
    {
        var passwordHasher = new PasswordHasher<object>();

PasswordHash = passwordHasher.HashPassword(
            null!,
            password);
    }

public string PasswordHash { get; private set; } = default!;

public bool Verify(string password)
    {
        var passwordHasher = new PasswordHasher<object>();

var result = passwordHasher.VerifyHashedPassword(
            null!,
            PasswordHash,
            password);

return result != PasswordVerificationResult.Failed;
    }
}
```

---

## Validation Behavior

MediatR pipeline'ında FluentValidation ile otomatik doğrulama yapan behavior.

```csharp
public sealed class ValidationBehavior<TRequest, TResponse>(
    IEnumerable<IValidator<TRequest>> validators)
    : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>, new()
{
    private readonly IValidator<TRequest>[] _validators =
        validators.ToArray();

public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken = default)
    {
        if (_validators.Length == 0)
        {
            return await next();
        }

var context = new ValidationContext<TRequest>(request);

var validationResults = await Task.WhenAll(
            _validators.Select(x =>
                x.ValidateAsync(context, cancellationToken)));

var errors = validationResults
            .SelectMany(x => x.Errors)
            .Where(x => x is not null)
            .DistinctBy(x => new { x.PropertyName, x.ErrorMessage })
            .ToList();

if (errors.Count != 0)
        {
            throw new ValidationException(errors);
        }

return await next();
    }
}
```

---

## Permission Behavior

MediatR pipeline'ında yetki kontrolü yapan behavior.

```csharp
public sealed class PermissionBehavior<TRequest, TResponse>(
    IUserContext userContext,
    IUserRepository userRepository) : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken = default)
    {
        var attr = request.GetType().GetCustomAttribute<PermissionAttribute>(inherit: true);

if (attr is null) return await next();

var userId = userContext.GetUserId();
        var user = await userRepository.FirstOrDefaultAsync(p => p.Id == userId, cancellationToken);
        if (user is null)
        {
            throw new ArgumentException("User bulunamadı");
        }

// Eğer permission string'i varsa kontrol et
        if (!string.IsNullOrEmpty(attr.Permission))
        {
            var hasPermission = user.Permissions.Any(p => p.Name == attr.Permission);
            if (!hasPermission)
            {
                throw new AuthorizationException($"'{attr.Permission}' yetkisine sahip değilsiniz.");
            }
        }

// Eğer permission string'i yoksa sadece admin kontrolü yap
        else if (!user.IsAdmin.Value)
        {
            throw new AuthorizationException("Bu işlem için admin yetkisi gereklidir.");
        }

return await next();
    }
}

public sealed class PermissionAttribute : Attribute
{
    public string? Permission { get; }

public PermissionAttribute()
    {
    }

public PermissionAttribute(string permission)
    {
        Permission = permission;
    }
}

public sealed class AuthorizationException : Exception
{
    public AuthorizationException() : base("Yetkiniz bulunmamaktadır.")
    {
    }

public AuthorizationException(string message) : base(message)
    {
    }
}
```

Kullanmak istediğiniz CQRS Request classınızın üstünde çağırıyorsunuz.

```csharp
[Permission]
public sealed record DeveloperCreateCommand(
    string Name
) : IRequest<Result<string>>;

[Permission("permission.create")]
public sealed record DeveloperCreateCommand(
    string Name
) : IRequest<Result<string>>;
```

---

## Exception Handler

Global exception handling için kullanılan handler.

```csharp
public sealed class ExceptionHandler : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken)
    {
        Result<string> errorResult;

httpContext.Response.ContentType = "application/json";
        httpContext.Response.StatusCode = 500;

var actualException = exception is AggregateException agg && agg.InnerException != null
        ? agg.InnerException
        : exception;

var exceptionType = actualException.GetType();
        var validationExceptionType = typeof(ValidationException);
        var authorizationExceptionType = typeof(AuthorizationException);

if (exceptionType == validationExceptionType)
        {
            httpContext.Response.StatusCode = 422;

errorResult = Result<string>.Failure(422, ((ValidationException)exception).Errors.Select(s => s.ErrorMessage).ToList());

await httpContext.Response.WriteAsJsonAsync(errorResult);

return true;
        }

if (exceptionType == authorizationExceptionType)
        {
            httpContext.Response.StatusCode = 403;
            errorResult = Result<string>.Failure(403, "Bu işlem için yetkiniz yok");
            await httpContext.Response.WriteAsJsonAsync(errorResult);
            return true;
        }

errorResult = Result<string>.Failure(exception.Message);

await httpContext.Response.WriteAsJsonAsync(errorResult);

return true;
    }
}
```

---
## OData

OData yı kullanmak istiyorsak yapmamız gereken IoC service registration işlemi ve örnek controller

IoC Container (program.cs)
```csharp
builder.Services
            .AddControllers()
            .AddOData(opt =>
            opt.Select()
                .Filter()
                .Count()
                .Expand()
                .OrderBy()
                .SetMaxTop(null)
            );
```

OData Controller
```csharp
[Route("api/[controller]")]
[ApiController]
[EnableQuery]
public class ODataController : ControllerBase
{
    public static IEdmModel GetEdmModel()
    {
        ODataConventionModelBuilder builder = new();
        builder.EnableLowerCamelCase();
        //builder.EntitySet<UserResponse>("users");
        return builder.GetEdmModel();
    }
}
```

---
## Kullanım Notları

- Bu kod parçaları Clean Architecture ve DDD prensipleri göz önünde bulundurularak hazırlanmıştır
- Entity Framework Core kullanımı için optimize edilmiştir
- MediatR kütüphanesi ile CQRS pattern'i uygulamalarını destekler
- Soft delete özelliği varsayılan olarak tüm entity'lerde aktiftir
- Audit alanları otomatik olarak doldurulur
- Permission attribute ile method bazlı yetkilendirme yapılabilir

My.Boilerplate.Codes.2026

My.Boilerplate.Codes.2026 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

My.Boilerplate.Codes.2026

My.Boilerplate.Codes.2026 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README