📑 Quick Navigation

Section	Description
🖼 Screenshots	Visual examples and use cases
🛒 Features	Complete feature list
👏 How to Use	Quick start guide
⚡ Performance	Performance optimizations (v2.2+)
🏗️ Architecture	Service-based design
📚 Documentation	Complete documentation index
🧪 Testing	Unit tests and quality
🐛 Bug Fixes	Recent critical fixes (v2.5.0)
📝 Changelog	Version history and changes
🔧 Frameworks	.NET support

---

💎 About WPF HexEditor

WPF HexEditor is a powerful, high-performance hex editor control designed specifically for .NET applications. Built with modern architecture and optimized for both small and large files, it provides a professional-grade binary editing experience.

🎯 Key Highlights

• 🚀 Blazing Fast - 99% faster rendering than V1, handles GB+ files with ease
• 🔧 Easy Integration - Drop-in WPF/WinForms control, works out of the box
• 🎨 Fully Customizable - Colors, fonts, themes, and display modes
• ⚡ Production Ready - Battle-tested with 80+ unit tests and comprehensive samples
• 🌍 Multilingual - 9 languages with instant switching: 🇺🇸 English, 🇪🇸 Spanish (ES/LATAM), 🇫🇷 French (FR/CA), 🇵🇱 Polish, 🇧🇷 Portuguese, 🇷🇺 Russian, 🇨🇳 Chinese

🆕 What's New in V2?

V2 represents a complete architectural overhaul with dramatic performance improvements:

• ✅ 99% faster rendering - Custom DrawingContext vs ItemsControl
• ✅ 10-100x faster search - LRU cache + parallel + SIMD optimization
• ✅ 80-90% less memory - Handle files that crashed V1
• ✅ Insert Mode fixed - Critical bug #145 resolved
• ✅ Service architecture - MVVM + 10 specialized services
• ✅ 100% backward compatible - Drop-in replacement for V1

See full V1 vs V2 comparison 👇

🌐 Cross-Platform Architecture (Preview)

NEW: Core library is now platform-agnostic! The business logic has been extracted to netstandard2.0, enabling support for multiple UI frameworks:

• ✅ WpfHexaEditor.Core - Platform-agnostic business logic (netstandard2.0)
• ✅ WpfHexaEditor.Wpf - WPF platform implementation (net48, net8.0-windows)
• ✅ WpfHexaEditor.Avalonia - Avalonia platform implementation (net8.0)
• 🚧 Future: MAUI, Uno Platform, Console applications

Key Benefits:

• 📱 True Cross-Platform - Same Core works on Windows (WPF), Linux, macOS, Web (Avalonia)
• 🧪 Testable - Business logic tested without UI frameworks (46 unit tests ✓)
• 🔌 Zero Dependencies - Core has no UI framework dependencies
• ⚡ Same Performance - Full SIMD/parallel optimizations maintained

Status: Preview - Core library complete with tests and examples. See ARCHITECTURE.md for details.

🎯 Perfect For

• 🔍 Developers - Debug binary protocols, inspect file formats
• 🎮 Game Modders - ROM hacking with custom TBL character tables
• 🔐 Security Researchers - Analyze executables and data structures
• 📊 Data Scientists - Visualize and analyze binary data patterns
• 💾 System Administrators - Low-level file inspection and repair

⭐ Support This Project

WPF HexEditor is 100% free and open source (Apache 2.0). It can be used in personal projects, commercial applications, and everything in between.

This project is developed in free time by passionate contributors. If you find it useful:

• ⭐ Star this repository - It helps others discover the project!
• 🍴 Fork and contribute - Pull requests are always welcome
• 💬 Share feedback - Report bugs or suggest features
• 📖 Improve documentation - Help others get started

Every star motivates us to keep improving! 🙏

🖼 Screenshots

📝 Standard ASCII View Clean interface with hex/ASCII side-by-side	🎮 Custom TBL (Final Fantasy II) Game ROM editing with custom character tables
🔍 Find & Replace Advanced search with pattern matching	📊 BarChart View ⭐ Visual data representation for analysis

🔧 Advanced Features - Click to see more screenshots

⚙️ ByteShift + Fixed Table Editing Advanced table editing with byte shifting	🖥️ AvalonDock Integration ⭐ Dockable panels for complex workflows
🎨 Custom Background Blocks Visual diff and data highlighting

🧾 What is TBL (custom character table)? - Click to learn more

The TBL are small plaintext .tbl files that link every hexadecimal value with a character, which proves most useful when reading and changing text data. WPF HexEditor supports .tbl files and you can define your custom character table as you want.

Common Use Cases:

• 🎮 Game ROM hacking - Translate game text using custom character mappings
• 📝 Retro computing - Work with non-standard character encodings
• 🔤 Custom encodings - Define application-specific character sets

Unicode TBL Support: Unicode characters are fully supported. Place the value to the right of the equal sign (=) in your plaintext .tbl file:

0401=塞西尔
42=Д
01=[START]
02=[END]

Example TBL File Structure:

How to Use:

1. Create a .tbl file with your character mappings
2. Load it in the hex editor: HexEditor.LoadTBLFile("path/to/file.tbl")
3. The editor will display bytes using your custom character table
4. Switch between ASCII and TBL modes on-the-fly

Supported in both V1 and V2 ✅

🛒 Feature Comparison: V1 (Legacy) vs V2

Legend: ✅ = Available | ⚠️ = Limited/Buggy | ❌ = Not Available | 🆕 = New in V2 | ⚡ = Performance improvement in V2

Note (v2.6+): V2 is now the main control called HexEditor. V1 is now HexEditorLegacy (deprecated).

📝 Core Editing

Feature	V1 (HexEditorLegacy)	V2 (HexEditor - Main)	Notes
Multi-format editing (Hex/Dec/Bin)	✅	✅
Multi-byte support (8/16/32-bit)	✅	✅
Endianness (Little/Big Endian)	✅	✅
Insert Mode	⚠️	✅	V2: Fixed critical bugs (Issue #145)
Delete bytes	✅	✅
Append bytes	✅	✅
Fill selection	✅	✅
Unlimited Undo/Redo	✅	✅	V2: Better memory optimization
Read-only mode	✅	✅

🔍 Search & Navigation

Feature	V1	V2	Notes
Advanced search (FindFirst/Next/Last/All)	✅	✅
Pattern search (byte[]/string)	✅	✅
Replace operations	✅	✅
LRU Search caching	❌	✅ 🆕⚡	V2: 10-100x faster repeated searches
Parallel multi-core search	❌	✅ 🆕⚡	V2: 2-4x faster for large files (>100MB)
SIMD vectorization	❌	✅ 🆕⚡	V2: 4-8x faster single-byte search (AVX2/SSE2)
Highlight search results	✅	✅
Bookmarks	✅	✅
Go to offset	✅	✅
Selection highlighting	✅	✅

📋 Copy/Paste & Export

Feature	V1	V2	Notes
Standard clipboard (Ctrl+C/V/X)	✅	✅
Copy as code (C#/VB/Java/Python)	✅	✅
Multiple formats (Hex/ASCII/Binary)	✅	✅
Copy to stream	✅	✅
Custom copy modes	✅	✅

🎨 Display & Visualization

Feature	V1	V2	Notes
BarChart view	❌	✅ 🆕	V2 only: Visual data representation
AvalonDock support	❌	✅ 🆕	V2 only: Dockable panels
Byte grouping (2/4/6/8/16 bytes)	✅	✅
Multiple encodings (ASCII/UTF-8/UTF-16/etc.)	✅	✅
Custom TBL support	✅	✅
Unicode TBL	✅	✅
Zoom (50%-200%)	✅	✅
Show deleted bytes	✅	✅
Line addressing	✅	✅
Offset modes (Hex/Dec)	✅	✅
Scrollbar markers	❌	✅ 🆕	V2 only: Visual markers for search/bookmarks/changes

⚡ Performance & Optimization

Feature	V1	V2	Improvement
UI Rendering	ItemsControl	DrawingContext ⚡	V2: 99% faster (5-10x)
Memory usage	High	Optimized ⚡	V2: 80-90% reduction
Render caching	❌	✅ ⚡	V2: 5-10x faster rendering
Width calculation cache	❌	✅ ⚡	V2: 10-100x faster
Span<T> APIs	❌	✅ ⚡	V2: 90% less allocation (.NET 5.0+)
Profile-Guided Optimization	❌	✅ ⚡	V2: 10-30% boost (.NET 8.0+)
Async operations	❌	✅ ⚡	V2: 100% UI responsiveness
Large file support (GB+)	⚠️ Slow	✅ Fast	V2: Memory-mapped files

🏗️ Architecture

Feature	V1	V2	Notes
Architecture style	Monolithic	MVVM + Services 🆕	V2: Clean separation of concerns
Service layer	❌	✅ 🆕	V2: 10 specialized services
Unit testable	⚠️ Difficult	✅ Easy	V2: 80+ unit tests
ByteProvider	✅	✅ Enhanced	V2: Better performance
Stream support	✅	✅
Event system	✅	✅ Enhanced	V2: More events
Change tracking	✅	✅

🎨 Customization

Feature	V1	V2	Notes
Color customization	✅	✅
Custom backgrounds	✅	✅
Font customization	✅	✅
Border styles	✅	✅
Status bar	✅	✅
Context menus	✅	✅

🧪 Developer Features

Feature	V1	V2	Notes
HexBox control	✅	✅
Dependency properties	✅	✅
MVVM compatible	⚠️ Limited	✅ Full	V2: True MVVM architecture
Sample applications	✅	✅	7+ samples for both versions
Unit tests	❌	✅ 🆕	V2: 80+ tests with xUnit
Benchmarks	❌	✅ 🆕	V2: BenchmarkDotNet suite
Localization	✅	✅	6 languages

📊 File Format Support

Feature	V1	V2	Notes
Any binary file	✅	✅
Large files (GB+)	⚠️ Slow	✅ Fast	V2: Much better performance
Partial loading	✅	✅
Stream editing	✅	✅
Custom formats (TBL)	✅	✅

⌨️ Keyboard Shortcuts

Shortcut	V1	V2	Function
Ctrl+C / V / X	✅	✅	Copy/Paste/Cut
Ctrl+Z / Y	✅	✅	Undo/Redo
Ctrl+A	✅	✅	Select All
Ctrl+F	✅	✅	Find dialog
Ctrl+H	✅	✅	Replace dialog
Ctrl+G	✅	✅	Go to offset
Ctrl+B	✅	✅	Toggle bookmark
ESC	✅	✅	Clear selection
Delete / Backspace	✅	✅	Delete bytes
Arrow keys	✅	✅	Navigation
Page Up/Down	✅	✅	Fast scrolling

---

🎯 Summary: Why Choose V2?

Performance Gains:

• 🚀 99% faster rendering (DrawingContext vs ItemsControl)
• 🚀 10-100x faster search (LRU cache + parallel + SIMD)
• 🚀 80-90% less memory usage
• 🚀 100% UI responsiveness (async operations)

Critical Bug Fixes:

• ✅ Issue #145 FIXED: Insert Mode now works correctly (was producing F0 pattern)
• ✅ Better stability: MVVM architecture with proper separation of concerns
• ✅ Save operations: Root cause of data loss fixed (pending validation)

New Features:

• 🆕 BarChart visualization
• 🆕 AvalonDock integration
• 🆕 Scrollbar markers
• 🆕 Service-based architecture (80+ unit tests)

V2 is 100% backward compatible - drop-in replacement for V1 with same public API!

---

📖 See Performance Guide for detailed optimization documentation

⚡ Performance Optimizations (v2.2+)

📖 For detailed performance documentation, benchmarking results, and best practices, see the Performance Guide

Advanced Backend Optimizations:

• 🚀 LRU Cache for Search Results (Option 4)

  • 10-100x faster for repeated searches
  • Intelligent caching with automatic eviction of least recently used results
  • Thread-safe with O(1) lookup performance
  • Configurable capacity (default: 20 cached searches)

• ⚡ Parallel Multi-Core Search (Option 5)

  • 2-4x faster for large files (> 100MB)
  • Automatic threshold detection (uses all CPU cores for large files)
  • Zero overhead for small files (automatic fallback to standard search)
  • Thread-safe with overlap handling for patterns spanning chunk boundaries

• 🎯 Profile-Guided Optimization (PGO) (Option 6)

  • 10-30% performance boost for CPU-intensive operations (.NET 8.0+)
  • Dynamic runtime optimization with tiered compilation
  • 30-50% faster startup with ReadyToRun (AOT compilation)
  • Automatic in Release builds

• 🔍 SIMD Vectorization (net5.0+)

  • 4-8x faster single-byte searches with AVX2/SSE2
  • Processes 32 bytes at once with AVX2 (16 with SSE2)
  • Automatic hardware detection and fallback

• 📦 Span + ArrayPool

  • 2-5x faster with 90% less memory allocation
  • Zero-allocation memory operations
  • Buffer pooling for efficient resource usage

• ⏱️ Async/Await Support

  • 100% UI responsiveness during long operations
  • Progress reporting (0-100%) with IProgress
  • Cancellation support with CancellationToken

Combined Results:

• 10-100x faster operations (depending on optimization tier)
• 95% less memory allocation
• 100% backward compatible - no breaking changes
• Automatic selection - optimizations activate based on file size/hardware

UI Rendering Optimizations (NEW!):

• 🎨 Cached Typeface & FormattedText (BaseByte.cs)

  • 2-3x faster rendering by reusing expensive WPF objects
  • Intelligent cache invalidation (only when text/font changes)
  • Eliminates allocations on every OnRender() call

• 📏 Cached Width Calculations (HexByte.cs)

  • 10-100x faster width lookups with static Dictionary cache
  • O(1) lookups instead of repeated calculations
  • Thread-safe with lock protection

• ⚡ Batch Visual Updates (BaseByte.cs)

  • 2-5x faster for multiple property changes
  • BeginUpdate/EndUpdate pattern prevents redundant updates
  • Single UpdateVisual() call instead of multiple

• 💾 Optimized StringByte Rendering

  • 2-3x faster by caching width calculations
  • No re-computation on every render unless text changes
  • Optimized for both TBL and ASCII modes

UI Performance Gains:

• 5-10x faster UI operations overall
• 50-80% reduction in rendering allocations
• 100% backward compatible - no API changes
• Automatic - optimizations always active

Data Structure Optimizations (NEW v2.2+):

• ✨ HighlightService HashSet Migration

  • 2-3x faster highlight operations with HashSet vs Dictionary
  • 50% less memory usage (single long vs key-value pair)
  • Single lookup operations (no redundant ContainsKey checks)

• 📦 Batching Support for Bulk Operations

  • 10-100x faster when highlighting thousands of search results
  • BeginBatch/EndBatch pattern prevents UI updates during operations
  • Real-world: 1000 highlights in ~100μs instead of 1.2ms

• 🚀 Bulk APIs

  • AddHighLightRanges() - 14x faster than loops (5-10x typical)
  • AddHighLightPositions() - 27x faster for scattered positions
  • Auto-batching when not already in batch mode

Highlight Performance Gains:

• 10-100x faster bulk highlighting (with batching)
• 2-3x faster single operations
• 50% less memory for highlight tracking
• 100% backward compatible - same API, better performance

🚀 Phase 6: Critical Performance Optimizations (NEW v2.5+)

🔥 MASSIVE PERFORMANCE GAINS - Up to 6,000x faster for large edited files!

📖 Full documentation: OPTIMIZATIONS_PHASE6.md

Phase 6.1: SIMD Comparisons ⚡⚡⚡

• 16-32x faster byte comparisons using Vector instructions
• Processes 16-64 bytes per CPU instruction (vs 1 byte scalar)
• Automatic hardware detection: SSE2 (16 bytes), AVX2 (32 bytes), AVX-512 (64 bytes)
• Conditional compilation: .NET 5.0+ gets SIMD, .NET Framework gets optimized scalar
• API: ComparisonService.CountDifferencesSIMD(), CalculateSimilaritySIMD()

Phase 6.2: Parallel Multi-Core Processing ⚡⚡

• 2-4x faster for files > 100MB on multi-core CPUs
• Automatic threshold detection (100MB) - zero overhead for small files
• Near-linear scaling: 4-core = 2.8x, 8-core = 3.8x, 16-core = 4.0x
• Uses Parallel.For with ConcurrentBag for thread-safe accumulation
• API: ComparisonService.CountDifferencesParallel(), CalculateSimilarityParallel()

Phase 6.3: SortedDictionary Optimization ⚡

• 3-10x faster GetAllModifiedPositions() calls in PositionMapper
• Pre-sorted collections: SortedDictionary + SortedSet vs unsorted
• O(m) merge vs O(m log m) sort - critical for files with many edits
• Trade-off: O(log n) insert vs O(1), but GetAllModifiedPositions() called frequently
• Automatic - no API changes required

Phase 6.4: Boyer-Moore Public API 🏗️

• Refactored search from ViewModel to ByteProvider public API
• Better architecture - search logic in data layer, not presentation
• Removed ~100 lines of duplicate code from ViewModel
• New public API: FindFirst(), FindNext(), FindLast(), FindAll(), CountOccurrences()
• Single source of truth for Boyer-Moore-Horspool algorithm

Phase 6.5: TRUE Binary Search ⚡⚡⚡⚡⚡ HIGHEST IMPACT!

• 100-5,882x faster position conversions (critical bug fix!)
• Bug discovered: Code claimed O(log m) binary search but used O(m) linear scan
• Fixed: Implemented true binary search with FindSegmentForPhysicalPosition()
• Performance: 1,000 edits = 100x, 10,000 edits = 769x, 100,000 edits = 5,882x!
• Real-world impact: Files with heavy edits now open instantly, scroll smoothly, no freezes

Phase 6 Combined Results:

• File comparison (1GB, SIMD+Parallel): 32x faster ⚡⚡⚡
• Position mapping (100k edits): 5,882x faster ⚡⚡⚡⚡⚡
• Total combined: Up to 6,000x faster for large edited files! 🔥
• Build: 0 errors, 0 warnings, 100% backward compatible
• Platforms: .NET Framework 4.8 + .NET 8.0-windows (multi-targeting)

See PERFORMANCE_GUIDE.md for comprehensive documentation.

👏 How to use

Add a reference to WPFHexaEditor.dll from your project, then add the following namespace to your XAML:

xmlns:control="clr-namespace:WpfHexaEditor;assembly=WPFHexaEditor"

Insert the control like this in your XAML...:

<control:HexEditor/>
<control:HexEditor Width="NaN" Height="NaN"/>
<control:HexEditor Width="Auto" Height="Auto"/>
<control:HexEditor FileName="{Binding FileNamePath}" Width="Auto" Height="Auto"/>

🏗️ Architecture

WPF HexEditor now uses a modern service-based architecture for improved maintainability and testability.

📖 Documentation:

• ARCHITECTURE.md - High-level service layer architecture
• ARCHITECTURE_V2.md - Detailed V2 internals: ByteProvider, LIFO insertions, position mapping, save operations

Service Layer (10 Services)

The control is powered by specialized services that handle different aspects of functionality:

Core Services

• 📋 ClipboardService - Manages copy/paste/cut operations
• 🔍 FindReplaceService - Search and replace with LRU cache + parallel search (10-100x faster)
• ↩️ UndoRedoService - Undo/redo history management
• 🎯 SelectionService - Selection validation and manipulation
• ✨ HighlightService - Manages byte highlighting with HashSet + batching (10-100x faster bulk operations)
• 🔧 ByteModificationService - Handles insert, delete, and modify operations

Additional Services

• 🔖 BookmarkService - Bookmark management and navigation
• 📚 TblService - Custom character table (TBL) operations
• 📐 PositionService - Position calculations and conversions
• 🎨 CustomBackgroundService - Custom background color blocks

Benefits:

• ✅ Separation of concerns - Each service has a single responsibility
• ✅ Unit testable components - Services can be tested in isolation
• ✅ Reusable across projects - Services are decoupled from HexEditor
• ✅ Easier to maintain and extend - Clear APIs and focused logic
• ✅ No breaking changes - Public API preserved during refactoring

Statistics:

• 10 services total (6 stateless, 4 stateful)
• ~150+ public methods
• ~2500+ lines of business logic extracted

See Services Documentation for details.

📚 Documentation

📖 Table of Contents

• Getting Started - Quick integration guide
• Architecture - Service-based design overview
• Performance Guide - ⚡ Performance optimization, benchmarking, best practices
• API Reference - HexEditor control documentation
• Sample Applications - Working examples
• Core Components - Internal architecture
• Testing - Unit tests and quality assurance

---

🎯 Main Control API

WPFHexaEditor Control - Complete documentation for the main HexEditor control

• Control architecture with 10 services
• Property reference and customization
• Usage examples (basic and advanced)
• Performance optimization tips
• Multi-targeting support (.NET 4.8 / .NET 8.0)
• Internationalization (6 languages)

📐 Architecture & Design

Architecture Diagrams - Visual architecture documentation

• Service layer architecture (Mermaid diagrams)
• Data flow diagrams
• Component relationships
• Design patterns used

Services Layer - Business logic architecture

• Complete API reference for all 10 services
• Service usage examples and patterns
• Stateless vs stateful services
• Integration guidelines

🎨 Sample Applications

Samples Overview - All sample applications

Individual Samples:

• C# WPF Sample - Main comprehensive demo
• VB.NET Sample - Visual Basic version
• WinForms Sample - Windows Forms integration
• AvalonDock Sample - Professional IDE-like interface
• BarChart Sample - Visual data analysis
• Binary Diff Sample - File comparison
• Insert Anywhere Sample - Dynamic insertion/deletion
• Service Usage Sample - Console app using services without UI

🧩 Core Components

Core Overview - Core infrastructure documentation

Detailed Component Documentation:

• Bytes/ - ByteProvider and byte manipulation

  • File/stream I/O with modification tracking
  • Insert/delete/modify operations
  • Undo/redo support
  • Conversion utilities

• CharacterTable/ - TBL file support

  • Custom character encoding for game hacking
  • Multi-byte character support (DTE)
  • Bidirectional byte ↔ character mapping

• Converters/ - WPF value converters

  • Hex/decimal conversions
  • Visibility converters
  • Path/filename converters

• EventArguments/ - Custom event args

  • ByteEventArgs for modifications
  • ByteDifferenceEventArgs for comparisons
  • CustomBackgroundBlockEventArgs for highlighting

• Interfaces/ - Core interfaces

  • IByte - Byte control contract
  • IByteControl - Manipulation interface
  • IByteModified - Change tracking contract

• MethodExtention/ - Extension methods

  • Byte array extensions
  • String parsing helpers
  • Double formatting
  • Application helpers

• Native/ - Windows API P/Invoke

  • High-performance file I/O
  • Memory-mapped files
  • Native window operations

• Dialog/ - UI dialogs

  • Find window
  • Find/Replace window
  • Byte input dialogs

🧪 Testing & Quality

Unit Tests - Test suite documentation

• 80+ unit tests with xUnit
• Service layer test coverage
• Test patterns and best practices
• Running tests and CI/CD integration

🔧 Development Tools

ByteProviderBench - Performance benchmarking tool

• Read/write performance testing
• Memory usage profiling
• Search algorithm benchmarks

📂 Project Structure

Sources Overview - Complete source code structure

• Directory organization
• Build instructions
• Multi-targeting configuration

🔧 Supported Frameworks

WPF HexEditor uses multi-targeting to support both legacy and modern .NET platforms:

📦 Target Frameworks

Framework	Version	Description	Use Case
net48	.NET Framework 4.8	Legacy Windows desktop platform	Existing WPF/WinForms applications
net8.0-windows	.NET 8 (LTS)	Modern cross-platform .NET	New applications, better performance

✨ Benefits of Multi-Targeting

• ✅ Single NuGet Package - Works in both old and new projects
• ✅ Zero Breaking Changes - Drop-in replacement for existing apps
• ✅ Future-Proof - Ready for .NET Core migration
• ✅ Best Performance - Modern .NET gets latest optimizations (Span<T>, SIMD)
• ✅ Same API - Identical code works on both platforms

🚀 Usage

<!-- .NET Framework 4.8 project -->
<TargetFramework>net48</TargetFramework>
<PackageReference Include="WPFHexaEditor" Version="2.2.0" />

<!-- .NET 8.0 project -->
<TargetFramework>net8.0-windows</TargetFramework>
<PackageReference Include="WPFHexaEditor" Version="2.2.0" />

Both scenarios use the exact same NuGet package - the correct binary is automatically selected!

🧪 Unit Testing

The project includes comprehensive unit tests for all service layer components:

• Test Framework: xUnit with .NET 8.0-windows
• Test Project: WPFHexaEditor.Tests
• Coverage: 80+ tests across 3 test suites
  • SelectionServiceTests - 35 tests for selection operations
  • FindReplaceServiceTests - 35 tests for search/replace with caching
  • HighlightServiceTests - 10+ tests for highlight management

Running tests:

cd Sources/WPFHexaEditor.Tests
dotnet test

The service-based architecture makes unit testing straightforward - services can be tested in isolation without UI dependencies.

🐛 Recent Bug Fixes

v2.5.0 Major Release (2026-02-14) 🎉

Why 2.5.0? This release marks the completion of the V2 architecture transformation with MVVM + Services, dramatic performance improvements (99% faster rendering, 10-100x faster search), and resolution of ALL critical bugs. This significant milestone warrants a major minor version bump while maintaining 100% backward compatibility with V1 API.

Issue #145 - Insert Mode Hex Input Bug ✅ RESOLVED

• Problem: Typing "FFFFFFFF" in Insert mode produced "F0 F0 F0 F0" pattern instead of "FF FF FF FF"
• Root Cause: Critical bug in PositionMapper.PhysicalToVirtual() returning wrong virtual position
• Fix: Corrected virtual position calculation to return position AFTER insertions
• Impact: Insert mode now works perfectly in both hex and ASCII panels
• Commits: 405b164, 35b19b5
• Documentation: ISSUE_145_CLOSURE.md, ISSUE_HexInput_Insert_Mode.md

Save Data Loss Bug ✅ COMPLETELY RESOLVED

• Problem: Saving files with insertions caused catastrophic data loss (multi-MB files → hundreds of bytes)
• Root Cause: Same PositionMapper bug caused ByteReader to read wrong bytes during Save operations
• Fix: PositionMapper fix (commit 405b164) resolved the root cause
• Validation: ✅ ALL comprehensive tests passed (2026-02-14)
  • ✅ Save with insertions → file size = original + inserted bytes
  • ✅ Save with deletions → file size = original - deleted bytes
  • ✅ Save with modifications → file size unchanged
  • ✅ Save with mixed edits (insertions + deletions + modifications) → all verified correct
  • ✅ After save, reopen and verify content byte-by-byte → matches perfectly
• Performance: Added fast save path for modification-only edits (10-100x faster)
• Commits: 405b164, 35b19b5
• Documentation: ISSUE_Save_DataLoss.md, RESOLVED_ISSUES.md

V2 Architecture Documentation [UPDATED]

• Added: Complete ARCHITECTURE_V2.md with detailed diagrams
• Fixed: All Mermaid diagram rendering errors for GitHub compatibility
• Content: ByteProvider V2, LIFO insertion semantics, position mapping, save operations
• Commits: 3800bd8, 6af1bee, d572de1, 9a31b3f

v2.2.0 Critical Fixes (2026)

Search Cache Invalidation Fix

• Fixed search cache not being invalidated after data modifications
• Users now receive accurate search results after editing
• Cache properly cleared at all 11 modification points

🗺️ Complete Documentation Map

Every major folder in the project contains comprehensive README documentation:

📦 WpfHexEditorControl/
│
├── 📄 README.md (this file) ..................... Main project overview
├── 📄 ARCHITECTURE.md .......................... Architecture diagrams
│
├── 📂 Sources/
│   ├── 📄 README.md ............................ Source code overview
│   │
│   ├── 📂 WPFHexaEditor/
│   │   ├── 📄 README.md ........................ Main control documentation
│   │   │
│   │   ├── 📂 Services/
│   │   │   └── 📄 README.md .................... 10 services API reference
│   │   │
│   │   ├── 📂 Core/
│   │   │   ├── 📄 README.md .................... Core components overview
│   │   │   ├── 📂 Bytes/README.md .............. ByteProvider & data layer
│   │   │   ├── 📂 CharacterTable/README.md ..... TBL file support
│   │   │   ├── 📂 Converters/README.md ......... WPF value converters
│   │   │   ├── 📂 EventArguments/README.md ..... Custom event args
│   │   │   ├── 📂 Interfaces/README.md ......... Core interfaces
│   │   │   ├── 📂 MethodExtention/README.md .... Extension methods
│   │   │   └── 📂 Native/README.md ............. Windows API P/Invoke
│   │   │
│   │   └── 📂 Dialog/
│   │       └── 📄 README.md .................... Find/Replace dialogs
│   │
│   ├── 📂 WPFHexaEditor.Tests/
│   │   └── 📄 README.md ........................ 80+ unit tests
│   │
│   ├── 📂 Samples/
│   │   ├── 📄 README.md ........................ Samples overview
│   │   ├── 📂 WPFHexEditor.Sample.CSharp/README.md
│   │   ├── 📂 WpfHexEditor.Sample.VB/README.md
│   │   ├── 📂 WpfHexEditor.Sample.Winform/README.md
│   │   ├── 📂 WpfHexEditor.Sample.AvalonDock/README.md
│   │   ├── 📂 WpfHexEditor.Sample.BarChart/README.md
│   │   ├── 📂 WpfHexEditor.Sample.BinaryFilesDifference/README.md
│   │   ├── 📂 WpfHexEditor.Sample.InsertByteAnywhere/README.md
│   │   └── 📂 WpfHexEditor.Sample.ServiceUsage/README.md
│   │
│   └── 📂 Tools/
│       └── 📂 ByteProviderBench/
│           └── 📄 README.md .................... Performance benchmarking

Total Documentation: 19 comprehensive README files covering every aspect of the project! 📚

💡 Learning Path

Beginner: Start here

1. Read How to Use for basic integration
2. Explore C# Sample for practical examples
3. Review Main Control API for available properties

Intermediate: Dive deeper 4. Understand Architecture and service layer design 5. Study Services Documentation for advanced features 6. Try specialized samples (BarChart, Binary Diff)

Advanced: Master the internals 7. Explore Core Components architecture 8. Review ByteProvider for data layer understanding 9. Study Unit Tests for testing patterns 10. Build custom tools with Service Usage Sample

🤝 Contributing

We welcome contributions! The comprehensive documentation makes it easy to understand the codebase:

• All services are documented with API references
• Unit tests provide usage examples
• Architecture diagrams show component relationships
• Each folder has detailed README with examples

---

✨ WPF HexEditor - A powerful, well-documented hex editor control for .NET

Created by Derek Tremblay (derektremblay666@gmail.com) Contributors: ehsan69h, Janus Tida, Claude Sonnet 4.5

Coded with ❤️ for the community! 😊🤟