.Net Framework Interior Workshop
< 
First of all, I want to note what I mean by internals. In this case, I mean it is the internal .Net Framework data structures. After all, being under his care, what do we see? Slender architecture classes, strict typing, security settings. And everything seems to work as an automagic and there is no need to think about anything. And it seems even great. But you are essentially in the Matrix. In the Matrix, the laws of which you know only by hearsay. That GC works that way, you were told. But you are not sure that this is so?
So if you continue the metaphor, the course is aimed at a software exit from the borders of the CLR. Having listened to the course, having done practical tasks on the spot, you will learn how to exit .Net with .Net tools. Change the structure of .Net types without resorting to reflection. To interfere in the process of multithreading, and to make really shamanic things.
I really hope that you will like the program very much, because in fact, this is the result of our own research, and all that is there, it will not work.
')
UPD: To be seen, I will write here: the link below takes you to the timepad ticket registration area. There you book a ticket. I'll send you a letter with details how to pay
When and where?
Registration page:
What you need from:
The picture for the seed (after calling CloneThread, the current thread branches into two, each of which goes to its own part of the if condition):
First of all, I want to note what I mean by internals. In this case, I mean it is the internal .Net Framework data structures. After all, being under his care, what do we see? Slender architecture classes, strict typing, security settings. And everything seems to work as an automagic and there is no need to think about anything. And it seems even great. But you are essentially in the Matrix. In the Matrix, the laws of which you know only by hearsay. That GC works that way, you were told. But you are not sure that this is so?So if you continue the metaphor, the course is aimed at a software exit from the borders of the CLR. Having listened to the course, having done practical tasks on the spot, you will learn how to exit .Net with .Net tools. Change the structure of .Net types without resorting to reflection. To interfere in the process of multithreading, and to make really shamanic things.
I really hope that you will like the program very much, because in fact, this is the result of our own research, and all that is there, it will not work.
')
UPD: To be seen, I will write here: the link below takes you to the timepad ticket registration area. There you book a ticket. I'll send you a letter with details how to pay
Master Class Program
The basics of memory management in .Net and not only
- Small Objects Heap / Large Objects Heap
- Thread Stack, High / Low Frequency Heaps, Code Heap, Stubs Heap
- Ephemeral Segments
- Pages, Memory mapped files
How objects are arranged in memory
- How does any Object? What does it contain?
- MethodTable
- EEClass
- Son Of Strike (SOS) debugger extension for viewing the internals of .Net objects
- Debugger Basic Commands
- Consider what objects in memory are in reality.
- Consider sizeof () of any .Net type (standard sizeof considers only by Value types)
Practice : basic tricks
- We get a pointer to the object.Net, investigate its real structure
- Practically interesting example: we transfer objects between AppDomains without serialization: without overhead costs.
- Practically interesting example: load the assembly so that its types can be used in the current domain, but it can be shipped.
- Have a little fun: create an instance of RefType on the stack
- What is an exception? What data structures are created when writing try / catch / finally? How to get them and how to manage them? Why is an exception unmistakably passed through methods that do not support exceptions?
- We place our handler in the chain, which will just listen to everything that goes through it.
- Manually, without catch, catch the exception
- How to implement catch () {throw; }
Practice: Advanced Tricks
- We are developing a class for allocating .Net objects outside .Net memory (outside SOH / LOH)
- Writing a pool of objects outside .Net memory
- Call the constructor by the pointer - get rid of the brakes of reflection
- Practically interesting example: We write the Memory Profiler kernel - we dump virtual memory with the recognition of .Net objects in it.
- Create a type manually by direct generation of internal CLR structures (virtual methods tables and interfaces)
- Practical interesting example: Share an .Net object between processes (using the Paging file)
- Practical interesting example: We write the fork () method: the method that creates a stream that starts from the same place where fork was called ( C ++ / CLI / asm).
When and where?
- May 16, Friday, from 6 pm to 11 pm, Moscow, 1st Volokolamsky passage, 10, bldg. 3 . So if you ask for leave from work, then not at all for long. If there are a lot of registrations, then we will spend the second part on Saturday . Here everything is welcome: write to the post office, whenever it is more convenient for someone (sunex.development@gmail.com)
Registration page:
What you need from:
- Come with a laptop and installed Visual Studio. I will mail you to the mail before starting the link to DropBox or Google Drive with files (there will be MSIL, C ++ / CLI, which will take a long time to write without preparation, and therefore we may not be in time). They need to be downloaded and verified.
The picture for the seed (after calling CloneThread, the current thread branches into two, each of which goes to its own part of the if condition):
Source: https://habr.com/ru/post/221475/
All Articles