Changelog

All notable changes to the RuntimePluggableClassFactory project will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[2.1.0] - 2025-11-03

Added - Async Module-Based Plugin Loading Support

Expanded Async Loading Capabilities

• **HybridPluginFactory**: Officially exposed factory for working with both traditional and containerized plugins
• PluginInfo: Public type for plugin metadata including execution mode and container information
• PluginExecutionMode: Enum for specifying plugin execution mode (Auto, Traditional, Containerized)
• HybridPluginFactoryOptions: Configuration options for hybrid plugin loading
• Moved hybrid plugin types from Examples namespace to main public API namespace

Module Identification Types (Already Public, Now Documented)

• PluginIdentifier: Identifies plugins by namespace, name, and version
• ContainerizedPluginInfo: Information about deployed containerized plugins
• **ContainerizedPluginLoader**: Async loader for containerized plugins
• **ContainerizedPluginProxy**: Proxy for bridging traditional and containerized plugin execution
• ContainerizedPluginLoaderOptions: Configuration for containerized plugin loading

Changed

• Moved HybridPluginFactory and related types from .Examples namespace to .Containerized namespace
• Elevated hybrid plugin loading from example code to officially supported public API

Use Cases Enabled

• Dynamic Module Loading from Kubernetes/Remote Sources: Full support for async loading of plugins from containerized environments
• Hybrid Plugin Architectures: Seamlessly mix traditional in-process plugins with containerized plugins
• Custom Async Plugin Loaders: All types needed for implementing custom module-based async plugin loading are now publicly exposed

[2.0.0] - 2025-07-24

Added - TDS Implementation Complete

Dynamic Plugin Loading/Unloading

• PluginLoadContext: Collectible AssemblyLoadContext for proper memory cleanup
• FilePluginLoader: Enhanced with UnloadPlugin() and UnloadAllPlugins() methods
• PluginWatcher: Runtime plugin detection and hot-swapping capabilities
• Proper resource disposal and memory management

Enhanced Stability & Error Handling

• PluginExecutionSandbox: Isolated execution environment for plugins
• Enhanced PluginClassFactory: Comprehensive error handling with events
• Error Events: PluginInstantiationError, PluginLoadingFailed, SecurityValidationFailed
• Graceful degradation on plugin failures
• Detailed error reporting and logging

Type Safety

• ITypedPluginClass<TInput, TOutput>: Generic interface for type-safe plugin execution
• PluginExecutionContext: Functional context with logging, cancellation, and properties
• TypedPluginClassFactory: Type-safe plugin factory implementation
• **PluginExecutionResult**: Strongly-typed execution results
• Async execution with timeout support

Security Hardening

• IPluginSecurityValidator: Security validation interface
• DefaultPluginSecurityValidator: Comprehensive security validation implementation
• PluginSecuritySettings: Configurable security policies (Default, Strict, Permissive)
• Multi-level security validation (assembly, type, method)
• Digital signature verification and trusted path validation
• Prohibited namespace and type detection

Comprehensive Testing

• 48 tests across 7 categories:
  • Unit Tests (8) - Core functionality
  • Stability Tests (3) - Error handling and resilience
  • Unloading Tests (2) - Dynamic plugin unloading
  • Typed Plugin Tests (6) - Type-safe plugin system
  • Security Tests (13) - Security hardening validation
  • Integration Tests (8) - End-to-end workflows
  • Performance Tests (8) - Performance and scalability
• Performance benchmarks with automated validation
• TestingStrategy.md: Comprehensive testing documentation

Documentation

• TDS_IMPLEMENTATION.md: Complete implementation documentation
• TestingStrategy.md: Comprehensive testing approach
• README.md: Updated with new features and usage examples
• Migration guide for existing implementations
• Architecture overview and performance characteristics

Changed

Breaking Changes

1. Assembly Loading: Direct Assembly.LoadFrom() replaced with AssemblyLoadContext
2. Plugin Discovery: Plugin enumeration now async (ListAllPossiblePluginsAsync())
3. Error Handling: Exceptions now wrapped in events for better error management
4. Security: Plugin loading now includes security validation by default
5. Target Framework: Upgraded from .NET Standard 2.0 to .NET 8.0

Performance Improvements

• Plugin discovery: < 5 seconds
• Plugin instantiation: < 100ms average, < 500ms max
• Plugin execution: < 10ms average for simple operations
• Concurrent throughput: > 100 executions/second
• Security validation: < 500ms average
• Memory growth: < 50MB under load
• Load/unload cycles: < 2 seconds average

Migration Guide

From v1.x to v2.0

1. Plugin Interfaces: Existing IPluginClass implementations remain compatible
2. Plugin Loading: Replace direct assembly loading with FilePluginLoader<T>
3. Error Handling: Subscribe to error events for comprehensive error management
4. Security: Add security validation to plugin loading process
5. Type Safety: Optionally migrate to ITypedPluginClass<TInput, TOutput> for type safety

Example Migration

Before (v1.x):

var pluginLoader = new FilePluginLoader<IMyPlugin>(pluginDirectory);
var factory = new PluginClassFactory<IMyPlugin>(pluginLoader);

After (v2.0):

var securityValidator = new DefaultPluginSecurityValidator(PluginSecuritySettings.CreateDefault());
var pluginLoader = new FilePluginLoader<IMyPlugin>(pluginDirectory, securityValidator);
var factory = new PluginClassFactory<IMyPlugin>(pluginLoader);

// Subscribe to error events
factory.PluginInstantiationError += (sender, e) => Console.WriteLine($"Plugin error: {e.Exception.Message}");

// Use type-safe factory (optional)
var typedFactory = new TypedPluginClassFactory<IMyTypedPlugin, MyInput, MyOutput>(pluginLoader);

[1.0.7] - 2020-11-07

Added

• Initial release of RuntimePluggableClassFactory
• Basic plugin loading from file directories
• Version-aware plugin management
• Interface-based plugin architecture
• Thread-safe plugin execution
• Basic error handling

Features

• Dynamic plugin loading from file directories
• Version management and plugin discovery
• IPluginClass interface for plugin development
• PluginClassFactory<T> for plugin instantiation
• FilePluginLoader<T> for file-based plugin loading
• Basic assembly loading and type resolution

---

Version Numbering

• Major version (X.0.0): Breaking changes, significant architectural changes
• Minor version (X.Y.0): New features, backward compatible
• Patch version (X.Y.Z): Bug fixes, minor improvements

Support

For questions, issues, or support:

• Review the comprehensive test suite (48 tests)
• Check the TDS Implementation Guide
• Examine the Testing Strategy
• Create an issue on GitHub