ref class NodeSorter : public System::Collections::IComparer
{
public:
    virtual int Compare(Object^ x, Object^ y)
    {
        System::Windows::Forms::TreeNode^ left = safe_cast<System::Windows::Forms::TreeNode^>(x);
        System::Windows::Forms::TreeNode^ right = safe_cast<System::Windows::Forms::TreeNode^>(y);

        if (left->Nodes->Count)
        {
            if (right->Nodes->Count)
                return left->Text->CompareTo(right->Text);
            return false;
        }

        if (right->Nodes->Count)
            return true;
        return left->Text->CompareTo(right->Text);
    }
}; // ref class NodeSorter

this->treeViewExample->TreeViewNodeSorter = gcnew NodeSorter();
this->treeViewExample->Sort();

use std::env;
use std::fs::File;
use std::io::prelude::*;

fn read_u32(buf: &Vec<u8>, offset: usize) -> u32 {
    let a = buf[offset + 0] as u32;
    let b = buf[offset + 1] as u32;
    let c = buf[offset + 2] as u32;
    let d = buf[offset + 3] as u32;

    (a | (b << 8) | (c << 16) | (d << 24))
}

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() == 2 {
        let file_name = &args[1];
        let mut file = File::open(file_name).expect("file not found");

        let mut content: Vec<u8> = Vec::new();
        let file_size = file
            .read_to_end(&mut content)
            .expect("Can't read file content");

        let mut shd_idx: u32 = 0;
        let mut offset: usize = 44;
        while offset < file_size {
            let dxbc: u32 = read_u32(&content, offset);
            let size = read_u32(&content, offset + 24) as usize;

            if dxbc == 0x43425844 {
                let shader_name = format!("{}{:04}.bin", "shd_", shd_idx);
                let mut shd_file = File::create(shader_name).expect("Can't create output file");
                shd_file
                    .write(&content[offset..(offset + size)])
                    .expect("Can't write to output file");
                shd_file.sync_all().unwrap();

                println!("Unpacking shader #{} of size {}", shd_idx, size);

                offset += size + 8;
                while content[offset] == 0 {
                    offset = offset + 1;
                }

                shd_idx = shd_idx + 1;
            } else {
                // quit
                offset = file_size
            }
        }
    }
}

this->treeSpawns->BeginUpdate();

// Очистка перед заполнением древа
this->treeSpawns->Nodes->Clear();
this->treeSpawns->SelectedNode = nullptr;

// Заполнение древа нодами
// ...

// Сортировка
this->treeSpawns->TreeViewNodeSorter = gcnew NodeSorter();
this->treeSpawns->Sort();

this->treeSpawns->EndUpdate();

this->treeView1->SuspendLayout();
this->treeView1->Sorted = false;
this->treeView1->TreeViewNodeSorter = nullptr;

this->treeView1->Sorted = true;
this->treeView1->ResumeLayout();
this->treeView1->TreeViewNodeSorter = gcnew NodeSorter();