How to use Microsoft.Diagnostics.Tracing to write events to sub folders

I would like to write to the system event log, in sub-folders under "Applications and Services Logs". I have tried creating the registry keys by hand (see here), but this didn't seem to work. I tried to find out how these keys would be created correctly, and this led to the "Microsoft.Diagnostics.Tracing" nuget package. I have created the demo application, and registered the manifest using wevtutil.

After registering, I look in Event Viewer, and see this: enter image description here

Why is the "Operational" node not just called "Operational" (like others) ? If I right click "Samples", and chose "Refresh", everything below "EventSourceDemos" disappears. If I restart Event Viewer, it comes back.

I have run the sample code, but see nothing logged (from Event Viewer). I added an Event with channel debug. This log sometimes appears in the Event Viewer - but not always. In the manifest, it says that the channel with a chid of "Debug" is not enabled. Why is that - when "Operational" is enabled ? I have re-run the wevtutil - do I have to do that for every build ?

Is there a fully working example somewhere ? Is there a simpler way to write to these sub-folder logs ?

My code:

using Microsoft.Diagnostics.Tracing;

namespace ConsoleApp11
{
    class Program
    {
        static void Main(string[] args)
        {
            var listener = new CustomEventListener();
            listener.EnableEvents(MyEventSource.Log, EventLevel.Verbose);

            MyEventSource.Log.Load(1234, "hello");
            MyEventSource.Log.DoStuff("hello world");

            var options = new EventSourceOptions { Level = EventLevel.Error };
            MyEventSource.Log.Write("Failed !", options);
        }
    }

    [EventSource(Name = "Samples-EventSourceDemos-EventLog")]
    public sealed class MyEventSource : EventSource
    {
        public static MyEventSource Log = new MyEventSource();

        [Event(1, Message = "{0} -> {1}", Channel = EventChannel.Operational)]
        public void Load(long baseAddress, string imageName)
        {
            WriteEvent(1, baseAddress, imageName);
        }

        [Event(2, Message = "{0}", Channel = EventChannel.Debug)]
        public void DoStuff(string message)
        {
            WriteEvent(2, message);
        }
    }

    public class CustomEventListener : EventListener
    {
        protected override void OnEventWritten(EventWrittenEventArgs eventData)
        {
        }
    }
}

Edit: Creating Registry keys by hand:

static public void Create(string companyName, string applicationName, string functionName, string logName, Guid publisher)
{
    var publisherGuid = $"{{{publisher}}}";
    var publisherLocation = @"SOFTWARE\Microsoft\Windows\CurrentVersion\WINEVT\Publishers";
    var primaryLocation = @"SOFTWARE\Microsoft\Windows\CurrentVersion\WINEVT\Channels";
    var secondaryLocation = @"SYSTEM\CurrentControlSet\Services\EventLog\Application";

    var primaryLogName = $@"{companyName}-{applicationName}-{functionName}/{logName}";
    var secondaryLogName = $"{companyName}-{applicationName}-{functionName}";
    var publisherName = $"{companyName}-{applicationName}";

    var primaryEventRoot = $@"{primaryLocation}\{primaryLogName}";
    var secondaryEventRoot = $@"{secondaryLocation}\{secondaryLogName}";
    var publisherEventRoot = $@"{publisherLocation}\{publisherGuid}";

    var evtxFilePath = $@"%SystemRoot%\System32\Winevt\Logs\{secondaryLogName}\{logName}.evtx";

    if (!Registry.LocalMachine.Exists(primaryEventRoot))
    {
        using (var primaryKey = Registry.LocalMachine.CreateSubKey(primaryEventRoot))
        {
            primaryKey.SetValue("Enabled", 1, RegistryValueKind.DWord);
            primaryKey.SetValue("Type", 1, RegistryValueKind.DWord);
            primaryKey.SetValue("Isolation", 0, RegistryValueKind.DWord);
            primaryKey.SetValue("RestrictGuestAccess", "1", RegistryValueKind.String);
            primaryKey.SetValue("OwningPublisher", publisherGuid, RegistryValueKind.String);
        }
    }

    if (!Registry.LocalMachine.Exists(secondaryEventRoot))
    {
        using (var secondaryKey = Registry.LocalMachine.CreateSubKey(secondaryEventRoot))
        {
            secondaryKey.SetValue("ProviderGuid", publisherGuid, RegistryValueKind.String);
            secondaryKey.SetValue("File", evtxFilePath, RegistryValueKind.String);
        }
    }

    if (!Registry.LocalMachine.Exists(publisherEventRoot))
    {
        using (var publisherKey = Registry.LocalMachine.CreateSubKey(publisherEventRoot))
        {
            publisherKey.SetValue("", publisherName, RegistryValueKind.String);
            publisherKey.SetValue("Enabled", 1, RegistryValueKind.DWord);

            using (var channelReference = publisherKey.CreateSubKey("ChannelReferences"))
            {
                channelReference.SetValue("Count", 1, RegistryValueKind.DWord);

                using (var reference0 = channelReference.CreateSubKey("0"))
                {
                    reference0.SetValue("Flags", 1, RegistryValueKind.DWord);
                    reference0.SetValue("Id", 16, RegistryValueKind.DWord);
                }
            }
        }
    }
}