iocs | Indicators from Unit 42 Public Reports | Command Line Interface library

There are ioctl(2) wrappers in "golang.org/x/sys/unix". unix.IoctlSetInt mechanically might meet your needs.

It also looks like you're handing control over a small memory buffer to the kernel. You need to be careful doing this: the Go garbage collector free memory objects that it doesn't think are in use, and even if something is in use, it can move it around. The kernel won't know about this and will keep using the old pointer. The unsafe.Pointer documentation has a fair amount to say on this topic, even with regards to less exotic syscalls. I'm not aware of anything that can "lock" a Go object in memory that would keep it from being moved or deallocated (nothing jumps out in the runtime package, for instance).

You might consider writing a very small extension using cgo that malloc()ed an appropriate buffer and handed it off to the ioctl. malloc'd memory isn't garbage-collected so it won't move or be freed from under you; some low-level tools might think this looks like a memory leak (it wouldn't be a bad idea to keep the old value of the pointer around to be able to free it later and dodge this).

The output of of json.dumps [Pyton-doc] is a string:

(...)

Serialize obj to a JSON formatted str using this conversion table. The arguments have the same meaning as in dump().

If you thus want to render the outcome, you render this with a simple:

you might think about rereading part of the documentation from Microsoft. Even if it's old (like from 2006) it is not outdated.

Example. Microsoft documented the use of callbacks. https://msdn.microsoft.com/en-us/library/367eeye0.aspx

In your case, you didn't look, what GetFunctionPointerForDelegate() is returning. It is a IntPtr. This is a structure Microsoft uses to wrap all sort of pointers into one structure for .NET. It has the method void* ToPointer()

If you find yourself using the Service Locator Pattern you are correct to question it, but it has it's place and is OK to use if you need to.

One thing that you may be slightly off on is how IoC injects. IoC can do constructor, property and method injection, so your association example can still be dependency injection.

Composition without IoC is fine if the object doesn't provide any real logic. If what you want to compose into your class is just a DTO, then you don't need to inject it anyway.

Add the {$STRONGLINKTYPES ON} directive to the .dpr. Then those types should be included. But it will definitely blow up your application, as it is not available for a single class.