
## Introduction

Production code fails. Clean code does not pretend failures do not exist; it handles them explicitly and consistently.

## 1) Use exceptions correctly

### Do not use exceptions for normal control flow

```csharp
// BAD
public int Parse(string input)
{
    try { return int.Parse(input); }
    catch { return -1; }
}

// GOOD
public int? Parse(string input)
    => int.TryParse(input, out var result) ? result : null;
```

### Throw specific exceptions

```csharp
public class OrderNotFoundException(int orderId)
    : Exception($"Order with ID {orderId} was not found.")
{
    public int OrderId { get; } = orderId;
}
```

Specific exception types improve logging, diagnosis, and mapping to HTTP responses.

## 2) Never swallow exceptions silently

```csharp
try
{
    await ProcessOrderAsync(orderId, ct);
}
catch (Exception ex)
{
    _logger.LogError(ex, "Failed to process order {OrderId}", orderId);
    throw;
}
```

If you catch, either:

- recover meaningfully, or
- enrich and rethrow

## 3) Standardize API errors with ProblemDetails

```csharp
public class GlobalExceptionHandler(ILogger<GlobalExceptionHandler> logger)
    : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(
        HttpContext context,
        Exception exception,
        CancellationToken ct)
    {
        logger.LogError(exception, "Unhandled exception");

        var details = new ProblemDetails
        {
            Status = StatusCodes.Status500InternalServerError,
            Title = "An unexpected error occurred",
            Type = "https://tools.ietf.org/html/rfc9110#section-15.6.1"
        };

        context.Response.StatusCode = details.Status.Value;
        await context.Response.WriteAsJsonAsync(details, ct);
        return true;
    }
}
```

A consistent response structure helps API clients and monitoring tools.

## 4) Validate input at boundaries

Boundary validation keeps invalid data from leaking deep into the domain.

### API request validation (FluentValidation)

```csharp
public class CreateOrderRequestValidator : AbstractValidator<CreateOrderRequest>
{
    public CreateOrderRequestValidator()
    {
        RuleFor(x => x.CustomerId).NotEmpty();
        RuleFor(x => x.Items).NotEmpty();
        RuleForEach(x => x.Items).ChildRules(item =>
        {
            item.RuleFor(i => i.Quantity).GreaterThan(0);
            item.RuleFor(i => i.Price).GreaterThan(0);
        });
    }
}
```

### Guard clauses inside services/domain

```csharp
public class OrderService(IOrderRepository repository)
{
    public async Task<Order> GetByIdAsync(int id, CancellationToken ct)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(id);

        return await repository.GetByIdAsync(id, ct)
            ?? throw new OrderNotFoundException(id);
    }
}
```

## 5) Prefer immutability for safety

```csharp
public record OrderDto(int Id, string CustomerName, decimal Total, DateTime CreatedAt);

public readonly record struct OrderId(int Value);
public readonly record struct CustomerId(int Value);
```

Strong types and immutable models reduce accidental state bugs.

## Summary

Reliable C# systems combine:

- clear validation boundaries
- specific exceptions
- structured error responses
- immutable and strongly-typed models

This approach makes failures understandable and recoverable.


Build resilient C# APIs with specific exceptions, ProblemDetails, validation boundaries, and immutable models.

C# Error Handling and Defensive Coding in ASP.NET Core — Clean Code


## Table of Contents

1. [Introduction](#introduction)
2. [GitHub Resources](#github-resources)
3. [Useful URLs](#useful-urls)
4. [Known Issues](#known-issues)
5. [Conclusion](#conclusion)

## Introduction

This post is a collection of useful links and resources related to Pokemon Go API development, including API endpoints, developer communities, protocol buffers, and tools.

## GitHub Resources

### PokemonGo-Bot - Python

### PokemonGo-Bot GitHub

https://github.com/PokemonGoF/PokemonGo-Bot/issues/2540

### Protobuf GitHub

https://github.com/google/protobuf/releases/tag/v3.0.0

### Protobuf-net GitHub (.NET Library)

https://github.com/mgravell/protobuf-net

### Latest Protos for Pokemon Go

https://github.com/AeonLucid/POGOProtos

### Pokemon API Demo - GitHub

https://github.com/tejado/pgoapi/tree/master/old-demo

### Pokemon Go Map - GitHub

https://github.com/AHAAAAAAA/PokemonGo-Map

## Useful URLs

### PokeAPI

https://pokeapi.co/docsv2/#locations-section

### PokeAPI YouTube

https://www.youtube.com/watch?v=Y2a0Xv3giho

### PokemonGO Developers (Reddit)

https://www.reddit.com/r/pokemongodev/

### API Status

https://www.reddit.com/r/pokemongodev/comments/4w1cvr/pokemongo_current_api_status/

### Is Pokemon Go Down?

http://ispokemongodownornot.com/

### Google Protocol Buffers

https://developers.google.com/protocol-buffers/docs/downloads

### Niantic Blog

https://nianticlabs.com/blog/

### Pokemon Go API - ProgrammableWeb

http://www.programmableweb.com/api/unofficial-pok%C3%A9mon-go

### Pokemondb.net

http://pokemondb.net/mechanics/move-tutors

## Known Issues

Proto3 syntax requires installing the latest proto 3.0: https://github.com/golang/protobuf/issues/24. The error "expected top-level statement (e.g. 'message')" might occur because the proto version is different: http://blog.csdn.net/luna84/article/details/8696474

## Conclusion

This post serves as a reference collection for Pokemon Go API development. The resources include official and community tools, API documentation, protocol buffer libraries, and developer communities that can help you get started with Pokemon Go API development.


A collection of useful links and resources for Pokemon Go API development, including API endpoints, tools, and community resources.

API

C# Error Handling and Defensive Coding in ASP.NET Core — Clean Code

Pokemon API Development Info