Forem: ISeeSharp

The Browser-Based Dev Tools I Actually Use

ISeeSharp — Sun, 29 Mar 2026 14:22:06 +0000

The Browser-Based Dev Tools I Actually Use

I keep a short list of browser tools I can open on any machine with no setup required. No installs, no node_modules, no npm audit warnings. Just a URL. Here are the ones that have actually stuck.

The ones I use

JSON formatting

The JSON Formatter on CalcHive is the one I've settled on. It validates as you type, handles deeply nested objects without issue, and doesn't send your data anywhere (everything runs client-side). That last part matters more than it sounds. If you're working with anything remotely sensitive (and let's be honest, you often are), pasting it into some random web app that logs it server-side is a bad habit.

JWT decoding

Every few months I get handed a JWT and need to check what's actually in the payload. Not verify it, just read it. jwt.io is fine but I've started using CalcHive's JWT decoder instead because it keeps everything local and the layout is cleaner. It separates the header, payload, and signature clearly and highlights the expiry timestamp in a way that makes it immediately obvious if the token is expired.

None of this requires a library. A JWT is just three Base64url-encoded parts separated by dots. But having a UI that just shows it to you instantly saves the mental overhead.

Base64

There are a hundred Base64 tools online and most of them are fine. The one at calchive.tools/encoding-decoding/base64 handles the edge cases properly: padding, URL-safe variants, encoding binary as well as plain text. I use this probably three or four times a week when dealing with API credentials, image data URIs, or checking what's been embedded in a config somewhere.

Regex testing

Regex is the one area where I genuinely want a full UI with real-time highlighting. Writing regex in code and running tests is fine for production, but when I'm figuring out a pattern for the first time, visual feedback is much faster.

I've tried Regex101 and it's great, but it's heavier than I sometimes need. For quick checks the CalcHive regex tester gets out of the way and just shows me which parts of my input match. That's usually all I need.

Unix timestamps

The Unix timestamp converter takes that number and tells me it's 25 April 2024. Done. You can also go the other way and turn a date into a timestamp, which is useful for database queries and filtering log streams.

URL parsing

If you need to break apart a URL and inspect its components (scheme, host, path, query params, fragment), the URL parser does exactly that. It sounds trivial but when you're staring at a redirect URL with eight query parameters and URL encoding layered on top, having it laid out clearly saves you from making a mistake.

Cron expressions

The cron parser takes an expression like 0 9 * * 1-5 and renders it in plain English: "At 09:00 AM, Monday through Friday". That's it. That's the whole tool. It's perfect.

A note on "nothing gets uploaded"

I want to come back to this because it's not just a nice-to-have. The CalcHive tools all run entirely in the browser with no server-side processing and no logging of your inputs. For developer tooling this actually matters quite a bit.

When you paste a JWT into a random tool, you're exposing user data: IDs, email addresses, roles, session info. When you paste JSON from your production database into an online formatter, you might be sending PII to some server you know nothing about. Most of the time nothing bad happens, but it's a risk you're taking for zero benefit because client-side tooling has gotten good enough that it doesn't need a server round trip to format your JSON.

A few more worth bookmarking

CalcHive also has a solid set of converters I've found myself using more than expected. The number base converter covers binary, octal, decimal and hex all in one place. The color converter handles HEX to RGB to HSL, which I end up needing whenever the design file and the CSS are in different formats. There's also a UUID generator for when you need v4 UUIDs for test fixtures and don't want to spin up a script for it.

Wrapping up

The best tool is usually the one that gets out of the way fastest. Single-purpose, well-executed, no friction. That's a decent philosophy for software in general.

If you've got a favourite dev tool I haven't mentioned, drop it in the comments. Always looking to add to the list.

Optimize your C# code with SPAN

ISeeSharp — Sat, 10 Dec 2022 17:47:11 +0000

Span is a struct in C#. A new feature introduced in C# 7.2 that allows for the representation of a contiguous region of arbitrary memory as a first-class object. This can be useful when working with large amounts of data, as it allows for more efficient memory usage and can improve performance.

Span can be is used to declare a variable of a Span type, where T is the type of the elements in the span. For example, the following code declares a Span variable called numbers:

Span<int> numbers = new int[] { 1, 2, 3, 4, 5 };

One of the main advantages of using Span is that it allows for more efficient memory usage by avoiding unnecessary copying of data. In some cases, using a Span can allow you to access data in memory directly, without having to first copy it to a separate managed array. This can result in improved performance, particularly when working with large amounts of data.

In addition to providing more efficient memory usage, Span also allows for more convenient manipulation of data. For example, the Slice() method can be used to create a new Span that represents a subset of the original span. This can be useful for accessing specific parts of a larger dataset without having to copy the entire dataset into a new array.

Here is an example of using the Slice() method to create a new Span that contains only the last three elements of the original numbers span:

Span<int> lastThreeNumbers = numbers.Slice(2, 3);

Example Usage

When working with large datasets, using Span can allow you to access and manipulate the data more efficiently. For example, if you have a large array of integers and you want to perform some operation on every tenth element, you can use the Slice() method to create a new Span that contains only those elements, and then perform the operation on the new span. This can be more efficient than copying the entire array into a new managed array.


// Create a large array of integers
int[] largeArray = new int[10000];

// Fill the array with some values
for (int i = 0; i < largeArray.Length; i++)
{
    largeArray[i] = i;
}

// Create a span that covers the entire array
Span<int> largeArraySpan = largeArray;

// Create a span that covers every tenth element of the array
Span<int> tenthElements = largeArraySpan.Slice(9, largeArraySpan.Length / 10);

// Perform some operation on every tenth element
for (int i = 0; i < tenthElements.Length; i++)
{
    tenthElements[i] *= 2;
}

The span can be useful when working with data that is stored in memory outside of the managed heap. For example, if you are working with a large byte array that is mapped to a file on disk, you can use a Span to access and manipulate the data directly, without having to first copy it to a managed array.

// Create a byte array that is mapped to a file on disk
byte[] fileData = File.ReadAllBytes("C:\\largeFile.dat");

// Create a span that covers the entire byte array
Span<byte> fileDataSpan = fileData;

// Use the span to manipulate the data directly
for (int i = 0; i < fileDataSpan.Length; i++)
{
    fileDataSpan[i] ^= 0xFF;
}

The span can be useful when implementing performance-critical algorithms that require direct access to contiguous regions of memory. For example, if you are implementing a sorting algorithm, you can use a Span to represent the data that needs to be sorted, and then use the span's methods to manipulate the data directly. This can be more efficient than using a managed array, as it allows you to avoid unnecessary copying of data.

// Create an array of integers to be sorted
int[] data = { 3, 5, 1, 7, 4, 2, 6 };

// Create a span that covers the array
Span<int> dataSpan = data;

// Implement a sorting algorithm using the span
for (int i = 0; i < dataSpan.Length - 1; i++)
{
    for (int j = i + 1; j < dataSpan.Length; j++)
    {
        if (dataSpan[i] > dataSpan[j])
        {
            int temp = dataSpan[i];
            dataSpan[i] = dataSpan[j];
            dataSpan[j] = temp;
        }
    }
}

Please check out my Youtube channel for more C# and .NET content.

https://www.youtube.com/channel/UCfZF4WWaH4i13MzEICLt6sQ

Validation in .NET Core

ISeeSharp — Sat, 10 Dec 2022 17:29:57 +0000

Introduction

In .NET Core, validation refers to the process of checking that the data provided by the user or client is in the correct format and meets the requirements of the application. This can include checks for things like required fields, minimum and maximum values, and correct data types.

To perform validation in a .NET Core API, you can use the built-in ModelState class and the [Required], [Range], and [RegularExpression] attributes. Here is an example of how these can be used to validate the data provided by the user in a controller action:

public IActionResult CreateUser([FromBody] User user)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }

    // Save the user to the database and return a success response...
}

In this example, the CreateUser action method accepts a User object as an argument. The [FromBody] attribute is used to indicate that the User object will be provided in the request body. The if statement at the beginning of the method checks the ModelState to see if the data provided by the user is valid. If the ModelState is not valid, the BadRequest method is called to return an error response to the user.

The User class itself might look like this:

public class User
{
    [Required]
    public string FirstName { get; set; }

    [Required]
    public string LastName { get; set; }

    [Required]
    [Range(1, 100)]
    public int Age { get; set; }

    [Required]
    [RegularExpression("^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+$")]
    public string Email { get; set; }
}

In this User class, the [Required] attribute is used to indicate that the FirstName, LastName, Age, and Email properties are required and must be provided by the user. The [Range] attribute is used to specify that the Age property must be a number between 1 and 100. Finally, the [RegularExpression] attribute is used to specify that the Email property must match a certain pattern (in this case, a valid email address).

When the CreateUser action method is called, the ModelState will be checked to ensure that the data provided by the user is valid. If any of the required properties are missing or if any of the properties have invalid values (e.g. if the Age property is not a number between 1 and 100, or if the Email property does not match the specified pattern), the ModelState will be considered invalid and an error response will be returned to the user. Otherwise, the user will be saved to the database and a success response will be returned.

Using [ApiController] to replace the ModelState check

To use the [ApiController] attribute, you simply need to add it to the top of the UsersController class, like this:

[ApiController]
public class UsersController : ControllerBase

This attribute indicates that the UsersController class is an API controller, which enables certain features and behaviors that are specific to API controllers in .NET Core. For example, when the [ApiController] attribute is applied to a controller, the ModelState will automatically be checked for validation errors before any action method in the controller is called, and an error response will be returned to the user if any validation errors are found. This means that you don't need to manually check the ModelState in each action method, as the attribute will handle it for you.

Additionally, the [ApiController] attribute enables the use of HTTP 400 responses for validation errors, rather than the default HTTP 500 responses. This means that when the [ApiController] attribute is applied to a controller, if any validation errors are found, the BadRequest method will automatically be called to return an HTTP 400 response to the user, rather than the InternalServerError method being called to return an HTTP 500 response. This behavior can make it easier to understand and handle validation errors in your API.

For more C# and Dotnet content see my Youtube channel: https://www.youtube.com/channel/UCfZF4WWaH4i13MzEICLt6sQ

Improve your C# with YIELD

ISeeSharp — Sat, 10 Dec 2022 17:18:37 +0000

Explanation

The yield keyword in C# is used to create an iterator method, which allows the programmer to loop through a collection of items, one at a time. It allows the code inside the iterator method to "yield" each item in the collection, one at a time, rather than returning the entire collection all at once. This can be useful when working with large collections of data, as it allows the programmer to process the data one item at a time, rather than having to load the entire collection into memory all at once.

Example

Here is an example of how the yield keyword can be used to create an iterator method in C#:

public static IEnumerable<int> GetOddNumbers(int start, int end)
{
    for (int i = start; i <= end; i++)
    {
        if (i % 2 != 0)
        {
            yield return i;
        }
    }
}

In this example, the GetOddNumbers method is an iterator method that takes a starting and ending integer as arguments, and yields all of the odd numbers between the starting and ending integers. The yield return statement is used to "return" each odd number in the range to the caller of the method, one at a time.

To use this iterator method, you could write code like this:

foreach (int oddNumber in GetOddNumbers(1, 10))
{
    Console.WriteLine(oddNumber);
}

This code would use the foreach loop to iterate over each odd number yielded by the GetOddNumbers iterator method, and print each one to the console.

USE CASES

When working with large collections of data

When working with large collections of data, such as a large list of database records or a large file containing multiple records, using the yield keyword can allow the programmer to process the data one record at a time, rather than having to load the entire collection into memory all at once. This can help to improve the performance and scalability of the application.

public static IEnumerable<DatabaseRecord> GetDatabaseRecords()
{
    using (var connection = new SqlConnection(connectionString))
    {
        connection.Open();
        var command = new SqlCommand("SELECT * FROM Records", connection);
        var reader = command.ExecuteReader();
        while (reader.Read())
        {
            yield return new DatabaseRecord(reader);
        }
    }
}

In this example, the GetDatabaseRecords method is an iterator method that yields each DatabaseRecord from a database query one at a time, rather than returning the entire collection of records all at once. This can help to improve the performance and scalability of the application, as it allows the records to be processed one at a time, rather than having to load the entire collection into memory all at once.

When working with infinite sequences or streams of data:

When working with infinite sequences or streams of data, such as a continuous stream of incoming network traffic or sensor readings, the yield keyword can be used to create an iterator method that yields each piece of data in the sequence as it becomes available, rather than having to wait for the entire sequence to be generated before processing it.

public static IEnumerable<SensorReading> GetSensorReadings()
{
    while (true)
    {
        yield return sensor.GetNextReading();
    }
}

In this example, the GetSensorReadings method is an iterator method that yields each SensorReading from a sensor as it becomes available, rather than having to wait for the entire sequence of readings to be generated before processing them. This allows the application to process the sensor readings as they are generated, rather than having to wait for the entire sequence to be generated before processing it.

When working with algorithms that generate sequences of data:

When working with algorithms that generate sequences of data, such as algorithms that generate sequences of random numbers or prime numbers, the yield keyword can be used to create an iterator method that yields each element in the generated sequence as it is produced, rather than having to generate the entire sequence at once and return it to the caller.

public static IEnumerable<int> GetRandomNumbers(int min, int max)
{
    Random random = new Random();
    while (true)
    {
        yield return random.Next(min, max);
    }
}

In this example, the GetRandomNumbers method is an iterator method that yields a sequence of random numbers. The yield return statement is used to "return" each random number in the sequence as it is generated, rather than generating the entire sequence at once and returning it to the caller. This allows the application to process the random numbers as they are generated, rather than having to wait for the entire sequence to be generated before processing it.

Please check out my Youtube channel for more C# and .NET content.

https://www.youtube.com/channel/UCfZF4WWaH4i13MzEICLt6sQ