CSharpEssentials.Errors v2.0.8 — nugetz

Maybe<string> someValue = Maybe.From("Hello");
Maybe<string> noValue = Maybe.None;

// LINQ support
var result = someValue
    .Select(str => str.ToUpper())
    .Where(str => str.Length > 5);

public Result<User> CreateUser(UserDto dto)
{
    if (string.IsNullOrEmpty(dto.Email))
        return Error.Validation("EMAIL_REQUIRED", "Email is required");

    var user = new User(dto);
    return Result<User>.Success(user);
}

public class EmailValidationRule : IRule<string>
{
    public Result Evaluate(string email, CancellationToken cancellationToken = default)
    {
        return email.Contains("@")
            ? Result.Success()
            : Error.Validation("INVALID_EMAIL", "Email must contain @");
    }
}

var error = Error.Validation(
    code: "USER_INVALID_AGE",
    description: "User age must be greater than 18"
);

public Any<string, int> ParseOrKeepAsString(string input)
{
    return int.TryParse(input, out int number)
        ? number
        : input;
}

public class Product : SoftDeletableEntityBase<Guid>
{
    private Product(string name, decimal price)
    {
        Id = Guid.NewGuid();
        Name = name;
        Price = price;
    }

    public static Product Create(string name, decimal price)
    {
        var product = new Product(name, price);
        product.Raise(new ProductCreatedEvent(product.Id));
        return product;
    }
}

// Configure in DbContext
public void Configure(EntityTypeBuilder<Product> builder)
{
    builder.SoftDeletableEntityBaseGuidIdMap();
    builder.OptimisticConcurrencyVersionMap();
}

public class OrderService
{
    private readonly IDateTimeProvider _dateTimeProvider;

    public Order CreateOrder()
    {
        return new Order { CreatedAt = _dateTimeProvider.UtcNow };
    }
}

var options = EnhancedJsonSerializerOptions.DefaultOptions;
string json = myObject.ConvertToJson(options);

// String transformations
"helloWorld".ToPascalCase();  // => "HelloWorld"
"hello_world".ToCamelCase();  // => "helloWorld"

// Collection operations
var randomItem = list.GetRandomItem();

public void Configure(IApplicationBuilder app)
{
    app.AddRequestResponseLogging(opt =>
    {
        // Configure logging options
        var loggingOptions = LoggingOptions.CreateAllFields();
        loggingOptions.HeaderKeys.Add("X-Correlation-Id");

        // Use the configured logger
        opt.UseLogger(app.Services.GetRequiredService<ILoggerFactory>(), loggingOptions);
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddExceptionHandler<GlobalExceptionHandler>()
        .ConfigureModelValidatorResponse()
        .ConfigureSystemTextJson()
        .AddEnhancedProblemDetails()
        .AddAndConfigureApiVersioning()
        .AddSwagger<DefaultConfigureSwaggerOptions>(
            SecuritySchemes.JwtBearerTokenSecurity,
            Assembly.GetExecutingAssembly()
        );
}

public void Configure(IApplicationBuilder app)
{
    app.UseVersionableSwagger();
    app.UseExceptionHandler();
    app.UseStatusCodePages();
}

// Basic configuration in Program.cs or Startup.cs
builder.Configuration.AddGcpSecretManager();

// Advanced configuration with options
builder.Configuration.AddGcpSecretManager(options =>
{
    options.CredentialsPath = "/path/to/credentials.json";
    options.AddProject(new ProjectSecretConfiguration
    {
        ProjectId = "your-gcp-project-id",
        Region = "europe-west1",
        PrefixFilters = ["app_", "service_"],
        SecretIds = ["specific-secret1"],
        RawSecretIds = ["config-json"],      // Skip JSON parsing for these secrets
        RawSecretPrefixes = ["raw_"]         // Skip JSON parsing for secrets with these prefixes
    });
});

// Configuration in appsettings.json
{
  "GoogleSecretManager": {
    "Projects": [
      {
        "ProjectId": "your-gcp-project-id",
        "Region": "europe-west1",
        "PrefixFilters": ["app_"],
        "SecretIds": ["specific-secret1"],
        "RawSecretIds": ["config-json"],
        "RawSecretPrefixes": ["raw_"]
      }
    ]
  }
}

dotnet add package CSharpEssentials

dotnet add package CSharpEssentials.Core

dotnet add package CSharpEssentials.Maybe

dotnet add package CSharpEssentials.Results

dotnet add package CSharpEssentials.Any

dotnet add package CSharpEssentials.Errors

dotnet add package CSharpEssentials.Rules

dotnet add package CSharpEssentials.Entity

dotnet add package CSharpEssentials.EntityFrameworkCore

dotnet add package CSharpEssentials.AspNetCore

dotnet add package CSharpEssentials.Json

dotnet add package CSharpEssentials.Time

dotnet add package CSharpEssentials.Clone

dotnet add package CSharpEssentials.Enums

dotnet add package CSharpEssentials.RequestResponseLogging

dotnet add package CSharpEssentials.GcpSecretManager

// Core functionality
using CSharpEssentials;

// Entity Framework Core integration
using CSharpEssentials.EntityFrameworkCore;

// ASP.NET Core integration
using CSharpEssentials.AspNetCore;

// Request Response Logging
using CSharpEssentials.RequestResponseLogging;

# Basic build and package (no publishing)
./build-and-publish-nugets.sh

# Build, package and publish to NuGet.org
./build-and-publish-nugets.sh YOUR_API_KEY

# Use parallel processing for faster builds
./build-and-publish-nugets.sh --parallel YOUR_API_KEY

# Preview what would happen (dry run)
./build-and-publish-nugets.sh --dry-run --verbose YOUR_API_KEY

# Skip build and only package existing builds
./build-and-publish-nugets.sh --skip-build YOUR_API_KEY

# Force package even with warnings (for NU5017 errors)
./build-and-publish-nugets.sh --force-pack YOUR_API_KEY

# Show help
./build-and-publish-nugets.sh --help

# Clone the repository
git clone https://github.com/senrecep/CSharpEssentials.git
cd CSharpEssentials

# Build all packages
./build-and-publish-nugets.sh

# Run tests (if available)
dotnet test

# Build and publish with API key
./build-and-publish-nugets.sh --parallel YOUR_NUGET_API_KEY

recepsen/CSharpEssentials.Errorsv2.0.8

Get Started

Readme

CSharpEssentials

🌟 Package Information

🌟 Key Features

📦 Core Modules

Maybe Monad

Result Pattern

Rule Engine

Error Types

Discriminated Unions

Entity Framework Support

Time Management

JSON Utilities

Extensions

Request Response Logging

ASP.NET Core Integration

Google Cloud Secret Manager Integration

Secret Management

🚀 Getting Started

Installation

Core Package

Core Utilities

Functional Programming

Error Handling & Validation

Domain Modeling

Entity Framework Core Integration

ASP.NET Core Integration

JSON Utilities

Time Management

Object Cloning

Enum Utilities

Request Response Logging

Google Cloud Secret Manager Integration

Basic Setup

📚 Documentation

Core Modules Documentation

Functional Programming Essentials

Error Handling & Validation

Domain Modeling

Infrastructure & Utilities

Integration Modules Documentation

Web Development

Data Access

Logging and Monitoring

Secret Management

Package-Specific Documentation

Core Packages

Functional Programming

Error Handling

Domain & Infrastructure

Integration Packages

Getting Help

🔧 Best Practices

Error Handling

Domain Modeling

Functional Programming

ASP.NET Core Integration

Entity Framework Core

Testing

Performance

Secret Management

🔧 Development

Building and Publishing NuGet Packages

Features

Usage Examples

Package Dependency Levels

Script Options

Development Workflow

🤝 Contributing

📄 License

🙏 Acknowledgments

📬 Support

🔍 Related Projects