C# fixed Keyword (unsafe)Use the fixed statement in an unsafe code block. This keyword prevents the memory from being moved.
dot net perls
Fixed. The fixed statement fixes memory in one location. Objects in memory are moved at almost any time. This makes garbage collection possible.
But when we use unsafe pointers to memory addresses, that memory must not be moved. With fixed we can use pointers without interfering with GC.
Fixed example. This program must be compiled with unsafe code allowed. You can set this option in Visual Studio. It introduces the Transform method, which gets a random string.
Then The program uses the fixed statement to ensure that the garbage collector does not relocate the string data.
Fixed Inside the fixed statement is a block of code. The string data pointed to by the char* pointer will not be moved.
And This means we can manipulate that memory however we like. In the example, we increment the value of each character.
Loop The program adds 1 to each character in the string. It does this through pointer manipulation.
C# program that uses fixed statement on string
using System; class Program { static void Main() { Console.WriteLine(Transform()); Console.WriteLine(Transform()); Console.WriteLine(Transform()); } unsafe static string Transform() { // Get random string. string value = System.IO.Path.GetRandomFileName(); // Use fixed statement on a char pointer. // ... The pointer now points to memory that won't be moved. fixed (char* pointer = value) { // Add one to each of the characters. for (int i = 0; pointer[i] != '\0'; ++i) { pointer[i]++; } // Return the mutated string. return new string(pointer); } } }
61c4eu6h/zt1 ctqqu62e/r2v gbekvhn6/xwq
Fixed buffer. The fixed modifier describes a buffer of constant size in an unsafe context in a struct. We use this memory as an array. This can help with performance.
Size The size of the fixed buffer must be constant—you can use a constant expression.
Note The program uses a static struct reference containing a fixed buffer of integers.
Load, Store In Load and Store(), the program reads and writes values to the fixed buffer using unsafe code and pointers.
C# program that uses fixed buffer and unsafe context
using System; unsafe struct FixedBufferExample { public fixed int _buffer[1024]; // This is a fixed buffer. } class Program { static FixedBufferExample _fixedBufferExample; // Reference to struct. static void Main() { // Store values in the fixed buffer. // ... The load the values from the fixed buffer. Store(); Load(); } unsafe static void Store() { // Put the fixed buffer in unmovable memory. // ... Then assign some elements. fixed (int* buffer = _fixedBufferExample._buffer) { buffer[0] = 1; buffer[99] = 2; buffer[1023] = 3; } } unsafe static void Load() { // Put in unmovable memory. // ... Then load some values from the memory. fixed (int* buffer = _fixedBufferExample._buffer) { Console.WriteLine(buffer[0]); Console.WriteLine(buffer[99]); Console.WriteLine(buffer[1023]); } } }
1 2 3
Fixed buffer, performance. The fixed buffer eliminates the need of many array bounds checks. But the overhead of changing the memory to an unmovable address often hurts performance.
Info A fixed buffer could be faster on long-running computations that are heavily numerical.
Tip As always, when improving performance, please set up benchmarks and only accept changes that result in an improvement.
Fixed statement, performance. There is a small cost to using the fixed statement. So it will only help on operations that spend significant amounts of time in unsafe code.
Fixed, warning. Optimizing with the fixed statement and pointer manipulation is often trial-and-error. It may make C# programs slower due to the transition from movable to fixed memory.
Thus If you are optimizing, make sure to benchmark all the unsafe changes you make.
Info Thanks to Amit Jha for pointing out that fixed statements can lead to performance improvements in certain situations.
A summary. Fixed is used with array elements, integer fields, and any data that is classified as movable—meaning it could be moved in memory during GC. This is a complex optimization.
© 2007-2021 sam allen. see site info on the changelog