by bill-s, 2021-04-22T17:37:24.320Z
Basics of C# async await. In this article, you'll learn what C# async and C# await keywords are and how to use async and await in C# code.
Nowadays, Asynchronous programming is very popular with the help of the async and await keywords in C#. When we are dealing with UI, and on button click, we use a long-running method like reading a large file or something else which will take a long time, in that case, the entire application must wait to complete the whole task. In other words, if any process is blocked in a synchronous application, the whole application gets blocked, and our application stops responding until the whole task completes.
Asynchronous programming is very helpful in this condition. By using Asynchronous programming, the Application can continue with the other work that does not depend on the completion of the entire task.
by bill-s, 2021-04-22T17:07:20.416Z
If you develop websites for a living, you probably have created a couple of forms that send out emails. You may have created dozens of them by now and your personal inbox is filled with spam from yourself and your peers testing. So much so that you've created automated Outlook rules to read & archive them automatically.
by bill-s, 2021-04-22T17:37:57.818Z
Nuke is an open-source, cross-platform build automation solution for .NET projects. NUKE prides itself on its simplicity and extensibility that makes build automation approachable for everyone.
In this episode, Matthias Koch joins Rich to give an understanding of what NUKE is and where it fits within the development cycle.
[01:03] - What is NUKE?
[03:00] - Where does NUKE shine?
[06:45] - Setting up a NUKE configuration
[11:50] - Does this ever conflict with MS Build?
[14:44] - Exploring a publish configuration
[20:46] - Where to find Getting Started information?
by bill-s, 2021-04-22T17:06:37.640Z
Containers, Docker, Kubernetes, and Serverless are often used when explaining a Microservices architecture. However, focusing on physical deployment is missing the point of Microservices entirely. Microservices (or any size services) are about logical separation and not about physical deployment. Deployment flexibility is a by-product of having well-defined boundaries for services that are autonomous.
by bill-s, 2021-04-22T17:05:47.283Z
This article covers
Creating and running a Docker image
Adding an image to a container registry
Pulling an image from a container registry
Accessing the properties of a container
by bill-s, 2021-04-22T17:15:12.832Z
We’ll use Blazor Server, Blazor WebAssembly and an ASP.NET Core MVC application to compare performance, looking at network activity to measure against the number of HTTP requests and total load time.
by bill-s, 2021-04-22T17:06:13.835Z
So I was revamping the tests in the template projects for Wrapt and wanted to try using a real database instead of compromising for an in memory one. There’s a few reasons for this, but most notably is being able to get to your test environment as close to realistic as possible.
Setting things up with a local database isn’t terribly hard but it does require some manual steps when setting things up for the first time and requires a specific local set up. This can be automated to a degree like Jimmy Bogard does in his Contoso repo but I was aiming for something a little different.
by mkaminski, 2021-04-20T09:17:32.924Z
Let’s say we have two JSON documents that we would like to merge. How can this be achieved using Newtonsoft.Json and System.Text.Json libraries?
by ThomasArdal, 2021-04-20T05:52:35.354Z
In this article, we'll see how to use the new DynamicComponent from .NET 6 to render dynamic content and to avoid tight coupling between page and component.
by bill-s, 2021-04-22T17:11:08.183Z
Get a DevTools performance trace for a page load
Get a DevTools trace with screenshots
Get a DevTools trace and extract filmstrip screenshots
Get a DevTools trace for a user interaction
Get Runtime performance metrics
Generate a Lighthouse report
Extract Lighthouse performance metrics
Emulate a slow network
Emulate a slow network and CPU
Get Navigation Timing API metrics
Measure First Paint and First Contentful Paint
Measure Largest Contentful Paint w/PerformanceObserver
Measure Cumulative Layout Shift w/PerformanceObserver
Measure SPA metrics with Next.js
Get DevTools-specific metrics: Frames Per Second
Measure memory leaks
Override requests with Request Interception
Block third-party domains
by marjann, 2021-04-21T09:19:51.956Z
Signals is a .NET5 based framework which focuses on increasing the quality and productivity within development teams by providing them with tools, aspects and processes.
Overview can be found on https://signals.emitknowledge.com/
Kick start via Signals Boilerplate on https://github.com/EmitKnowledge/Signals-Boilerplate
When developing an application, certain aspects are mandatory in the project setup phase that are consuming development teams time and focus.
Dependency injection. Signals enables you to use your DI framework of choice with the power of attribute-based injection.
Out of the box Signals offers integration with Autofac, DotNetCore and Simple Injector. Integrating another framework is available through following the convention.
Treat configuration files as objects independent of the storage. Signals enables you to create and maintain configuration files. The framework allows you to set different configurations per environment and to select an active environment. All configurations are mapped against objects.
Out of the box Signals has implementation for File and MSSQL configuration providers.
Signals provides a standardized logging interface that supports integration with existing logging libraries.
Out of the box Signals integrates with NLog. As the framework is extensible by definition, adding an implementation with another logging library is straight forward.
In the enterprise world, there is often a need to understand who did what and when. Signals support auditing via integration with Audit.NET and MSSQL database. Extending the auditing aspect is supported like with the rest of the aspects in the framework.
No matter how fast is your application, it is good to store the most accessed information in the cache. Signals supports in memory caching. Using a different system like Redis can be achieved by extending the caching aspect.
You never know when you will get a new request to add support for different languages in the application. Signals got this covered for you. Out of the box the framework supports file, MSSQL and in memory localization setup.
When your application requires storing files, Signals supports upload and encryption of files for file system, Azure Blob storage and MSSQL database. Other storage providers are supported by extension of Signals.
Signals supports distributed processes. The framework supports a request to start from the web application and to finish on the background service. This is achieved with the support of communication channels which by default we support Azure Event Grid, MSMQ, MSSQL and Azure Service Bus.
Authentication and authorization
This aspect enables you to configure authentication for both ASP.NET MVC and ASP.NET Core. Signals support managing authentication, authorization and permissions with ease with attributes and by direct usage of the authentication, authorization and permission managers.
Signals support task scheduling with daily, monthly, pattern-based, time part, weekend, weekly and workday recurrence configuration. Current implementations are through Fluent Scheduler and Hangfire. Can be extended with other libraries as well.
Having a centralized mechanism to handle exceptions and retry policies is of great need to prevent information to leak outside the system boundaries and to be able to extract meaningful information from the exceptions and errors. Signals supports this through Polly.NET.
We are often challenged to improve long-running processes. To be able to achieve better performance, you will need information on how your system behaves and which processes are the bottleneck. The benchmarking aspect will give you the details by allowing you to track processes, chains and checkpoints.
by bill-s, 2021-04-22T17:07:00.280Z
We’ve previously introduced dotnet monitor as an experimental tool to access diagnostics information in a dotnet process. We’re now pleased to announce dotnet monitor has graduated to a supported tool in the .NET ecosystem. dotnet monitor will be fully supported beginning with our first stable release later this year.