GroupBy() is powerful but can be inefficient for multiple lookups. ToLookup() offers better performance for repeated accesses.
Problem:
var groups = numbers.GroupBy(n => n % 2); var evens = groups.First(g => g.Key == 0); //This iterates multiple times.
Solution:
var lookup = numbers.ToLookup(n => n % 2); var evens = lookup[0];This avoids unnecessary iterations.
Do
public string GetTheBestBookName(Book book) {
return $"The Best book's Name is {book.Name}. and the author name is {book.Author}";
}
Don't
public string GetTheBestBookName(Book book) {
return "The Best book's Name is " + book.Name + " and the author name is " + book.Author;
}
Do
string firstName = "John";
string lastName = "Doe";
string fullName = string.Format("{0} {1}", firstName, lastName);
Don't
string firstName = "John"; string lastName = "Doe"; string fullName = firstName + " " + lastName;
Do
using (SqlConnection connection = new SqlConnection("connection string"))
{
connection.Open();
// Do something with the connection
}
Don't
SqlConnection connection = new SqlConnection("connection string");
connection.Open();
// Do something with the connection
connection.Close();
using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
class Program
{
private static readonly SemaphoreSlim Semaphore = new SemaphoreSlim(1); // Allows one task at a time to update the counter
private static readonly int MaxCallsPerMinute = 100;
private static readonly TimeSpan RateLimitInterval = TimeSpan.FromMinutes(1);
private static int CallsMade = 0;
private static DateTime RateLimitReset = DateTime.UtcNow.Add(RateLimitInterval);
static async Task Main(string[] args)
{
string apiUrl = "https://api.example.com/endpoint";
// Simulate multiple API calls
var tasks = new Task[200]; // Simulate 200 API requests
for (int i = 0; i < tasks.Length; i++)
{
int requestId = i + 1;
tasks[i] = MakeRateLimitedCall(apiUrl, requestId);
}
// Wait for all tasks to complete
await Task.WhenAll(tasks);
Console.WriteLine("All API calls completed.");
}
private static async Task MakeRateLimitedCall(string apiUrl, int requestId)
{
// Enforce rate-limiting logic
await Semaphore.WaitAsync();
try
{
await ApplyRateLimit(requestId);
// Simulate API call
using (HttpClient client = new HttpClient())
{
Console.WriteLine($"Request {requestId}: Started.");
HttpResponseMessage response = await client.GetAsync(apiUrl);
Console.WriteLine($"Request {requestId}: Completed with status {response.StatusCode}.");
}
}
catch (Exception ex)
{
Console.WriteLine($"Request {requestId}: Error - {ex.Message}");
}
finally
{
Semaphore.Release();
}
}
private static Task ApplyRateLimit(int requestId)
{
lock (Semaphore)
{
if (DateTime.UtcNow >= RateLimitReset)
{
// Reset the counters when the time window is up
CallsMade = 0;
RateLimitReset = DateTime.UtcNow.Add(RateLimitInterval);
Console.WriteLine($"Request {requestId}: Rate limit reset.");
}
if (CallsMade >= MaxCallsPerMinute)
{
var waitTime = (int)(RateLimitReset - DateTime.UtcNow).TotalMilliseconds;
Console.WriteLine($"Request {requestId}: Rate limit reached, waiting {waitTime / 1000} seconds...");
Monitor.Wait(Semaphore, waitTime);
}
CallsMade++;
}
return Task.CompletedTask;
}
}
using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
class Program
{
// Semaphore to limit concurrent calls
private static readonly SemaphoreSlim Semaphore = new SemaphoreSlim(5); // Maximum 5 concurrent calls
static async Task Main(string[] args)
{
string apiUrl = "https://api.example.com/endpoint";
// Simulate multiple API calls
var tasks = new Task[20]; // Simulate 20 API requests
for (int i = 0; i < tasks.Length; i++)
{
int requestId = i + 1; // Capture the request ID
tasks[i] = MakeApiCallAsync(apiUrl, requestId);
}
// Wait for all tasks to complete
await Task.WhenAll(tasks);
Console.WriteLine("All API calls completed.");
}
private static async Task MakeApiCallAsync(string apiUrl, int requestId)
{
await Semaphore.WaitAsync(); // Wait for a slot to be available
try
{
using (HttpClient client = new HttpClient())
{
Console.WriteLine($"Request {requestId}: Started.");
HttpResponseMessage response = await client.GetAsync(apiUrl);
Console.WriteLine($"Request {requestId}: Completed with status {response.StatusCode}.");
}
}
catch (Exception ex)
{
Console.WriteLine($"Request {requestId}: Error - {ex.Message}");
}
finally
{
Semaphore.Release(); // Release the semaphore slot
}
}
}
Use JsonPropertyName Attribute for Camel Case Serialization
public class PersonWithAttributes
{
[JsonPropertyName("firstName")]
public string? FirstName { get; set; }
[JsonPropertyName("surname")]
public string? Surname { get; set; }
[JsonPropertyName("age")]
public int? Age { get; set; }
[JsonPropertyName("isActive")]
public bool? IsActive { get; set; }
}
Create JsonSerializerExtensions
public static class JsonSerializerExtensions
{
public static string SerializeWithCamelCase<T>(this T data)
{
return JsonSerializer.Serialize(data, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
}
public static T DeserializeFromCamelCase<T>(this string json)
{
return JsonSerializer.Deserialize<T>(json, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
}
}
How to use ?
var personWithAttributes = new PersonWithAttributes
{
Age = 20,
FirstName = "John",
Surname = "Doe",
IsActive = true
};
JsonSerializer.Serialize(personWithAttributes, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
or
personWithAttributes.SerializeWithCamelCase();
or
personWithAttributes.DeserializeFromCamelCase<PersonWithAttributes>()
Unique identifiers are essential for managing records in modern applications, particularly in distributed or large-scale systems. UUIDs (Universally Unique Identifiers) and ULIDs (Universally Unique Lexicographically Sortable Identifiers) are two popular choices, each offering unique benefits. Let's explore what makes them different, their pros and cons, and how to choose the best one for your specific needs.
What is a UUID?
A UUID is a 128-bit identifier designed to ensure global uniqueness. They are often used in databases, systems, and applications to uniquely identify records or objects.
Advantages of UUIDs
Disadvantages of UUIDs
What is a ULID?
A ULID is a 128-bit identifier that combines uniqueness with sortability by creation time. ULIDs were designed to address some of the limitations of UUIDs, particularly their lack of temporal order.
Advantages of ULIDs
Disadvantages of ULIDs
When to Use UUIDs
When to Use ULIDs
Storage and Indexing
Sorting Operations
Choose UUID If:
Choose ULID If:
Both UUIDs and ULIDs offer unique benefits and are suitable for different scenarios. While UUIDs provide robust uniqueness for distributed systems, ULIDs offer an additional advantage of time-based sorting. The choice between UUIDs and ULIDs depends on your specific needs, such as the importance of ordering, compatibility requirements, or readability.