Skip to main content

Inga Bemman dev notes

Here I keep work and research related notes

Search This Blog

Posts

Handling JSON without allocations C# ASP.NET Core

Posted by Inga Bemman September 17, 2020

Get link
Facebook
Twitter
Pinterest
Email
Other Apps

Benchmark.NET usage with WPF

Posted by Inga Bemman September 22, 2020

Get link
Facebook
Twitter
Pinterest
Email
Other Apps

CLS Rules

Posted by Inga Bemman September 22, 2020

Get link
Facebook
Twitter
Pinterest
Email
Other Apps

CTS, CLI, VES

Posted by Inga Bemman September 22, 2020

Get link
Facebook
Twitter
Pinterest
Email
Other Apps

WPF Bar Chart rendering with skia

Posted by Inga Bemman September 19, 2020

Get link
Facebook
Twitter
Pinterest
Email
Other Apps

Adorners

Posted by Inga Bemman September 19, 2020

Get link
Facebook
Twitter
Pinterest
Email
Other Apps

Asynchronous Streams

Posted by Inga Bemman September 19, 2020

Get link
Facebook
Twitter
Pinterest
Email
Other Apps

Inga Bemman: WPF and UWP Software Developer https://xaml.shop

Blog Archive

2020 16
- September 15
- July 1

Labels

.net
ASP.NET Core
async
benchmarking
charp
CLI
CLR
Garbage Collection
json
rx.net

skia
wpf

Show more Show less

Popular Posts

WPF Bar Chart rendering with skia

WPF Chart with SkiaSharp SkiaShrap graphics library renders gradients very very smooth and I love it on WPF (as opposed to natural way of creating gradients) it also scales nicely when a window resizes without extra code;

Diagnostic Tools

© Andrey Akinshin 2019 Andrey Akinshin Pro .NET Benchmarking https://doi.org/10.1007/978-1-4842-4941-3_6 .NET Diagnostic Tools Andrey Akinshin 1 (1) Saint Petersburg, Russia If all you have is a hammer, everything looks like a nail. — Abraham Maslow Benchmarking is only one of the performance investigation steps. In this chapter, you will find a brief overview of the some important diagnostic tools that can be useful for the whole investigation. We will learn the following kinds of tools: Benchmarking harness This tool automatically benchmarks the specified method and displays corresponding metrics. It tells you how much time it takes to perform this method, but it doesn’t always tell you why you have such values. Performance profiler This tool measures performance metrics for each called method inside an application. It tells you where the performance bottleneck of the application is and allows exploring performance profiles with detailed information about consumed CPU resou

ConfigureAwait(false) to improve performance

While all await expressions capture the execution context , the decision of whether to flow synchronization context as well is controlled by the type being awaited . If you await for a Task , the synchronization context will also be captured by default. Tasks are not the only thing you can await , and I’ll describe how types can support await in the section “The await Pattern”. Sometimes, you might want to avoid getting the synchronization context (internal another tread switch) involved. If you want to perform asynchronous work starting from a UI thread , but you have no particular need to remain on that thread, scheduling every continuation through the synchronization context is unnecessary overhead . If the asynchronous operation is a Task or Task<T> (or the equivalent value types, ValueTask or ValueTask <T>), you can declare that you don’t want this by calling the ConfigureAwait method passing false . This returns a different representation of the asynchronous opera

Reading Large Data files in WPF with IAsyncEnumerable

Producing and consuming Async sequences Reading Large Data files in WPF As soon as you type new Thread() , it’s over; your project already has legacy code. An asynchronous foreach will ask the collection object for an enumerator, and will repeatedly ask it to advance to the next item, executing the loop body with the value returned by Current each time, until the enumerator indicates that there are no more items. The main difference is that the synchronous MoveNext has been replaced by MoveNextAsync , which returns an awaitable ValueTask <T>. (The IAsyncEnumerable <T> interface also provides support for passing in a cancellation token, although an asynchronous foreach won’t use that itself.) To consume an enumerable source that implements this pattern, you must put the await keyword in front of the foreach. You can also return an IAsyncEnumerable<T> . Code below shows both implementation and consumption of IAsyncEnumerable<T> in action. TEST 1: Reading

Adorners

An adorner is a special kind of class that is rendered above all UI controls , in what is known as an adorner layer . Adorner elements in this layer will always be rendered on top of the normal WPF controls. For example we could use adorner to add handles to a UI control, to enable users to resize the element. Allow user to resize Rectangle elements on a canvas Adorners need to be initialized in code and so, a good place to do this is in the UserControl.Loaded method, when we can be certain that the canvas and its items will have been initialized. 1. Create class ResizingAdorner .cs and inherit from Adorner class public class ResizingAdorner : Adorner { private VisualCollection visualChildren; private Thumb top, left, bottom, right; 2. Declare the VisualCollection object that will contain the visuals that we want to render 3. Declare 4 Thumb elements for top, right, bottom, left provide a DragDelta event that we will use to register the users' mouse movements

Benchmark.NET usage with WPF

| Method | Toolchain | Mean | Error | StdDev | Median | Ratio | RatioSD | Gen 0/1k Op | Gen 1/1k Op | Gen 2/1k Op | Allocated Memory/Op | |----------------- |-------------- |------------:|-----------:|------------:|---------:|------:|--------:|------------:|------------:|------------:|--------------------:| | LoadImageControl | .NET Core 3.0 | 450.2 us | 108.9 us | 286.8 us | 337.7 us | 0.95 | 1.37 | - | - | - | 1.05 KB | | LoadImageControl | net471 | 13,463.7 us | 7,503.8 us | 22,125.2 us | 507.3 us | 1.00 | 0.00 | - | - | - | 18 KB | Run in RELEASE mode to get the benchmark report

Handling JSON without allocations C# ASP.NET Core

Handling JSON without allocations C# ASP.NET Core

CLR and Garbage Collection

The CLR maintains a heap , a service that provides memory for the objects and values whose lifetime is managed by the GC. Each time you construct an instance of a class with new , or you create a new array object , the CLR allocates a new heap block . The GC decides when to deallocate that block. A heap block contains all the nonstatic fields for an object , or all the elements if it’s an array. The CLR also adds a header , which is not directly visible to your program. This includes a pointer to a structure describing the object’s type . This supports operations that depend on the real type of an object. For example, if you call GetType on a reference , the runtime uses this pointer to find out the type. It’s also used to work out which method to use when you invoke a virtual method or an interface member. The CLR also uses this to know how large the heap block is —the header does not include the block size , because the runtime can work that out from the object’s type. (Most

Reactive Extensions for .NET, or Rx

Use Rx for : to combine and manage multiple streams of events in LINQ fashion Rx’s fundamental abstraction, IObservable<T> , represents a sequence of items, and its operators are defined as extension methods for this interface. Rx implements standard LINQ operators, you can write queries against a live source ( For example, you could write a query that provides data only for stocks that are changing price more frequently than some minimum rate.) 1. defines a standard way for sources to report errors 2. it is able to deliver items in a well-defined order 3. pr ovides a clear way to signal when there are no more items 4. Rx makes an event source a first-class entity, because it’s just an object. This means you can pass an event source as an argument, store it in a field, or offer it in a property Subscribers are required to supply an object that implements IObserver<T> The fundamental abstraction in Rx, IObservable<T>, is implemented by event s

WPF Performance

The WPF Framework looks at the graphics hardware that is installed on the computer that it is running on and puts it into one of 3 ca tegories Rendering Tier 0 < version 7 of DirectX Rendering Tier 1 < version 9 of DirectX Rendering Tier 2 >= version 9 of DirectX As the UI will freeze during the rendering time, care should be taken to minimize the number of visual layers that are rendered We can find out the rendering tier of the host computer's graphics hardware using the static Tier property of the RenderCapability class. public App() { StateManager.Instance.RenderingTier = (RenderingTier)(RenderCapability.Tier >> 16); } namespace CompanyName.ApplicationName.DataModels.Enums { public enum RenderingTier { Zero = 0, One = 1, Two = 2 } } Making more efficient resources When we reference our resources, we can either use a StaticResource or a DynamicResource . a StaticResource will look up the value of the r

Powered by Blogger