To Every Programmer Who’s Ever Scanned
Hacker News And /r/programming And Thought...
“How Will I Ever Keep Up?”
Here’s How To Turn “Information Overwhelm”
Into An Efficiency Edge That Can
Quickly Boost Your Income,
Earn You “MVP” Status With Your Team,
And Make You The In-Demand Developer
Companies Are Dying To Recruit
The Redgate Hub provides a wealth of free technical articles and videos and recently even more content has been added to the university. New courses include guidance for setting up your own demo environment, a course on unboxing SQL Cone, and a guide to testing your Database DevOps readiness.
Scratch.js is a standalone library with no external dependencies which brings interactivity to your website by allowing you to generate scratch cards for your visitors.
Based on HTML5, scratch.js generate canvas on the fly and is optimized for all modern browsers and has touch support for mobile devices. You can use it to make scratch cards, coupons, promotionnal game and even advertisement.
Single header only C++ logging library. It is extremely light-weight, robust, fast performing, thread and type safe and consists of many built-in features. It provides ability to write logs in your own customized format. It also provide support for logging your classes, third-party libraries, STL and third-party containers etc.
public interface INotifyPropertyChanged
{
event PropertyChangedEventHandler PropertyChanged;
} partial class CarModel : INotifyPropertyChanged
{
private double _speedKmPerHour;
public double SpeedKmPerHour
{
get => _speedKmPerHour;
set
{
_speedKmPerHour = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SpeedKmPerHour)));
}
}
public event PropertyChangedEventHandler? PropertyChanged;
} partial class CarModel : INotifyPropertyChanged
{
private double _speedKmPerHour;
} <Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0" PrivateAssets="all" />
</ItemGroup>
</Project> [Generator]
public class NotifyPropertyChangedGenerator : ISourceGenerator
{
public void Initialize(GeneratorInitializationContext context)
{
}
public void Execute(GeneratorExecutionContext context)
{ public void Execute(GeneratorExecutionContext context)
{
// uncomment to debug the actual build of the target project
// Debugger.Launch();
var compilation = context.Compilation;
var notifyInterface = compilation.GetTypeByMetadataName("System.ComponentModel.INotifyPropertyChanged");
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var immutableHashSet = syntaxTree.GetRoot()
.DescendantNodesAndSelf()
.OfType<ClassDeclarationSyntax>()
.Select(x => semanticModel.GetDeclaredSymbol(x))
.OfType<ITypeSymbol>()
.Where(x => x.Interfaces.Contains(notifyInterface))
.ToImmutableHashSet();
foreach (var typeSymbol in immutableHashSet)
{
var source = GeneratePropertyChanged(typeSymbol);
context.AddSource($"{typeSymbol.Name}.Notify.cs", source);
}
}
} private string GeneratePropertyChanged(ITypeSymbol typeSymbol)
{
return $@"
using System.ComponentModel;
namespace {typeSymbol.ContainingNamespace}
{{
partial class {typeSymbol.Name}
{{
{GenerateProperties(typeSymbol)}
public event PropertyChangedEventHandler? PropertyChanged;
}}
}}";
}
private static string GenerateProperties(ITypeSymbol typeSymbol)
{
var sb = new StringBuilder();
var suffix = "BackingField";
foreach (var fieldSymbol in typeSymbol.GetMembers().OfType<IFieldSymbol>()
.Where(x=>x.Name.EndsWith(suffix)))
{
var propertyName = fieldSymbol.Name[..^suffix.Length];
sb.AppendLine($@"
public {fieldSymbol.Type} {propertyName}
{{
get => {fieldSymbol.Name};
set
{{
{fieldSymbol.Name} = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof({propertyName})));
}}
}}");
}
return sb.ToString();
} <Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<ProjectReference Include="..\NotifyPropertyChangedGenerator\NotifyPropertyChangedGenerator.csproj"
OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>
</ItemGroup>
</Project> using System.ComponentModel;
namespace NotifyPropertyChangedGenerator.Demo
{
public partial class CarModel : INotifyPropertyChanged
{
private double SpeedKmPerHourBackingField;
private int NumberOfDoorsBackingField;
private string ModelBackingField = "";
public void SpeedUp() => SpeedKmPerHour *= 1.1;
}
} SQL is back. Not just because writing glue code to kludge together NoSQL tools is annoying. Not just because retraining workforces to learn a myriad of new languages is hard. Not just because standards can be a good thing.
But also because the world is filled with data. It surrounds us, binds us. At first, we relied on our human senses and sensory nervous systems to process it. Now our software and hardware systems are also getting smart enough to help us. And as we collect more and more data to make better sense of our world, the complexity of our systems to store, process, analyze, and visualize that data will only continue to grow as well.
services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(connectionString));
public static IServiceCollection AddDbContext<TContext>(
[NotNullAttribute] this IServiceCollection serviceCollection,
[CanBeNullAttribute] Action<DbContextOptionsBuilder> optionsAction = null,
ServiceLifetime contextLifetime = ServiceLifetime.Scoped,
ServiceLifetime optionsLifetime = ServiceLifetime.Scoped) where TContext : DbContext; An exception occurred while iterating over the results of a query for context type 'BlazorServer.DataAccess.ApplicationDbContext'. System.InvalidOperationException: A second operation was started on this context before a previous operation completed. This is usually caused by different threads concurrently using the same instance of DbContext. For more information on how to avoid threading issues with DbContext, see https://go.microsoft.com/fwlink/?linkid=2097913.
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Configuration.GetConnectionString("DefaultConnection");
//services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(connectionString));
services.AddDbContextFactory<ApplicationDbContext>(options => options.UseSqlServer(connectionString)); @inject IDbContextFactory<ApplicationDbContext> DbFactory
private async Task DeleteImageAsync()
{
using var context = DbFactory.CreateDbContext();
var image = await context.HotelRoomImages.FindAsync(1);
// ...
} @implements IDisposable
@inject IDbContextFactory<ApplicationDbContext> DbFactory
@code
{
private ApplicationDbContext Context;
protected override async Task OnInitializedAsync()
{
Context = DbFactory.CreateDbContext();
await base.OnInitializedAsync();
}
private async Task DeleteImageAsync()
{
var image = await Context.HotelRoomImages.FindAsync(1);
// ...
}
public void Dispose()
{
Context.Dispose();
}
} services.AddScoped<ApplicationDbContext>(serviceProvider =>
serviceProvider.GetRequiredService<IDbContextFactory<ApplicationDbContext>>().CreateDbContext()); public interface IHotelRoomService : IDisposable
{
// ...
}
public interface IHotelRoomImageService : IDisposable
{
// ...
} public class HotelRoomService : IHotelRoomService
{
private bool _isDisposed;
// ...
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (!_isDisposed)
{
try
{
if (disposing)
{
_dbContext.Dispose();
}
}
finally
{
_isDisposed = true;
}
}
}
} @page "/hotel-room/create"
@page "/hotel-room/edit/{Id:int}"
@implements IDisposable
// ...
@code
{
// ...
public void Dispose()
{
HotelRoomImageService.Dispose();
HotelRoomService.Dispose();
}
} @page "/hotel-room"
@implements IDisposable
// ...
@code
{
// ...
public void Dispose()
{
HotelRoomService.Dispose();
}
} System.ObjectDisposedException: Cannot access a disposed context instance. A common cause of this error is disposing a context instance that was resolved from dependency injection and then later trying to use the same context instance elsewhere in your application. This may occur if you are calling 'Dispose' on the context instance, or wrapping it in a using statement. If you are using dependency injection, you should let the dependency injection container take care of disposing context instances. Object name: 'ApplicationDbContext'.
@code
{
private IHotelRoomImageService HotelRoomImageService;
protected override async Task OnInitializedAsync()
{
HotelRoomImageService = new HotelRoomImageService(DbFactory.CreateDbContext(), mapper);
await base.OnInitializedAsync();
}
private async Task DeleteImageAsync()
{
await HotelRoomImageService.DeleteAsync(1);
// ...
}
public void Dispose()
{
HotelRoomImageService.Dispose();
}
} @page "/hotel-room" @*@implements IDisposable*@ @*@inject IHotelRoomService HotelRoomService*@ @inherits OwningComponentBase<IHotelRoomService>
@code
{
private IHotelRoomService HotelRoomService => Service; @page "/preferences"
@using Microsoft.Extensions.DependencyInjection
@inherits OwningComponentBase
@code {
private IHotelRoomService HotelRoomService { get; set; }
private IHotelRoomImageService HotelRoomImageService { get; set; }
protected override void OnInitialized()
{
HotelRoomService = ScopedServices.GetRequiredService<IHotelRoomService>();
HotelRoomImageService = ScopedServices.GetRequiredService<IHotelRoomImageService>();
}
} services.AddDbContextFactory<ApplicationDbContext>(options => options.UseSqlServer(connectionString));
services.AddScoped<ApplicationDbContext>(serviceProvider =>
serviceProvider.GetRequiredService<IDbContextFactory<ApplicationDbContext>>().CreateDbContext()); @inject IHotelRoomService HotelRoomService
@inherits OwningComponentBase<IHotelRoomService>
| Check | Code | Description |
| Is Null | if(variable is null) return true; |
|
| Is Not Null | if(variable is { }) return false |
|
| Is Not Null | if(variable is object) return false |
|
| Is Null | if(variable == null) return true |
|
| Is Not Null | if(variable != null) return false |
|
SonarLint is a free IDE extension that lets you fix coding issues before they exist! Like a spell checker, SonarLint highlights Bugs and Security Vulnerabilities as you write code, with clear remediation guidance so you can fix them before the code is even committed. SonarLint in VS Code supports analysis of C, C++, HTML, Java, JavaScript, PHP, Python and TypeScript, and you can install it directly from the VS Code Marketplace!
3. Article 12a: No posting your own photos or videos of sports matches. Only the "organisers" of sports matches will have the right to publicly post any kind of record of the match. No posting your selfies, or short videos of exciting plays. You are the audience, your job is to sit where you're told, passively watch the game and go home.
This syntax supports static analysis such that later code will know whether variable is null or not.
Doesn’t produce a warning even when comparing against a non-nullable value type making the code to check pointless.
Requires C# 7.0 because it leverages type pattern matching.