String interpolation, introduced in C# 6.0, provides a more readable and concise way to format strings compared to traditional concatenation (+) or string.Format(). Instead of manually inserting variables or placeholders, you can use the $ symbol before a string to directly embed expressions inside brackets.
string name = "Walt"; string job = 'Software Engineer'; string message = $"Hello, my name is {name} and I am a {job}"; Console.WriteLine(message);
This would produce the final output of:
Hello, my name is Walt and I am a Software Engineer
String interpolation can also be chained together into a multiline string (@) for even cleaner more concise results:
string name = "Walt"; string html = $@" <div> <h1>Welcome, {name}!</h1> </div>";
Primary constructors, introduced in C# 12, offer a more concise way to define class parameters and initialize fields.
This feature reduces boilerplate code and makes classes more readable.
Before primary constructors, you would likely write something like the following:
public class UserService { private readonly ILogger _logger; private readonly IUserRepository _repository; public UserService(ILogger logger, IUserRepository repository) { _logger = logger; _repository = repository; } public async Task<User> GetUserById(int id) { _logger.LogInformation("Fetching user {Id}", id); return await _repository.GetByIdAsync(id); } }
With primary constructors, this becomes:
public class UserService(ILogger logger, IUserRepository repository) { public async Task<User> GetUserById(int id) { logger.LogInformation("Fetching user {Id}", id); return await repository.GetByIdAsync(id); } }
Here's a practical example using primary constructors with dependency injection:
public class OrderProcessor( IOrderRepository orderRepo, IPaymentService paymentService, ILogger<OrderProcessor> logger) { public async Task<OrderResult> ProcessOrder(Order order) { try { logger.LogInformation("Processing order {OrderId}", order.Id); var paymentResult = await paymentService.ProcessPayment(order.Payment); if (!paymentResult.Success) { return new OrderResult(false, "Payment failed"); } await orderRepo.SaveOrder(order); return new OrderResult(true, "Order processed successfully"); } catch (Exception ex) { logger.LogError(ex, "Failed to process order {OrderId}", order.Id); throw; } } }
public record Customer(string Name, string Email) { public string FormattedEmail => $"{Name} <{Email}>"; }
Primary constructors provide a cleaner, more maintainable way to write C# classes, especially when working with dependency injection and simple data objects.
In C#, you can format an integer with commas (thousands separator) using ToString with a format specifier.
int number = 1234567; string formattedNumber = number.ToString("N0"); // "1,234,567" Console.WriteLine(formattedNumber);
Explanation:
"N0": The "N" format specifier stands for Number, and "0" means no decimal places. The output depends on the culture settings, so in regions where , is the decimal separator, you might get 1.234.567.
Alternative:
You can also specify culture explicitly if you need a specific format:
using System.Globalization; int number = 1234567; string formattedNumber = number.ToString("N0", CultureInfo.InvariantCulture); Console.WriteLine(formattedNumber); // "1,234,567"
Slow initial load times can drive users away from your React application. One powerful technique to improve performance is lazy loading - loading components only when they're needed.
Let's explore how to implement this in React.
By default, React bundles all your components together, forcing users to download everything upfront. This makes navigation much quicker and more streamlined once this initial download is complete.
However, depending on the size of your application, it could also create a long initial load time.
import HeavyComponent from './HeavyComponent'; import AnotherHeavyComponent from './AnotherHeavyComponent'; function App() { return ( <div> {/* These components load even if user never sees them */} <HeavyComponent /> <AnotherHeavyComponent /> </div> ); }
React.lazy() lets you defer loading components until they're actually needed:
import React, { lazy, Suspense } from 'react'; // Components are now loaded only when rendered const HeavyComponent = lazy(() => import('./HeavyComponent')); const AnotherHeavyComponent = lazy(() => import('./AnotherHeavyComponent')); function App() { return ( <div> <Suspense fallback={<div>Loading...</div>}> <HeavyComponent /> <AnotherHeavyComponent /> </Suspense> </div> ); }
Combine with React Router for even better performance:
import React, { lazy, Suspense } from 'react'; import { BrowserRouter, Routes, Route } from 'react-router-dom'; const Home = lazy(() => import('./pages/Home')); const Dashboard = lazy(() => import('./pages/Dashboard')); const Settings = lazy(() => import('./pages/Settings')); function App() { return ( <BrowserRouter> <Suspense fallback={<div>Loading...</div>}> <Routes> <Route path="/" element={<Home />} /> <Route path="/dashboard" element={<Dashboard />} /> <Route path="/settings" element={<Settings />} /> </Routes> </Suspense> </BrowserRouter> ); }
Implement these techniques in your React application today and watch your load times improve dramatically!
Register for my free weekly newsletter.