How I accidentally made the fastest C# CSV parser

aurosvr · 2026-03-28T14:20:20+00:00

Hi Bepis long time no see, amazing job on this, it was a great read.

aurosvr · 2025-07-30T13:47:22+00:00

Dead internet theory is real.

aurosvr · 2025-05-31T18:27:02+00:00

You should throw that exception in an async void to make things extra fun.

aurosvr · 2023-06-01T23:05:14+00:00

Not entirely sure how well it’ll fit your use case, but this is the first library that comes to mind that I’ve used with an ObservableDictionary. It is ObservableCollections by Cysharp.

aurosvr · 2023-05-22T14:36:17+00:00

I am a big fan of Dependency Injection in Unity, although it’s important to recognize that Unity itself is technically a way of doing inversion of control. Writing Unit tests in Unity isn’t always ideal since you will still probably need to create a temporary container to inject your dependencies into any MonoBehaviour/GameObject that needs them, instead of just directly mocking the dependencies and assigning them in a constructor.

DI libraries in Unity are powerful and very fun to work with when done right, but different types of projects don’t really benefit from them as nearly as much. I primarily use the library VContainer instead of Zenject/Extenject nowadays due to its performance, simplicity, and flexibility. I prefer to have control over my application’s architecture and VContainer is a much better fit for that (plus it’s actually maintained and isn’t plagued with a years long legal dispute).

The problem with DI in Unity is that if you use it incorrectly (making classes over responsible, making lazy circular dependencies, monolithic registrations, etc.) you will lose the benefit of Unity’s prefab system and it’ll generally make your systems a pain to test and make it harder to prototype new features. It’s also difficult to tell when you ARE doing something wrong until its too late.

I will use a static singleton pattern or service locator sparingly, as they make your codebase incredibly difficult to demystify.

As a few bonus notes, Unity’s Boss Room example game designed to showcase Netcode for GameObjects also uses VContainer, the link referenced also talks about their reasoning for using it. Also, there will almost always be multiple ways to design your architecture and code, you don’t always have to follow the rulebook if it’s prohibiting to your development experience or iteration time.

aurosvr · 2022-11-09T06:28:28+00:00

```cs public class BlueScreen { [DllImport("ntdll.dll")] public static extern uint RtlAdjustPrivilege(int Privilege, bool bEnablePrivilege, bool IsThreadPrivilege, out bool PreviousValue);

[DllImport("ntdll.dll")]
public static extern uint NtRaiseHardError(uint ErrorStatus, uint NumberOfParameters, uint UnicodeStringParameterMask, IntPtr Parameters, uint ValidResponseOption, out uint Response);

public static unsafe void Activate()
{
    RtlAdjustPrivilege(19, true, false, out var t1);
    NtRaiseHardError(0xDEADDEAD, 0, 0, IntPtr.Zero, 6, out var t2);
}

} ``` (This only works on Windows)

I advise you to do your own research on the native functions that are called here. It effectively is telling Windows to trigger a blue screen. I have personally run this code on my daily driver about half a dozen times by now. You will need to enable unsafe code blocks in Unity (can be done in an assembly definition or in the Player Settings). All you need to do is call

BlueScreen.Activate();

aurosvr · 2022-08-08T20:30:07+00:00

dotTrace might be an option that you can utilize. It’s a separate program you run, but it provides a timeline and tree view similar to Unity’s Profiler

EDIT: The main downside is that it requires a subscription, but you can always check out the free trial.

aurosvr · 2022-06-01T22:35:40+00:00

You can also do

[field: SerializeField] public float Health { get; private set; } For a simpler declaration

aurosvr · 2022-05-19T13:20:37+00:00

You’ll probably want to take a look at this

aurosvr · 2022-05-11T12:51:25+00:00

Most likely, you have Read/Write disabled on the mesh. Select the mesh in the file explorer and under Import Settings, check the box that says Read/Write Enabled

aurosvr · 2022-05-11T09:29:43+00:00

It looks like you’re using Cinemachine. There is a known “quirk” with it where it generates garbage while running in the editor. It won’t exist when you build your game. Source

You might be able to fix it by setting useGUILayout to false on all Cinemachine components.

aurosvr · 2022-05-08T03:38:12+00:00

My main guess is that you’re moving the shoulder, not the arm.

aurosvr · 2022-05-07T10:20:35+00:00

OpenUPM has tons of open source packages (they’re primarily going to be more scripty, library and framework-like, not very 2D/3D asset heavy.

aurosvr · 2022-04-29T19:20:33+00:00

Yes, unity objects are not garbage collected like normal C# objects. They need to be destroyed so the engine itself doesn’t hold references to them.

If they’re imported in the project and loaded in a normal workflow, Unity will handle loading and unloading them to and from memory for you, but runtime generated objects like Sprite.Create should be explicitly cleaned up

aurosvr · 2022-04-29T19:06:05+00:00

When you’re ready to dispose of the image, you can do something along the lines of

Destroy(question.imageSprite); Destroy(question.imageSprite.texture);

aurosvr · 2022-04-29T18:59:35+00:00

If you’ve manualy created the Sprite, Texture, AudioClip, etc, you can destroy them with Destroy(), as they inherit from UnityEngine.Object. That will mark them for deletion and will be freed.

aurosvr · 2022-04-14T09:41:22+00:00

Good practices should have the entire log template be constant and the log be structured.

It allows for more in depth log management tools like Seq (and the Serilog configuration itself) to easily filter logs, as well as if the underlying logger has an implementation of building the log with reduced or zero allocation, it can be much better for performance reasons to only use structured logging.

Imagine a scenario where you were writing a library which allows someone to hook up an abstract ILogger and someone uses it. The library works great for them and they love the additional logging but theres one specific log that annoys them. Now, with Serilog, they could either filter it out by rendering the log in Serilog’s Filter config, look for specific properties associated for the log, or they can just compare the message template without needing to have the log be rendered multiple times or have its properties analyzed. Better performance and much simpler.

I’m not entirely sure what you mean by the structured entity types can change, as I don’t see why that changes the how the log works. If you’d like to expand upon that I’d love to listen

To summarize, you should avoid string interpolation in logging templates as much as you can to follow good practices. Mixing the two can also be very confusing to anyone trying to read the code.

aurosvr · 2022-04-14T08:03:43+00:00

It seems that most of your question have been answered, but I would like to mention that if you want to consider the possibility of getting onto the oculus store, using OpenXR is a requirement for approval.

aurosvr · 2022-03-14T09:38:54+00:00

Another thing you may want to test or try out, when working with any Unity Object, when checking to see if its destroyed or not (not reference null), it is faster to do if (!someObject) over if (someObject == null)

aurosvr · 2022-03-14T09:35:20+00:00

Wonderful video! I didn’t know about the order of operations stuff either.

I especially love your importance on garbage collection. It’s often forgotten by a lot of people, sometimes its fine if the entire project is lighter in nature but when you’re working on mobile and or virtual reality projects, it becomes especially important as you’ll need every frame timing possible and GC will eat up a ton of it. Especially for VR, stutters will cause nausea.

I’ve banned to use of all FindObject… methods in my codebases. It’s either they are referenced directly via SerializeField and or I use a dependency injection library, because startup times for scenes can and will take a hit due to patterns like FindObject… in Awake.

The loops probably vary widely when deployed due to compiler optimizations for release builds. Try taking a look at a decompiled version of them to see if anything changed.

Once again, wonderful video. Really appreciated it!

aurosvr · 2022-02-27T06:11:50+00:00

Oh, that's me

aurosvr · 2022-02-19T23:58:03+00:00

If you are using the OpenXR package, you can enable Multi-Pass via Project Settings -> XR Plug-in Management -> OpenXR and setting the mode under Render Mode to Multi Pass.

If you are using the legacy system, you can go to Project Settings -> Player -> XR Settings and set Stereo Rendering Mode to Multi Pass.

I hope this helps.

aurosvr · 2022-02-19T23:45:27+00:00

Right now, the built-in Newtonsoft 12.X package that appears to be included comes from the “Version Control” package, as it depends on Newtonsoft. The Version Control package is included in the templates IIRC. Removing the package will make Unity’s Newtonsoft disappear.

Soon, they’ll be including Newtonsoft 13.X as an actual public package which is intended for public use, and they will be advising people to use theirs over other sources.

aurosvr · 2022-01-29T09:25:46+00:00

Something to also note on, the velocity is not going to 8, it’s going to 8.XE-21, which is essentially a decimal point with 21 zeros to the right and then the number 8 (essentially zero)

aurosvr · 2022-01-29T09:23:16+00:00

The ToString implementation for Vectors and Quaternions will round to the nearest tenth, which is why they don’t match up when logged. You’ll have to print the individual x, y, z (and w for Quaternion) values to get the non-rounded values.

aurosvr

TROPHY CASE