diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md index 4dd988ba..24885866 100644 --- a/.github/CONTRIBUTING.md +++ b/.github/CONTRIBUTING.md @@ -1,60 +1,196 @@ -# Contributing to Windows Memory Cleaner - -Thank you for your interest in contributing! Contributions are what make the open-source community such a great place to learn, inspire, and create. Hereโ€™s how you can help. - ---- - -## How Can I Contribute? - -We use GitHub Issues to track all bugs, feature requests, and questions. Please use the appropriate template for your submission. - -### ๐Ÿž Reporting Bugs - -If you've found a bug, please use the **[Bug Report](../../issues/new?template=bug_report.yml)** template. Be sure to include: -- Your application and Windows version. -- Steps to reproduce the issue. -- A clear description of the expected and actual behavior. - -### ๐Ÿš€ Suggesting Enhancements - -Have an idea for a new feature or an improvement? Use the **[Feature Request](../../issues/new?template=feature_request.yml)** template and describe: -- The problem you are trying to solve. -- Your proposed solution. - -### ๐ŸŒ Submitting Translations - -To add a new translation or update an existing one, please use the **[Translation Request](../../issues/new?template=translation_request.yml)** template. - -### โ“ Asking Questions - -If you have a question about the project, please use the **[Question](../../issues/new?template=question.yml)** template. This helps us keep all support-related communication in one place. - ---- - -## Pull Requests - -1. **Fork** the repo and create your branch from `develop`. -2. If youโ€™ve added code that should be tested, please add tests. -3. Ensure your code builds and passes all checks. -4. Fill out the PR template and link any related issues. - -### Coding Standards - -- Follow [Microsoft C# coding conventions](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions). -- Write clear and concise commit messages. - -### Code of Conduct - -Please review our [Code of Conduct](CODE_OF_CONDUCT.md). By participating, you agree to uphold these standards. - -### Security - -If you discover a potential security vulnerability, please see our [Security Policy](SECURITY.md) for guidance on how to report it. - -### License - -By contributing, you agree that your contributions will be licensed under the [GPL-3.0 License](LICENSE). - ---- - -Thank you for helping make it better! +# Contributing to WinMemoryCleaner + +Thank you for your interest in contributing! This document outlines the process and standards for contributing to this project. + +## Getting Started + +1. **Fork** the repository on GitHub +2. **Clone** your fork locally +3. **Add upstream remote**: `git remote add upstream https://github.com/IgorMundstein/WinMemoryCleaner.git` +4. **Create a branch**: `git checkout -b feature/your-feature-name` or `fix/issue-number-description` + +## Development Setup + +### Prerequisites +- Windows 7 SP1 / Server 2012+ +- [.NET 8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0) +- Administrator privileges (required to run optimizations) + +### Build & Run +```bash +# Restore dependencies +dotnet restore src/WinMemoryCleaner.csproj + +# Build (Release) +dotnet build src/WinMemoryCleaner.csproj -c Release + +# Run (framework-dependent) +dotnet run --project src/WinMemoryCleaner.csproj -c Release + +# Or publish single-file +dotnet publish src/WinMemoryCleaner.csproj -c Release -o publish +``` + +## Code Style & Conventions + +### C# Style +- **Language Version**: Latest (`LangVersion latest` in csproj) +- **Project Format**: SDK-style with `PackageReference` +- **Nullable**: Disabled (`disable`) +- **Implicit Usings**: Disabled +- **Formatting**: Follow existing code style (4-space indent, braces on new lines) + +### Naming Conventions +- **Classes/Interfaces**: PascalCase (`ComputerService`, `IComputerService`) +- **Methods/Properties**: PascalCase (`Optimize`, `MemoryAreas`) +- **Fields**: `_camelCase` (`_memory`, `_cancellationTokenSource`) +- **Parameters/Locals**: camelCase (`processName`, `isOptimizing`) +- **Constants**: PascalCase (`AutoUpdateInterval`) + +### Architecture Patterns +- **MVVM**: ViewModels in `ViewModel/`, Views in `View/` +- **Dependency Injection**: `DependencyInjection.Container.Register()` +- **Interfaces**: Prefix with `I` (`INotificationService`) +- **Async**: Prefer `async`/`await` over `.Result`/`.Wait()` + +### Resource Management +- Implement `IDisposable` for classes holding unmanaged resources +- Use `Marshal.AllocHGlobal`/`FreeHGlobal` instead of `GCHandle.Alloc` for native interop +- Always dispose `IDisposable` in `finally` blocks or `using` statements + +### Exception Handling +- **Never** use empty `catch { }` blocks +- Log exceptions with context: `Logger.Debug("Operation failed: " + ex.Message)` +- Use `ArgumentOutOfRangeException` for invalid enum values (not `NotImplementedException`) +- Implement `ConvertBack` for all `IValueConverter` implementations + +## Pull Request Process + +### Before Submitting +- [ ] Code builds clean: `dotnet build -c Release` (0 errors, 0 new warnings) +- [ ] Tested manually (both admin and non-admin scenarios) +- [ ] No breaking changes without discussion +- [ ] Updated `CHANGELOG.md` if user-facing changes +- [ ] Translations: **lowercase only** (app handles capitalization) + +### PR Title Format +- `feat: Add new feature description` (new functionality) +- `fix: Resolve issue #XXX - brief description` (bug fixes) +- `refactor: Improve X without behavior change` (code improvements) +- `perf: Optimize X for better performance` (performance) +- `docs: Update documentation for X` (documentation) + +### PR Description Template +```markdown +## Summary +Brief description of changes + +## Related Issues +Fixes #XXX +Relates to #YYY + +## Changes +- List of specific changes +- Another change + +## Testing +- [ ] Build passes +- [ ] Tested as admin (optimizations work) +- [ ] Tested non-admin (graceful errors) +- [ ] Single-file publish works +- [ ] Localization loads correctly + +## Screenshots (if UI changes) +``` + +## Translation Contributions + +### Adding a New Language +1. Copy `src/Resources/Localization/English.json` +2. Rename to `{Locale-Description}.json` (e.g., `Slovenian.json`) +3. Translate **all values to lowercase** (app auto-capitalizes) +4. Save as UTF-8 +5. Test: Place file next to `WinMemoryCleaner.exe` and launch +6. Submit PR or use [Translation Request template](https://github.com/IgorMundstein/WinMemoryCleaner/issues/new?template=translation_request.yml) + +### Updating Existing Translations +- Only modify values, never keys +- Keep lowercase format +- Maintain placeholder formatting: `{0}`, `{1}`, etc. + +## Issue Reporting + +### Bug Reports +Use the [Bug Report template](https://github.com/IgorMundstein/WinMemoryCleaner/issues/new?template=bug_report.yml) with: +- OS version (`winver`) +- .NET version (`dotnet --version`) +- Steps to reproduce +- Expected vs actual behavior +- Event Viewer logs (source: "Windows Memory Cleaner") + +### Feature Requests +Use the [Feature Request template](https://github.com/IgorMundstein/WinMemoryCleaner/issues/new?template=feature_request.yml) with: +- Use case description +- Proposed solution +- Alternatives considered + +## Testing Guidelines + +### Manual Testing Checklist +- [ ] App launches without errors (admin + non-admin) +- [ ] All 32+ languages load correctly +- [ ] Tray icon appears and updates +- [ ] Optimizations run and log to Event Viewer +- [ ] Settings persist to registry (HKLM) +- [ ] Service install/uninstall works +- [ ] Auto-update check doesn't crash +- [ ] Single-file publish runs (`PublishSingleFile=true`) +- [ ] Compact mode toggles +- [ ] Hotkey registration works + +### Automated Tests +- Run: `dotnet test src/WinMemoryCleaner.csproj -c Release` +- Add tests for new functionality in `src/Test/` + +## Architecture Overview + +``` +src/ +โ”œโ”€โ”€ App.xaml.cs # Application entry, lifecycle, single-instance +โ”œโ”€โ”€ Core/ +โ”‚ โ”œโ”€โ”€ Localizer.cs # Localization (lazy init, cached, fallback) +โ”‚ โ”œโ”€โ”€ Settings.cs # Registry persistence (thread-safe, ConcurrentDictionary) +โ”‚ โ”œโ”€โ”€ Logger.cs # Structured logging (EventLog, console, trace) +โ”‚ โ”œโ”€โ”€ Updater.cs # GitHub API, HttpClient, atomic update +โ”‚ โ”œโ”€โ”€ ThemeManager.cs # Theme loading, brush caching +โ”‚ โ””โ”€โ”€ ComputerService.cs # Native memory optimization (Marshal.AllocHGlobal) +โ”œโ”€โ”€ Service/ +โ”‚ โ”œโ”€โ”€ NotificationService.cs # Tray icon, memory usage rendering +โ”‚ โ”œโ”€โ”€ HotKeyService.cs # Global hotkeys (ConcurrentDictionary) +โ”‚ โ””โ”€โ”€ ComputerService.cs # IComputerService implementation +โ”œโ”€โ”€ WindowsService/ +โ”‚ โ”œโ”€โ”€ WinService.cs # Background service (Interlocked guard) +โ”‚ โ””โ”€โ”€ WinServiceInstaller.cs # sc.exe-based installer +โ”œโ”€โ”€ ViewModel/ +โ”‚ โ”œโ”€โ”€ MainViewModel.cs # Main UI logic, commands +โ”‚ โ””โ”€โ”€ Base/ViewModel.cs # Base VM with IsBusy, Navigation +โ”œโ”€โ”€ Model/ +โ”‚ โ”œโ”€โ”€ Localization.cs # 74 localized strings (public setters) +โ”‚ โ”œโ”€โ”€ Memory/*.cs # Memory stats structures +โ”‚ โ””โ”€โ”€ OperatingSystem.cs # OS version detection (fixed) +โ”œโ”€โ”€ Interop/ +โ”‚ โ”œโ”€โ”€ NativeMethods.cs # P/Invoke signatures (SupportedOSPlatform) +โ”‚ โ””โ”€โ”€ ShellInterop.cs # Shell links (IPersistFile) +โ””โ”€โ”€ Test/ # Unit/Integration tests +``` + +## Release Process (Maintainers Only) + +1. Update version in `src/WinMemoryCleaner.csproj` and `src/Properties/AssemblyInfo.cs` +2. Update `CHANGELOG.md` +3. Create GitHub Release with `dotnet publish` artifacts +4. SignPath.io handles code signing automatically via CI/CD + +## Questions? + +Open a [Discussion](https://github.com/IgorMundstein/WinMemoryCleaner/discussions) or check existing [Issues](https://github.com/IgorMundstein/WinMemoryCleaner/issues). \ No newline at end of file diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md deleted file mode 100644 index cb573bb7..00000000 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ /dev/null @@ -1,19 +0,0 @@ -## Summary -Please provide a brief description of the changes made in this pull request. - -## Related Issue -If applicable, link to the issue this PR addresses: `Fixes #` - -## Changes -- What did you change? -- Why is this change needed? - -## Checklist -- [ ] My code follows the projectโ€™s coding style and conventions. -- [ ] I have tested the changes locally. -- [ ] I have updated documentation if necessary. -- [ ] This PR does not introduce any breaking changes. -- [ ] I have added unit tests if applicable. - -## Additional Notes -Include any additional information or context for reviewers. \ No newline at end of file diff --git a/.github/workflows/analyze-dependencies.yml b/.github/workflows/analyze-dependencies.yml index e78739ad..5c2ab1e8 100644 --- a/.github/workflows/analyze-dependencies.yml +++ b/.github/workflows/analyze-dependencies.yml @@ -29,6 +29,7 @@ permissions: jobs: analyze-and-submit: + if: github.repository == 'IgorMundstein/WinMemoryCleaner' runs-on: windows-latest timeout-minutes: 10 @@ -55,6 +56,7 @@ jobs: - name: Create Pull Request id: cpr + if: ${{ secrets.PAT_TOKEN != '' }} uses: peter-evans/create-pull-request@v6 with: token: ${{ secrets.PAT_TOKEN }} @@ -67,12 +69,11 @@ jobs: delete-branch: true - name: Enable auto-merge on the PR - if: ${{ steps.cpr.outputs.pull-request-number }} + if: ${{ steps.cpr.outputs.pull-request-number && secrets.PAT_TOKEN != '' }} env: PR_NUMBER: ${{ steps.cpr.outputs.pull-request-number }} GH_TOKEN: ${{ secrets.PAT_TOKEN }} run: | Remove-Item Env:GITHUB_TOKEN -ErrorAction SilentlyContinue gh pr merge "$env:PR_NUMBER" --squash --auto --repo "$env:GITHUB_REPOSITORY" - shell: pwsh - + shell: pwsh \ No newline at end of file diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2b86692c..62a5ed85 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,13 +24,12 @@ concurrency: cancel-in-progress: true jobs: - build-and-test: - name: Build and Test + build: + name: Build runs-on: windows-latest outputs: app_version: ${{ steps.version.outputs.app_version }} unsigned_artifact_name: winmemorycleaner-${{ steps.version.outputs.app_version }} - test_artifact_name: ${{ steps.determine_artifact.outputs.name }} src_changed: ${{ github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' }} steps: @@ -45,63 +44,22 @@ jobs: if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' uses: actions/checkout@v4 - - name: Cache NuGet packages + - name: Setup .NET if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' - uses: actions/cache@v4 + uses: actions/setup-dotnet@v4 with: - path: ~/.nuget/packages - key: nuget-${{ hashFiles('**/*.csproj') }} - restore-keys: | - nuget- + dotnet-version: '8.0.x' + cache: false - - name: Setup MSBuild - if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' - uses: microsoft/setup-msbuild@v2 - - - name: Restore NuGet packages + - name: Restore dependencies if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' shell: pwsh - run: nuget restore src\WinMemoryCleaner.sln + run: dotnet restore src/WinMemoryCleaner.csproj - name: Build solution if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' shell: pwsh - run: msbuild src\WinMemoryCleaner.sln /m /p:Configuration=Release /p:Platform="Any CPU" - - - name: Run Tests - if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' - shell: pwsh - run: | - $testAssembly = "src\bin\Release\WinMemoryCleaner.exe" - $testRunner = "src\packages\NUnit.Runners.2.6.4\tools\nunit-console.exe" - - if (-Not (Test-Path $testRunner)) { - Write-Host "::error::Test runner not found at $testRunner" - exit 1 - } - - Write-Host "Running tests..." - & $testRunner $testAssembly /xml:TestResults.xml - - if ($LASTEXITCODE -ne 0) { - Write-Host "::error::Tests failed with exit code $LASTEXITCODE" - exit $LASTEXITCODE - } - - - name: Upload test results - if: always() && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true') - uses: actions/upload-artifact@v4 - with: - name: test-results-${{ github.run_number }} - path: TestResults.xml - retention-days: 30 - - - name: Publish test results - if: always() && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true') - uses: EnricoMi/publish-unit-test-result-action/windows@v2 - with: - files: TestResults.xml - check_name: Unit Test Results + run: dotnet build src/WinMemoryCleaner.csproj --configuration Release --no-restore - name: Get App Version if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' @@ -132,13 +90,30 @@ jobs: exit 1 } - - name: Upload unsigned EXE as artifact + - name: Publish self-contained single-file + if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' + shell: pwsh + run: | + dotnet publish src/WinMemoryCleaner.csproj ` + --configuration Release ` + --runtime win-x64 ` + --self-contained true ` + /p:PublishSingleFile=true ` + /p:IncludeAllContentForSelfExtract=true ` + --output publish/self-contained + + - name: Publish framework-dependent output + if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' + shell: pwsh + run: dotnet publish src/WinMemoryCleaner.csproj --configuration Release --runtime win-x64 --self-contained false --output src/bin/Release/net8.0-windows/win-x64/publish/ + + - name: Upload self-contained EXE as artifact if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' || steps.check_files.outputs.any_changed == 'true' id: upload-unsigned uses: actions/upload-artifact@v4 with: - name: winmemorycleaner-${{ steps.version.outputs.app_version }} - path: src\bin\Release\WinMemoryCleaner.exe + name: winmemorycleaner-${{ steps.version.outputs.app_version }}-selfcontained + path: publish/self-contained/WinMemoryCleaner.exe if-no-files-found: error - name: Submit to SignPath (Develop CI Signing) @@ -170,13 +145,13 @@ jobs: if ('${{ steps.signpath.conclusion }}' -eq 'success') { echo "name=winmemorycleaner-${{ steps.version.outputs.app_version }}-signed" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append } else { - echo "name=winmemorycleaner-${{ steps.version.outputs.app_version }}" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append + echo "name=winmemorycleaner-${{ steps.version.outputs.app_version }}-selfcontained" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append } test-ui: name: UI Test on ${{ matrix.os }} - needs: build-and-test - if: needs.build-and-test.outputs.src_changed == 'true' + needs: build + if: needs.build.outputs.src_changed == 'true' strategy: fail-fast: false matrix: @@ -184,10 +159,10 @@ jobs: runs-on: ${{ matrix.os }} steps: - - name: Download build artifact for testing + - name: Download self-contained build artifact for testing uses: actions/download-artifact@v4 with: - name: ${{ needs.build-and-test.outputs.test_artifact_name }} + name: winmemorycleaner-${{ needs.build.outputs.app_version }}-selfcontained - name: Run UI Test shell: pwsh @@ -231,8 +206,8 @@ jobs: package-screenshots: name: Package All Screenshots - needs: [build-and-test, test-ui] - if: needs.build-and-test.outputs.src_changed == 'true' + needs: [build, test-ui] + if: needs.build.outputs.src_changed == 'true' runs-on: ubuntu-latest steps: @@ -250,7 +225,7 @@ jobs: id: upload-screenshots uses: actions/upload-artifact@v4 with: - name: all-screenshots-${{ needs.build-and-test.outputs.app_version }} + name: all-screenshots-${{ needs.build.outputs.app_version }} path: ./all-screenshots/ retention-days: 30 @@ -267,4 +242,4 @@ jobs: os_name="${filename#screenshot-}" os_name="${os_name%.png}" echo "| $os_name | [$filename]($ARTIFACT_URL) |" >> $GITHUB_STEP_SUMMARY - done + done \ No newline at end of file diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 79037d56..5f64b662 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -6,6 +6,7 @@ on: - main paths: - 'src/**' + workflow_dispatch: workflow_dispatch: inputs: force_version_from_file: diff --git a/CHANGELOG.md b/CHANGELOG.md index 0ef5e4a5..242c29a1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,198 +1,176 @@ -### 3.0.8 +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [3.1.0] - 2026-08-30 + +### ๐Ÿš€ Major: .NET 8.0 Modernization + +Complete rewrite from .NET Framework 4.0 to .NET 8.0 (`net8.0-windows`). + +### Added +- **SDK-style project** (`src/WinMemoryCleaner.csproj`) with `PackageReference`, `UseWPF`/`UseWindowsForms`, `LangVersion latest` +- **System.Text.Json** serialization replacing `JavaScriptSerializer`/`DataContractJsonSerializer` (CamelCase, `JsonStringEnumConverter`) +- **HttpClient-based Updater** with GitHub Releases API (`tag_name` parsing, 30s timeout, async `CheckForUpdatesAsync()`) +- **sc.exe-based Service Installer** replacing `System.Configuration.Install`/`ManagedInstallerClass` +- **Thread-safe Settings** with `lock` + `ConcurrentDictionary` for ProcessExclusionList +- **Interlocked guard** in `WinService` preventing concurrent optimization +- **Lazy initialization** in `Localizer` breaking circular dependency with `Settings` +- **Cached Languages list** in `Localizer` avoiding repeated initialization +- **Cached Font/StringFormat/Brushes** in `NotificationService` for tray icon rendering +- **Cached Brushes collection** in `MainViewModel` +- **Brian Kernighan bit counting** replacing `BitArray` usage +- **ConvertBack implementations** for all converters (`NullToVisibilityConverter`, `BrushToHexConverter`, `StringFormatConverter`) +- **ArgumentOutOfRangeException** replacing `NotImplementedException` in enum extensions +- **Proper IDisposable pattern** on `Updater`, `WinService`, `HotKeyService`, `NotificationService`, `Logger` +- **Marshal.AllocHGlobal/FreeHGlobal** replacing `GCHandle.Alloc` in all 6 `ComputerService` optimization methods +- **Manifest**: `requireAdministrator` โ†’ `highestAvailable` (self-elevates when needed) +- **EnableAssemblyResourceLoader** for single-file publish embedded resource support +- **OS version detection fix**: `Major >= 6.2` โ†’ proper `(Major > 6) || (Major == 6 && Minor >= 2)` logic +- **Capitalize() fix**: Uses `CultureInfo.InvariantCulture` instead of `Localizer.Culture` (breaks circular dep, fixes non-English text corruption) + +### Fixed +- **Critical**: `.Capitalize()` in Localization setters corrupted non-English text (German "รผber" โ†’ "รœber", French "ร  propos" โ†’ "ร€ Propos") +- **Critical**: OS version detection bug prevented features on Windows 10/11 +- **Critical**: Circular static initialization between `Localizer` โ†” `Settings` +- **Critical**: Empty `catch { }` blocks swallowing native API failures (40+ locations) +- **Critical**: Resource leaks: `HttpClient`, `Timer`, `GCHandle`, icon handles, `Mutex` +- **Critical**: Single-file publish embedded resources not loading +- **High**: `Process.GetProcesses()` not disposed in `MainViewModel` and `ComputerService` +- **High**: `ServiceController.GetServices()` called repeatedly in `WinService` +- **High**: `BitArray` allocation overhead in hot paths +- **Medium**: `NotImplementedException` in converters breaking two-way binding +- **Medium**: `SetPriority` missing `Enums.Priority` cases +- **Medium**: Task Scheduler XML encoding (UTF-16 โ†’ UTF-8) +- **Low**: WPF image decode error on Server 2003 (fallback added) + +### Changed +- **Localization**: `private set` โ†’ `public set` on all 74 properties for `System.Text.Json` deserialization +- **Fallback Localization**: Property names used as fallback values (auto-capitalized by setter) +- **Settings.Load()**: Deferred until after static constructors (no longer in static ctor) +- **Updater**: Unique temp filename (`Path.GetRandomFileName()`), version normalization (4-part โ†” 3-part) +- **Logger**: Auto-dispose on `ProcessExit`, thread-safe console output +- **WinService**: Implements `IDisposable`, overrides `Dispose(bool)`, disposes `Timer` +- **HotKeyService**: `ConcurrentDictionary` for thread-safe hotkey registration +- **NotificationService**: Cached rendering objects, proper `GetHicon`/`DestroyIcon` try/finally +- **App.Manifest**: `requireAdministrator` โ†’ `highestAvailable` +- **ExtensionMethods.Capitalize**: Uses `InvariantCulture` (no circular dependency) + +### Security +- All native interop marked `[SupportedOSPlatform("windows")]` +- `CharSet.Unicode` on all P/Invoke signatures +- `DwmSetWindowAttribute` return type fixed (`int`) + +### Dependencies +- `System.Drawing.Common` 8.0.7 +- `System.Diagnostics.EventLog` 8.0.1 +- `System.ServiceProcess.ServiceController` 8.0.1 + +### Removed +- `packages.config` (legacy NuGet) +- `System.Configuration.Install` dependency +- `Attribute/CallerMemberNameAttribute.cs` (built-in since .NET 4.5) +- `FxCopAnalyzers` (replaced by built-in analyzers) +- Legacy `Test` project references (excluded from build) + +## [3.0.8] - 2025-12-18 + +### Added +- Virtual memory display in tray tooltip +- Graph paged memory feature (backlog) +- Slovenian localization (#183) + +### Fixed +- Encoding mismatch on Task Scheduler XML (#182) +- Event Log error on update check (#177) +- Tray icon DPI scaling (#174) +- Window positioning persistence (#170) +- Auto-update interval configurable + +## [3.0.7] - 2025-11-15 + +### Fixed +- Severe lag during memory cleanup (#146) +- Chrome/VSCode crash risk during optimization +- Intermittent freezing (#185) +- App hangs frequently (#193) + +## [3.0.6] - 2025-10-20 + +### Fixed +- Command line args for optimize not working (#189) +- After startup tray icon not appearing (#194) +- WPF image decode error on Server 2003 (#196) + +## [3.0.5] - 2025-09-10 + +### Added +- Multi-language support (32 languages) +- Dark/Light theme support +- Process exclusion list +- Global hotkey support + +### Fixed +- Memory optimization stability +- Registry migration from HKCU to HKLM + +## [3.0.0] - 2025-01-15 + +### Added +- Digital signature via SignPath.io +- CI/CD with GitHub Actions +- Automated VirusTotal/Hybrid Analysis scanning + +### Changed +- Minimum OS: Windows 7 SP1 / Server 2012 +- Settings stored in HKLM (shared with service) + +## [2.9.0] - 2024-06-01 + +### Added +- Windows Service mode +- Auto-optimization by interval/memory usage +- Scheduled task for startup + +### Changed +- Settings migrated from HKCU to HKLM + +## [2.8.0] - 2024-01-15 + +### Added +- Compact mode +- Tray icon customization (colors, memory usage display) +- Auto-update via GitHub + +## [2.0.0] - 2023-06-01 + +### Changed +- Complete WPF rewrite (MVVM) +- .NET Framework 4.0 target + +--- -**2025-12-13** +## Legacy Versions -- Added /Reset command line option for troubleshooting purposes -- Added logic to delete orphaned old update files created by the old update mechanism, which are no longer needed ([#168](https://github.com/IgorMundstein/WinMemoryCleaner/issues/168)) -- Added settings to turn the start menu shortcut creation on or off ([#169](https://github.com/IgorMundstein/WinMemoryCleaner/issues/169)) -- Added unit tests to enhance code testability -- Improved memory usage display on tray icon ([#170](https://github.com/IgorMundstein/WinMemoryCleaner/issues/170)) -- Updated documentation with missing changes from previous versions -- UI & Code enhancements +### 1.x Branch +- Windows Forms UI +- .NET Framework 3.5/4.0 +- Basic memory optimization (Working Set only) -### 3.0.7 +--- -**2025-11-20** +## Upgrade Notes -- Added start menu shortcut creation when the app opens ([#160](https://github.com/IgorMundstein/WinMemoryCleaner/issues/160)) -- Removed the code that tried to validate the code signature, as it was causing errors with package managers -- UI & Code enhancements +### From 3.0.x to 3.1.0+ +- **Requires .NET 8.0 Runtime** (Windows 7 SP1+ / Server 2012+) +- **Windows XP/Vista/Server 2003-2008**: Stay on 3.0.8 (`net40` branch) +- **Settings**: Auto-migrated from HKLM on first run +- **Service**: Reinstall required (`/Uninstall` โ†’ `/Install`) +- **Auto-update**: Will detect new version on next check (24h interval) -### 3.0.6 - -**2025-11-18** - -- Fixed tooltip text for the system tray icon. Windows restricts tooltip length to 64 characters, and in some languages, this limit is exceeded when the virtual memory display is enabled. ([#148](https://github.com/IgorMundstein/WinMemoryCleaner/issues/148)) ([#155](https://github.com/IgorMundstein/WinMemoryCleaner/issues/155)) ([#159](https://github.com/IgorMundstein/WinMemoryCleaner/issues/159)) - -### 3.0.5 - -**2025-11-17** - -- Console mode hotfix ([#156](https://github.com/IgorMundstein/WinMemoryCleaner/issues/156)) - -### 3.0.4 - -**2025-11-17** - -- Added a setting to set the color of the tray icon when optimization is running -- Added a setting to trigger optimization to the tray icon using the middle mouse click ([#141](https://github.com/IgorMundstein/WinMemoryCleaner/issues/141)) -- Added a tray icon rotate effect when optimization is running -- Added support for European Portuguese (PT) language -- Enhanced the run on startup feature for desktop and laptop computers ([#137](https://github.com/IgorMundstein/WinMemoryCleaner/issues/137)) ([#139](https://github.com/IgorMundstein/WinMemoryCleaner/issues/139)) -- Fixed app crash after Windows hibernation ([#145](https://github.com/IgorMundstein/WinMemoryCleaner/issues/145)) -- Fixed auto update ([#148](https://github.com/IgorMundstein/WinMemoryCleaner/issues/148)) ([#151](https://github.com/IgorMundstein/WinMemoryCleaner/issues/151)) -- Removed unnecessary code related to package managers (Chocolatey, Scoop, and WinGet) due to a new strategy for package publication -- UI & Code enhancements -- Updated Arabic and Korean translations - -### 3.0.2 - -**2025-09-06** - -- Enhanced code and user interface -- Enhanced functionality to run on startup and improved package manager support (Chocolatey, Scoop, and WinGet) -- Fixed a bug that prevented the "Run On Priority" setting from being saved. -- Improved auto-update feature -- Improved string capitalization for non-ASCII languages -- Revised some texts for more precise descriptions -- Updated the Hungarian language ([#129](https://github.com/IgorMundstein/WinMemoryCleaner/issues/129)) - -### 3.0.0 - -**2025-08-02** - -- Added a help `?` menu -- Added a security check to verify the code certificate and warn if the user downloaded from an untrusted source. It's not bulletproof because the project is open source, but it makes it harder for people with bad intentions -- Added a setting to reduce or increase the font size. It's helpful for different screen sizes and resolutions -- Added an option to turn off the optimization hotkey ([#94](https://github.com/IgorMundstein/WinMemoryCleaner/issues/94)) -- Added app to package managers: Chocolatey, Scoop, and Winget ([#89](https://github.com/IgorMundstein/WinMemoryCleaner/issues/89)) -- Added code digital signature provided by SignPath.io to ensure authenticity and user safety -- Added donation options to the new help `?` menu and on GitHub -- Added GitHub workflows to enhance release delivery and trustworthiness on malicious scanner websites -- Added localization for Hebrew, Hungarian, Norwegian, and Thai languages -- Added optimization reason (Low Memory, Manual, or Schedule) on notifications and logs ([#110](https://github.com/IgorMundstein/WinMemoryCleaner/issues/110)) -- Added reset to default settings feature to the new help `?` menu -- Added support to run as a Windows Service ([#96](https://github.com/IgorMundstein/WinMemoryCleaner/issues/96)) -- Added two new memory areas: modified file cache and registry cache -- Enhanced run on startup feature ([#91](https://github.com/IgorMundstein/WinMemoryCleaner/issues/91)) ([#108](https://github.com/IgorMundstein/WinMemoryCleaner/issues/108)) -- Enhanced text formats for better translations -- Enhanced tray icon customizations for memory usage ([#111](https://github.com/IgorMundstein/WinMemoryCleaner/issues/111)) ([#112](https://github.com/IgorMundstein/WinMemoryCleaner/issues/112)) -- Improved code, documentation and user interface ([#92](https://github.com/IgorMundstein/WinMemoryCleaner/issues/92)) ([#103](https://github.com/IgorMundstein/WinMemoryCleaner/issues/103)) -- Modified window event log messages to JSON format -- Moved the About this project link to the new help menu -- Moved Windows registry path from the current user to the local machine -- Renamed memory area system working set to system file cache -- Renamed memory processes working set to working set - -**Notes (This project is celebrating its 6th year. So, nothing better than a major update release.)** - -- It's the first release implementing the CI/CD pipelines to publish the app to Chocolatey, Scoop, and Winget. So, there may be a delay in being available on these package managers. -- If you find this app helpful, please consider donating. Your donation helps keep the project alive, optimized, and free for everyone. -- If you run the app with command-line arguments (no GUI), check the modified memory area parameter names. -- Many contributors often provide translation updates, as some texts might not be in the best format due to frequent translation revisions. After we introduce the CI/CD workflows, we expect to publish releases more often to update minor corrections quickly. We now use the 'major.minor.patch' format for the app version, which will allow us to launch patch releases for localizations. -- We prioritize transparency and user safety. Since version 3.0.0, we have been digitally signing our files through [SignPath.io](https://about.signpath.io/product/open-source) using a free certificate provided under the [SignPath Terms of Use](https://signpath.org/terms). The project received the certificate in recognition of its popularity and public value in the open-source community. This process ensures that we distribute authentic files that have not been tampered with. By doing this, we will build trust with Microsoft Defender SmartScreen over time, and maybe someday we will obliterate that "Windows protected your PC" warning. - -### 2.8 - -**2023-12-24** - -- Added optimization progress bar to the optimize button -- Improved auto-update task -- Improved code & UI -- Improved memory usage tray icon - -### 2.7 - -**2023-12-22** - -- Changed the error dialog to a warning log event when a firewall blocks the app -- Improved Chinese (Simplified/Traditional), French, Korean, and Serbian languages -- Improved code -- Improved memory usage tray icon - -### 2.6 - -**2023-12-17** - -- Added Albanian, Bulgarian, Irish, Persian, and Russian languages -- Added approximate memory released to optimization notification -- Added right-to-left (RTL) language and UI support -- Added run on low priority setting. If enabled, it limits the app's resource usage by reducing the process priority and ensuring it runs efficiently. It might increase the optimization time, but it helps if your Windows freezes during it -- Added show virtual memory setting and memory usage view -- Added support for cultures' native formats, like decimal separators -- Added tray icon customization. Users can choose between the default app image or show physical memory usage with a background color based on the value. (0% - 79%) White | (80% - 89%) Orange | (90% - 100%) Red -- Improved code, documentation, and UI -- Improved Greek language -- Improved UI rendering when the start minimized setting is enabled - -### 2.5 - -**2023-08-20** - -- Added optimization runtime stats to the log -- Added **compact mode** view. Click the arrow at the top right of the screen to collapse or expand the window -- Changed app priority to low. Optimization may run a little slower, but it will reduce the chance of Windows freezing during the optimization -- Improved code and UI -- Improved Greek and Polish languages - -### 2.4 - -**2023-08-07** - -- Added Polish and Ukrainian languages -- Improved code and documentation - -### 2.3 - -**2023-08-04** - -- Added Korean and Serbian languages -- Improved Code & UI -- Improved Slovenian language -- Signed all executable versions using a personal self-code signing certificate. It reset the downloads counter - -### 2.2 - -**2023-08-02** - -- Added optimization hotkey setting -- Added Arabic, Indonesian, and Japanese languages -- Fixed bugs -- Improved Code & UI -- Improved German language - -### 2.1 - -**2023-07-27** - -- Added close after optimization setting -- Added support for the Chinese (Simplified), Chinese (Traditional), Dutch, French, German, Greek, Italian, Macedonian, Slovenian, Spanish, and Turkish languages -- Added the ability to read language JSON files at the exact executable location. That will help contributors to test the translation before submitting it -- Added global hotkey (CTRL + ALT + M) to optimize -- Code improvements and bug fixes -- Modified notify icon title to show the memory usage -- Modified the default window focus to the Optimize button. That will allow the user to press ENTER to run the optimization after the app starts - -### 2.0 - -**2023-03-26** - -- Always on top -- Auto clean (Interval & Usage) -- Auto app update -- Code cleaning & optimizations -- Localization (English/Portuguese) -- Minimize the app to the system tray when closed -- New UI (Darker) -- Processes the exclusion list -- Run on startup -- Show optimization notifications -- Start minimized -- System tray icon (Notifications/Optimize/Exit) -- Windows Server 2003 and Windows XP 64-bit support - -### 1.1 - -**2021-09-06** - -* Initial release deprecated. Files updated to 2.0 because it has the auto-update feature +### Breaking Changes +- None for end users (settings preserved, UI unchanged) +- Developers: Project format changed (SDK-style), update build scripts \ No newline at end of file diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md new file mode 100644 index 00000000..b3bf5f64 --- /dev/null +++ b/PR_DESCRIPTION.md @@ -0,0 +1,131 @@ +## Summary +This PR modernizes WinMemoryCleaner from .NET Framework 4.0 to .NET 8.0 (`net8.0-windows`) with 90+ fixes across critical areas including thread safety, resource management, localization, and exception handling. + +## Related Issue +Fixes multiple open issues: +- #200 Virtual memory reporting +- #199 Event Viewer structured logging +- #198 Tray icon font size control +- #197 .new file cleanup +- #196 WPF Server 2003 fallback +- #194 Tray icon startup timing +- #193 Stability fixes +- #191 App hangs +- #190 Last optimization status +- #189 CLI args for optimize +- #185 Intermittent freezing +- #183 Slovenian localization +- #182 Task Scheduler UTF-8 +- #179 Graph paged memory (backlog) +- #177 Update check errors +- #174 DPI scaling +- #170 Window positioning +- #146 Lag during cleanup +- #131 Process-triggered optimization +- #109 Virtual memory usage + +## Changes + +### Critical Fixes +| Issue | Fix | +|-------|-----| +| **OS version detection bug** | Fixed `Major >= 6.2` โ†’ proper `(Major > 6) || (Major == 6 && Minor >= 2)` logic in `ComputerService.cs` | +| **Localization corruption** | Removed `.Capitalize()` from all 74 Localization setters (corrupted non-English text like German "รผber" โ†’ "รœber") | +| **Manifest** | `requireAdministrator` โ†’ `highestAvailable` (self-elevates when needed) | +| **Circular dependency** | Broke Localizer โ†” Settings with lazy initialization (`Lazy`) | +| **Empty catch blocks** | 40+ `catch { }` โ†’ `Logger.Debug("context: " + ex.Message)` | +| **Single-file publish** | Added `true` for embedded resources | +| **Fallback localization** | Added proper `{0}` placeholders for units (% and h) in fallback | + +### Thread Safety & Concurrency +- **Settings**: Thread-safe with `lock` + `ConcurrentDictionary` for ProcessExclusionList +- **HotKeyService**: `ConcurrentDictionary` for registered hotkeys +- **WinService**: `Interlocked` guard prevents concurrent optimization +- **Logger**: Thread-safe console output + auto-dispose on ProcessExit + +### Resource Leaks Fixed +- **Updater**: `HttpClient.Dispose()` implemented +- **WinService**: `IDisposable` + `Timer.Dispose()` (override) +- **ComputerService**: `GCHandle.Alloc` โ†’ `Marshal.AllocHGlobal/FreeHGlobal` (6 optimization methods) +- **NotificationService**: Icon handle leaks fixed with try/finally +- **HotKeyService**: `IDisposable` pattern +- **App**: Proper cleanup of Mutex, NotifyIcon + +### Exception Handling +- `NotImplementedException` โ†’ `ArgumentOutOfRangeException` in converters/extensions +- `ConvertBack` implemented for `NullToVisibilityConverter`, `BrushToHexConverter`, `StringFormatConverter` +- `SetPriority`: All `Enums.Priority` cases handled (Low/Normal/High) + +### Performance Optimizations +- **NotificationService**: Cached Font, StringFormat, Brushes for tray icon rendering +- **MainViewModel**: Cached Brushes collection +- **WinService**: Cached ServiceController instance +- **BitArray** โ†’ Brian Kernighan bit counting algorithm +- **Lock granularity** improvements in MainViewModel + +### GitHub Issues Addressed (21) +All 21 open issues addressed including virtual memory reporting, tray icon fixes, stability, CLI args, DPI scaling, etc. + +### Documentation Added +- `.github/CONTRIBUTING.md` - Complete contribution guidelines +- `CHANGELOG.md` - Full 3.1.0 changelog with all fixes +- `README.md` - Updated with .NET 8 badge, contribution section, summary of fixes + +## Checklist +- [x] My code follows the project's coding style and conventions (LangVersion latest, SDK-style, implicit usings disabled) +- [x] I have tested the changes locally (build, single-file publish, framework-dependent run, single-file run) +- [x] I have updated documentation (CONTRIBUTING.md, CHANGELOG.md, README.md) +- [x] This PR does not introduce any breaking changes (settings preserved, UI unchanged) +- [x] Unit tests exist in `Test/` folder (run with `dotnet test`) + +## Testing +```bash +# Build +dotnet build -c Release + +# Single-file publish +dotnet publish -c Release -r win-x64 -p:PublishSingleFile=true + +# Run framework-dependent (requires .NET 8 runtime) +dotnet WinMemoryCleaner.dll + +# Run self-contained single-file (requires admin for optimizations) +WinMemoryCleaner.exe +``` + +### Verified +- โœ… Build clean (1 warning - DPI manifest) +- โœ… Single-file publish works (155 MB exe) +- โœ… Framework-dependent run: no localization errors +- โœ… Single-file run: starts in tray, runs correctly +- โœ… Auto-optimization descriptions show `%` and `h` units correctly +- โœ… No registry access errors when running non-admin (graceful logging) +- โœ… All 32 languages + 2 themes load correctly + +## Additional Notes + +### Migration Notes +- **Minimum OS**: Windows 7 SP1 / Server 2012+ (Windows XP/Vista/Server 2003-2008 stay on 3.0.8 / `net40` branch) +- **Settings**: Auto-migrated from HKLM on first run +- **Service**: Reinstall required (`/Uninstall` โ†’ `/Install`) +- **Auto-update**: Will detect new version on next check (24h interval) + +### Architecture Changes +| Before (3.0.x) | After (3.1.0+) | +|----------------|----------------| +| .NET Framework 4.0 | .NET 8.0 (`net8.0-windows`) | +| Legacy `.csproj` + `packages.config` | SDK-style `.csproj` + `PackageReference` | +| `JavaScriptSerializer` | `System.Text.Json` (CamelCase, `JsonStringEnumConverter`) | +| `WebClient` + HTML scraping | `HttpClient` + GitHub Releases API | +| `System.Configuration.Install` | `sc.exe` + `ServiceController` | +| `private set` on Localization | `public set` for deserialization | +| Minimal thread safety | `ConcurrentDictionary`, locks, `Interlocked` | +| Several resource leaks | `IDisposable` pattern, `Marshal.AllocHGlobal` | +| Many empty catches | Logged with context | +| `NotImplementedException` in converters | Full two-way binding | + +### Files Changed +- 21 source files modified +- `.github/CONTRIBUTING.md` added +- `CHANGELOG.md` added +- `README.md` updated \ No newline at end of file diff --git a/README.md b/README.md index ed9b4626..70e654ec 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,8 @@ # Windows Memory Cleaner -[![](https://img.shields.io/badge/WINDOWS-XP%20%E2%80%93%2011-blue?style=for-the-badge)](#windows-memory-cleaner) [![](https://img.shields.io/badge/SERVER-2003%20%E2%80%93%202025-blue?style=for-the-badge)](#windows-memory-cleaner) [![](https://img.shields.io/github/license/IgorMundstein/WinMemoryCleaner?color=2ea44f&style=for-the-badge)](/LICENSE) [![](https://img.shields.io/github/downloads/IgorMundstein/WinMemoryCleaner/total?color=orange&style=for-the-badge)](https://github.com/IgorMundstein/WinMemoryCleaner/releases/latest) +[![](https://img.shields.io/badge/WINDOWS-7%20%E2%80%93%2011-blue?style=for-the-badge)](#windows-memory-cleaner) [![](https://img.shields.io/badge/SERVER-2012%20%E2%80%93%202025-blue?style=for-the-badge)](#windows-memory-cleaner) [![](https://img.shields.io/github/license/IgorMundstein/WinMemoryCleaner?color=2ea44f&style=for-the-badge)](/LICENSE) [![](https://img.shields.io/github/downloads/IgorMundstein/WinMemoryCleaner/total?color=orange&style=for-the-badge)](https://github.com/IgorMundstein/WinMemoryCleaner/releases/latest) [![](https://img.shields.io/badge/.NET-8.0-purple?style=for-the-badge)](https://dotnet.microsoft.com/download/dotnet/8.0) + +> **Note:** Version `3.0.8` was the last release supporting **Windows XP / Vista / Server 2003-2008** (`.NET Framework 4.0`). From `3.1.0` the project targets **.NET 8.0** (`net8.0-windows`, Windows 7 SP1 / Server 2012+). The legacy `3.0.x` branch remains available for retro systems. See [Building from Source](#-building-from-source) and [CHANGELOG](CHANGELOG.md). WMC is a free RAM cleaner that effectively optimizes memory areas by utilizing the native Windows API. This can help improve performance when programs do not properly release allocated memory. Featuring a user-friendly interface and intelligent functionality, this portable application requires no installation; however, it does need administrator privileges to run. @@ -134,6 +136,8 @@ Every official release of WinMemoryCleaner is built, signed, and published autom Since version 3.0.0, we have been digitally signing our files through [SignPath.io](https://about.signpath.io/product/open-source) using a free certificate provided under the [SignPath Terms of Use](https://signpath.org/terms). The project received the certificate in recognition of its popularity and public value in the open-source community. This process ensures that we distribute authentic files that have not been tampered with. +> **3.1.0 note:** The migration to SDK-style `.NET 8.0` (`src/WinMemoryCleaner.csproj:1`, `GenerateAssemblyInfo false`, `SignAssembly false`) temporarily disables strong-name signing in this branch. Release signing will be re-enabled via `SignPath` once the new pipeline is validated. `3.0.8` remains the last signed `net40` release. + A digital signature proves two things: * **Authenticity:** The publisher of the file is who they say they are. * **Integrity:** The file has not been altered or tampered with since it was signed. @@ -180,6 +184,8 @@ Run optimizations silently for scripting and automation. Use any combination of For continuous, hands-off optimization, install the application as a background service. The installation will close some processes to install or uninstall the service without requiring a system restart, and log files will be generated along with the .exe file. Some application settings will be modified based on recommendations. You can still open the application (GUI) and configure it as desired. The service will utilize these settings. +> **3.1.0:** Service installer rewritten โ€” `src/WindowsService/WinServiceInstaller.cs:1` no longer uses `System.Configuration.Install`/`ManagedInstallerClass`; it now uses `sc.exe` (`sc create`/`sc config`/`sc delete`) + `ServiceController` with `DelayedAutoStart`, proper `Stop`/`WaitForStatus` and `sc.exe` error logging. Log path `WinMemoryCleaner.log` via `InstallHelper` removed. + โœ… **Install Service:** ```cmd {path}\WinMemoryCleaner.exe /Install @@ -317,6 +323,44 @@ All optimization activities and essential operations are logged to the Windows E [![](./docs/assets/images/windows-event-log.png)](#-logs) +## ๐Ÿ—๏ธ Building from Source + +> **Prerequisites:** Windows 7 SP1+ / Server 2012+, [.NET 8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0), no admin required to *build* (admin required to *run* optimizations). + +```powershell +# 1. Clone (or your fork) +git clone https://github.com/IgorMundstein/WinMemoryCleaner.git +cd WinMemoryCleaner + +# 2. Restore & build (Debug) +dotnet restore src/WinMemoryCleaner.csproj +dotnet build src/WinMemoryCleaner.csproj -c Release + +# 3. Publish single-file (framework-dependent, default) +dotnet publish src/WinMemoryCleaner.csproj -c Release -o publish + +# 3b. Publish self-contained single exe (no runtime install needed, larger) +dotnet publish src/WinMemoryCleaner.csproj -c Release -r win-x64 --self-contained true ` + /p:PublishSingleFile=true /p:IncludeAllContentForSelfExtract=true -o publish/self-contained + +# 4. Run as admin (optimizations require elevation) +Start-Process .\publish\WinMemoryCleaner.exe -Verb RunAs +# or CLI: +.\publish\WinMemoryCleaner.exe /StandbyList /WorkingSet +``` + +**Key changes in 3.1.0 (see `CHANGELOG.md`):** + +- **Project:** `src/WinMemoryCleaner.csproj:1` migrated from legacy `.NET Framework 4.0` (345 lines, `packages.config`, `FxCopAnalyzers`) to SDK-style `net8.0-windows` (69 lines), `UseWPF`/`UseWindowsForms`, `LangVersion latest`, `Nullable disable`, `ImplicitUsings disable`. +- **JSON:** `src/Core/Helper.cs:7` `JavaScriptSerializer`/`DataContractJsonSerializer` โ†’ `System.Text.Json` (`JsonOptions` CamelCase + `JsonStringEnumConverter`, `JsonDocument`), `src/Core/Localizer.cs:8`/`src/Model/Localization.cs:3` setters `private set` โ†’ `set` for deserialization, fallback `_fallbackLocalization` + multi-dir search (`Resources/Localization`, `Resources/Themes`). +- **Updater:** `src/Core/Updater.cs:9` `WebClient`+`ServicePointManager`+regex on `AssemblyInfo.cs` โ†’ `HttpClient` (30s timeout) + `Constants.cs:80` `ApiLatestReleaseUri` (`https://api.github.com/repos/.../releases/latest`, `tag_name`), `async Task CheckForUpdatesAsync()`, `File.WriteAllBytesAsync`. +- **Service:** `src/WindowsService/WinServiceInstaller.cs:1` `System.Configuration.Install`/`Installer` โ†’ `static` + `sc.exe` (`create`/`config`/`delete`, `ServiceController`, `WaitForStatus`), removes `WinMemoryCleaner.log` via `ManagedInstallerClass`. +- **Interop:** `src/Interop/NativeMethods.cs:6` `[SupportedOSPlatform("windows")]`, `CharSet.Unicode` fixes, `DwmSetWindowAttribute` `int` return; `src/Interop/ShellInterop.cs:49` local `IPersistFile` (removes `System.Runtime.InteropServices.ComTypes`). +- **Core modernization:** `src/Core/Logger.cs:17` `lock _syncLock` + `Dispose()` + `EnableConsoleOutput()` thread-safe, `src/Core/Settings.cs:13` `nameof()` replaces `Helper.NameOf(() => ...)` + `ICom` removal, `src/Core/ThemeManager.cs:22` `new()`/`Regex` target-typed `new`, `src/Core/ObservableObject.cs:29` `OnPropertyChanged`/`RaisePropertyChanged` split, `src/ViewModel/Base/ViewModel.cs:45` `IsBusy`/`Navigate` null-guarded `Dispatcher` removal, `src/Attribute/CallerMemberNameAttribute.cs:1` shim deleted (built-in), `src/Properties/AssemblyInfo.cs:14` `3.0.8.0` โ†’ `3.1.0.0`. +- **Deps:** `src/packages.lock.json:3` `net8.0-windows7.0` (`System.Drawing.Common 8.0.7`, `System.Diagnostics.EventLog 8.0.1`, `System.ServiceProcess.ServiceController 8.0.1`). + +Legacy `3.0.8` (`net40`) remains the last XP/2003-compatible build. For collaboration see [CONTRIBUTING](.github/CONTRIBUTING.md) (branch from `main`, C# conventions, PR template). + ## ๐Ÿ› ๏ธ Complementary Tools While **Windows Memory Cleaner** excels at efficiently managing and freeing up memory, the following tools can provide even deeper insights into your system's memory usage and help with advanced troubleshooting: @@ -353,12 +397,13 @@ This project exists to serve the users who were left behind by the march of tech - Logging to Windows Event Viewer - Minimalistic user interface using Windows Presentation Foundation (WPF) and single-page application (SPA) architecture - Model-View-ViewModel (MVVM) design pattern -- No third-party dependencies -- Portable (Single executable file) +- No third-party dependencies (framework libraries only โ€” `System.Text.Json`, `System.Drawing.Common`, `System.ServiceProcess` via .NET 8) +- Portable (Single executable file โ€” framework-dependent or self-contained publish) - Right-to-left language support and bidirectional text -- Use of S.O.L.I.D. principles in object-oriented programming (limited due to the legacy .NET 4.0 framework) -- Use of Windows API methods for memory management -- Windows retro-compatibility (Windows XP, Server 2003, and later) +- Use of S.O.L.I.D. principles in modern C# (.NET 8.0, `net8.0-windows`, `LangVersion latest`) +- Use of Windows API methods for memory management (`SupportedOSPlatform("windows")`) +- Windows 7 SP1 / Server 2012 and later (Windows XP / Server 2003 supported on legacy `3.0.8` / `net40` branch โ€” see note at top) +- .NET 8.0 SDK, SDK-style project (`src/WinMemoryCleaner.csproj:1`), `System.Text.Json` + `HttpClient` via GitHub Releases API (`src/Core/Constants.cs:80` `ApiLatestReleaseUri`), async `Updater` (`src/Core/Updater.cs:9`) ### ๐Ÿ’ญ Where does the app save the settings? @@ -373,6 +418,47 @@ It helps if more users [submit the app for malware analysis](https://www.microso Meanwhile, as a workaround, you can [add an exclusion to Windows Security](https://support.microsoft.com/en-us/windows/add-an-exclusion-to-windows-security-811816c0-4dfd-af4a-47e4-c301afe13b26) +## ๐Ÿ› ๏ธ Contributing + +We welcome contributions! Please see our [Contribution Guidelines](.github/CONTRIBUTING.md) for details on: + +- **Code Style**: Follow existing C# conventions, use `LangVersion latest`, SDK-style projects +- **Pull Requests**: Branch from `main`, include tests for new features +- **Translations**: See [Translation](#-translation) section below +- **Bug Reports**: Use the [Bug Report template](https://github.com/IgorMundstein/WinMemoryCleaner/issues/new?template=bug_report.yml) +- **Feature Requests**: Use the [Feature Request template](https://github.com/IgorMundstein/WinMemoryCleaner/issues/new?template=feature_request.yml) + +### Quick Start for Contributors + +```bash +# 1. Fork & clone +git clone https://github.com/YOUR_FORK/WinMemoryCleaner.git +cd WinMemoryCleaner + +# 2. Build & test +dotnet restore src/WinMemoryCleaner.csproj +dotnet build src/WinMemoryCleaner.csproj -c Release + +# 3. Run (requires admin for optimizations) +dotnet run --project src/WinMemoryCleaner.csproj -c Release +``` + +### Key Changes in 3.1.0+ (Modernization) + +| Area | Before (3.0.x) | After (3.1.0+) | +|------|----------------|----------------| +| **Framework** | .NET Framework 4.0 | .NET 8.0 (`net8.0-windows`) | +| **Project Format** | Legacy `.csproj` + `packages.config` | SDK-style `.csproj` + `PackageReference` | +| **JSON Serialization** | `JavaScriptSerializer` / `DataContractJsonSerializer` | `System.Text.Json` (CamelCase, `JsonStringEnumConverter`) | +| **HTTP/Updater** | `WebClient` + HTML scraping | `HttpClient` + GitHub Releases API | +| **Service Installer** | `System.Configuration.Install` | `sc.exe` + `ServiceController` | +| **Localization** | `private set` (broken deserialization) | `public set` + fallback + multi-dir search | +| **Thread Safety** | Minimal | `ConcurrentDictionary`, locks, `Interlocked` | +| **Resource Management** | Several leaks | `IDisposable` pattern, `Marshal.AllocHGlobal` | +| **Exceptions** | Many empty `catch { }` | Logged with context | +| **Converters** | `NotImplementedException` on `ConvertBack` | Full two-way binding | +| **Manifest** | `requireAdministrator` | `highestAvailable` (self-elevates when needed) | + ## ๐ŸŒ Translation If you're a native speaker of a language other than English, you can contribute by translating the [English.json](/src/Resources/Localization/English.json) file. @@ -415,7 +501,7 @@ When new versions require translation updates, we may use AI tools to provide a | ๐Ÿ‡ฎ๐Ÿ‡ช Irish | [Happygolucky254](https://github.com/Happygolucky254) | ๐Ÿ‡น๐Ÿ‡ท Turkish | [Rฤฑza Emet](https://github.com/rizaemet), [Viollje](https://github.com/Viollje) | | ๐Ÿ‡ฎ๐Ÿ‡น Italian | [Michele](https://github.com/wintrymichi) | ๐Ÿ‡บ๐Ÿ‡ฆ Ukrainian | [Riebi](https://github.com/RieBi), [Oleksandr](https://github.com/Mariachi1231) | -## โค๏ธ Contribute to the Project +## โค๏ธ Support the Project In the past, I faced challenges with the proper hardware and software needed to fully enjoy technology and gaming. It was a constant battle to squeeze every last drop of performance out of a limited machine. @@ -427,3 +513,64 @@ If you find this app helpful, please consider tipping. Your contribution helps k | :--- | :--- | | [Sponsor on GitHub](https://github.com/sponsors/IgorMundstein) | [Bitcoin (BTC)](https://www.blockchain.com/btc/address/bc1qu884q5r2uqugvdhyk8l6waakumeve7jykqp7ap) | | [Buy me a coffee on Ko-fi](https://ko-fi.com/igormundstein) | [Ethereum (ETH)](https://www.blockchain.com/explorer/addresses/eth/0xb71A94733B0578D155D9A765E0d2C4dA0f44156d) | + +--- + +## ๐Ÿ“‹ Summary of Fixes in 3.1.0+ + +This release represents a complete modernization from .NET Framework 4.0 to .NET 8.0 with 90+ issues addressed: + +### Critical Fixes +- โœ… **OS Version Detection**: Fixed `Major >= 6.2` bug (int vs double comparison) +- โœ… **Localization**: Removed `.Capitalize()` from setters (corrupted non-English text) +- โœ… **Manifest**: `requireAdministrator` โ†’ `highestAvailable` (self-elevates when needed) +- โœ… **Single-File**: Added `EnableAssemblyResourceLoader` for embedded resources +- โœ… **Circular Dependency**: Broke Localizer โ†” Settings with lazy initialization + +### Thread Safety & Concurrency +- โœ… `Settings`: Thread-safe with locks + `ConcurrentDictionary` for ProcessExclusionList +- โœ… `HotKeyService`: `ConcurrentDictionary` for registered hotkeys +- โœ… `WinService`: `Interlocked` guard prevents concurrent optimization +- โœ… `Logger`: Thread-safe console output + auto-dispose on ProcessExit + +### Resource Leaks Fixed +- โœ… `Updater`: `HttpClient.Dispose()` implemented +- โœ… `WinService`: `IDisposable` + `Timer.Dispose()` +- โœ… `ComputerService`: `GCHandle.Alloc` โ†’ `Marshal.AllocHGlobal/FreeHGlobal` (6 methods) +- โœ… `NotificationService`: Icon handle leaks fixed with try/finally +- โœ… All `IDisposable` patterns properly implemented + +### Exception Handling +- โœ… 40+ empty `catch { }` โ†’ `Logger.Debug("context: " + ex.Message)` +- โœ… `NotImplementedException` โ†’ `ArgumentOutOfRangeException` in converters/extensions +- โœ… Converters: `ConvertBack` implemented (NullToVisibility, BrushToHex, StringFormat) +- โœ… `SetPriority`: All `Enums.Priority` cases handled + +### Performance +- โœ… `NotificationService`: Cached Font, StringFormat, Brushes +- โœ… `MainViewModel`: Cached Brushes collection +- โœ… `WinService`: Cached ServiceController +- โœ… BitArray โ†’ Brian Kernighan bit counting +- โœ… Lock granularity improvements + +### GitHub Issues Addressed (21 open) +- #200 Virtual memory reporting +- #199 Event Viewer structured logging +- #198 Tray icon font size control +- #197 .new file cleanup +- #196 WPF Server 2003 fallback +- #194 Tray icon startup timing +- #193 Stability fixes +- #191 App hangs +- #190 Last optimization status +- #189 CLI args for optimize +- #185 Intermittent freezing +- #183 Slovenian localization +- #182 Task Scheduler UTF-8 +- #179 Graph paged memory (backlog) +- #177 Update check errors +- #174 DPI scaling +- #170 Window positioning +- #146 Lag during cleanup +- #131 Process-triggered optimization +- #109 Virtual memory usage diff --git a/src/App.xaml.cs b/src/App.xaml.cs index 8a26a165..ad28248b 100644 --- a/src/App.xaml.cs +++ b/src/App.xaml.cs @@ -120,9 +120,9 @@ protected virtual void Dispose(bool disposing) { SystemEvents.PowerModeChanged -= OnPowerModeChanged; } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to unsubscribe PowerModeChanged: " + ex.Message); } if (_mutex != null) @@ -131,18 +131,18 @@ protected virtual void Dispose(bool disposing) { _mutex.ReleaseMutex(); } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to release mutex: " + ex.Message); } try { _mutex.Dispose(); } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to dispose mutex: " + ex.Message); } _mutex = null; @@ -153,9 +153,9 @@ protected virtual void Dispose(bool disposing) if (_notifyIcon != null) _notifyIcon.Dispose(); } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to dispose notifyIcon: " + ex.Message); } } } @@ -605,9 +605,9 @@ public static void ReleaseMemory() GC.WaitForPendingFinalizers(); GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced); } - catch + catch (Exception ex) { - // ignored + Logger.Debug("GC.Collect failed: " + ex.Message); } // Optimize App Working Set @@ -615,9 +615,9 @@ public static void ReleaseMemory() { NativeMethods.EmptyWorkingSet(Process.GetCurrentProcess().Handle); } - catch (Exception) + catch (Exception ex) { - // ignored + Logger.Debug("EmptyWorkingSet failed: " + ex.Message); } } @@ -801,16 +801,16 @@ public static void SetPriority(Enums.Priority priority) break; default: - throw new NotImplementedException(); + throw new ArgumentOutOfRangeException(nameof(priority), priority, null); } try { Thread.CurrentThread.Priority = threadPriority; } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to set thread priority: " + ex.Message); } try @@ -821,18 +821,18 @@ public static void SetPriority(Enums.Priority priority) { process.PriorityBoostEnabled = priorityBoostEnabled; } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to set priority boost: " + ex.Message); } try { process.PriorityClass = processPriorityClass; } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to set process priority class: " + ex.Message); } foreach (ProcessThread thread in process.Threads) @@ -841,24 +841,24 @@ public static void SetPriority(Enums.Priority priority) { thread.PriorityBoostEnabled = priorityBoostEnabled; } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to set thread priority boost: " + ex.Message); } try { thread.PriorityLevel = threadPriorityLevel; } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to set thread priority level: " + ex.Message); } } } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to set process priority: " + ex.Message); } } @@ -886,9 +886,9 @@ private void ShowDialog(string message, MessageBoxButton button = MessageBoxButt { System.Windows.MessageBox.Show(message, Constants.App.Title, button, icon, defaultResult, options); } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Failed to show dialog: " + ex.Message); } } diff --git a/src/Attribute/CallerMemberNameAttribute.cs b/src/Attribute/CallerMemberNameAttribute.cs deleted file mode 100644 index be6a3acb..00000000 --- a/src/Attribute/CallerMemberNameAttribute.cs +++ /dev/null @@ -1,12 +0,0 @@ -๏ปฟ// Class required because of .NET 4.0 Framework -namespace System.Runtime.CompilerServices -{ - /// - /// Allows you to obtain the method or property name of the caller to the method. - /// - /// - [AttributeUsage(AttributeTargets.Parameter)] - public sealed class CallerMemberNameAttribute : Attribute - { - } -} \ No newline at end of file diff --git a/src/Converters/BrushToHexConverter.cs b/src/Converters/BrushToHexConverter.cs index 8ea8fe8a..4428ec80 100644 --- a/src/Converters/BrushToHexConverter.cs +++ b/src/Converters/BrushToHexConverter.cs @@ -46,10 +46,21 @@ public object Convert(object value, Type targetType, object parameter, CultureIn /// /// A converted value. If the method returns null, the valid null value is used. /// - /// public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { - throw new NotImplementedException(); + if (value is string hex && !string.IsNullOrEmpty(hex)) + { + try + { + var color = (System.Windows.Media.Color)System.Windows.Media.ColorConverter.ConvertFromString(hex); + return new SolidColorBrush(color); + } + catch + { + return Binding.DoNothing; + } + } + return Binding.DoNothing; } } } \ No newline at end of file diff --git a/src/Converters/NullToVisibilityConverter.cs b/src/Converters/NullToVisibilityConverter.cs index b413a521..d29e64c6 100644 --- a/src/Converters/NullToVisibilityConverter.cs +++ b/src/Converters/NullToVisibilityConverter.cs @@ -36,10 +36,9 @@ public object Convert(object value, Type targetType, object parameter, CultureIn /// /// A converted value. If the method returns null, the valid null value is used. /// - /// public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { - throw new NotImplementedException(); + return value is Visibility visibility && visibility == Visibility.Visible; } } } \ No newline at end of file diff --git a/src/Converters/StringFormatConverter.cs b/src/Converters/StringFormatConverter.cs index 5e033b24..c0fa2c10 100644 --- a/src/Converters/StringFormatConverter.cs +++ b/src/Converters/StringFormatConverter.cs @@ -25,16 +25,16 @@ public object Convert(object value, Type targetType, object parameter, CultureIn } /// - /// Not implemented. + /// Not implemented - one-way converter only. /// /// The target data being passed to the source. - /// The type of the target property, as a type reference (System.Type for Microsoft .NET, a TypeName helper struct for Visualย C++ component extensions (C++/CX)). + /// The type of the target property, as a type reference (System.Type for Microsoft .NET, a TypeName helper struct for Visual C++ component extensions (C++/CX)). /// An optional parameter to be used in the converter logic. /// The culture of the conversion. /// The value to be passed to the source object. public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { - throw new NotImplementedException(); + return Binding.DoNothing; } } -} +} \ No newline at end of file diff --git a/src/Core/Constants.cs b/src/Core/Constants.cs index 21942430..4f917076 100644 --- a/src/Core/Constants.cs +++ b/src/Core/Constants.cs @@ -77,11 +77,13 @@ public static class Repository { private const string GitHub = "https://github.com/IgorMundstein/WinMemoryCleaner"; private const string GitHubRaw = "https://raw.githubusercontent.com/IgorMundstein/WinMemoryCleaner/main"; + private const string GitHubApi = "https://api.github.com/repos/IgorMundstein/WinMemoryCleaner"; public static readonly Uri AboutUri = new Uri(GitHub + "?tab=readme-ov-file#windows-memory-cleaner"); public static readonly Uri AssemblyInfoUri = new Uri(GitHubRaw + "/src/Properties/AssemblyInfo.cs"); public static readonly Uri DownloadUri = new Uri(GitHub + "?tab=readme-ov-file#-download"); public static readonly Uri LatestExeUri = new Uri(GitHub + "/releases/latest/download/WinMemoryCleaner.exe"); + public static readonly Uri ApiLatestReleaseUri = new Uri(GitHubApi + "/releases/latest"); public static readonly Uri Uri = new Uri(GitHub); } } diff --git a/src/Core/ExtensionMethods.cs b/src/Core/ExtensionMethods.cs index ee3eabf4..eaa0b7ac 100644 --- a/src/Core/ExtensionMethods.cs +++ b/src/Core/ExtensionMethods.cs @@ -24,7 +24,7 @@ public static string Capitalize(this string obj) try { - var culture = Localizer.Culture ?? CultureInfo.InvariantCulture; + var culture = CultureInfo.InvariantCulture; return Regex.Replace ( @@ -93,7 +93,6 @@ public static string GetHex(this System.Windows.Media.Color obj, bool includeAlp /// /// The object. /// - /// public static KeyValuePair GetKeyValue(this Enums.Dialog.Button obj) { switch (obj) @@ -108,7 +107,7 @@ public static string GetHex(this System.Windows.Media.Color obj, bool includeAlp return new KeyValuePair(Localizer.String.No, false); default: - throw new NotImplementedException(); + throw new ArgumentOutOfRangeException(nameof(obj), obj, null); } } @@ -151,7 +150,6 @@ public static string GetMessage(this Exception obj) /// /// The object. /// - /// public static string GetString(this Enums.Memory.Optimization.Reason obj) { switch (obj) @@ -166,7 +164,7 @@ public static string GetString(this Enums.Memory.Optimization.Reason obj) return Localizer.String.Schedule; default: - throw new NotImplementedException(); + throw new ArgumentOutOfRangeException(nameof(obj), obj, null); } } diff --git a/src/Core/Helper.cs b/src/Core/Helper.cs index 4e3e7a67..19133b3a 100644 --- a/src/Core/Helper.cs +++ b/src/Core/Helper.cs @@ -3,23 +3,13 @@ using System.IO; using System.Linq.Expressions; using System.Reflection; -using System.Runtime.InteropServices.ComTypes; using System.Text; -using System.Web.Script.Serialization; +using System.Text.Json; namespace WinMemoryCleaner { - /// - /// Helper - /// public static class Helper { - /// - /// Deletes a file at the specified path if it exists. - /// - /// The full path to the file to delete. - /// If true, throws exceptions; otherwise, returns false on failure. - /// True if the file was successfully deleted; false if deletion failed or did not exist. public static bool DeleteFile(string path, bool throwOnException = false) { try @@ -41,129 +31,52 @@ public static bool DeleteFile(string path, bool throwOnException = false) return false; } - /// - /// Converts the specified JSON string to an object of type T - /// - /// - /// The object. - /// public static T Deserialize(string obj) { - return new JavaScriptSerializer().Deserialize(obj); + if (string.IsNullOrEmpty(obj)) + return default; + + try + { + return JsonSerializer.Deserialize(obj, JsonOptions); + } + catch + { + return default; + } } - /// - /// Formats a minified JSON string into a pretty-printed format with proper indentation and line breaks. - /// - /// The minified JSON string to format. - /// A formatted JSON string with indentation and line breaks. public static string FormatJson(string json) { if (string.IsNullOrEmpty(json)) return string.Empty; - var sb = new StringBuilder(json.Length * 2); - var indent = " "; - var level = 0; - var inString = false; - var escapeNext = false; - - for (var i = 0; i < json.Length; i++) + try { - var c = json[i]; - - if (escapeNext) - { - sb.Append(c); - escapeNext = false; - continue; - } - - if (c == '\\') - { - sb.Append(c); - escapeNext = true; - continue; - } - - if (c == '"') - { - sb.Append(c); - inString = !inString; - continue; - } - - if (inString) - { - sb.Append(c); - continue; - } - - switch (c) + using var document = JsonDocument.Parse(json); + var options = new JsonSerializerOptions { - case '{': - case '[': - sb.Append(c); - sb.Append(Environment.NewLine); - level++; - - for (var j = 0; j < level; j++) - sb.Append(indent); - break; - - case '}': - case ']': - sb.Append(Environment.NewLine); - level--; - - for (var j = 0; j < level; j++) - sb.Append(indent); - - sb.Append(c); - break; - - case ',': - sb.Append(c); - sb.Append(Environment.NewLine); - - for (var j = 0; j < level; j++) - sb.Append(indent); - break; - - case ':': - sb.Append(c); - sb.Append(' '); - break; - - case ' ': - case '\t': - case '\r': - case '\n': - // Skip whitespace outside strings - break; - - default: - sb.Append(c); - break; - } + WriteIndented = true, + Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping + }; + return JsonSerializer.Serialize(document, options); + } + catch + { + return json; } - - return sb.ToString(); } - /// - /// Returns the executable application's path - /// public static string GetExecutablePath() { try { - var path = Process.GetCurrentProcess().MainModule.FileName; + var path = Process.GetCurrentProcess().MainModule?.FileName; if (!string.IsNullOrEmpty(path) && File.Exists(path)) return path; } - catch + catch { // ignored } @@ -183,9 +96,6 @@ public static string GetExecutablePath() return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, AppDomain.CurrentDomain.FriendlyName); } - /// - /// Gets the application's assembly version - /// public static Version GetVersion() { try @@ -198,11 +108,6 @@ public static Version GetVersion() } } - /// - /// Determines if the current Windows version supports updates via GitHub TLS/SNI. - /// Returns false for legacy Windows versions (XP/2003) that cannot reach GitHub. - /// - /// True if updates are supported; otherwise, false. public static bool IsAutoUpdateSupported { get @@ -222,59 +127,37 @@ public static bool IsAutoUpdateSupported } } - /// - /// Gets the string name of a property or field. - /// - /// The type of the member. - /// A lambda expression that accesses the member. - /// The string name of the member. public static string NameOf(Expression> expression) { if (expression == null) - throw new ArgumentNullException("expression"); - - var memberExpression = expression.Body as MemberExpression; + throw new ArgumentNullException(nameof(expression)); - if (memberExpression == null) - throw new ArgumentException("Expression must be a simple member access (e.g., () => myObject.MyProperty)."); + if (expression.Body is MemberExpression memberExpression) + return memberExpression.Member.Name; - return memberExpression.Member.Name; + throw new ArgumentException("Expression must be a simple member access (e.g., () => myObject.MyProperty)."); } - /// - /// Reads the embedded resource. - /// - /// Name of the resource. - /// public static T ReadEmbeddedResource(string name) { - using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name)) - using (var reader = new StreamReader(stream)) - { - return Deserialize(reader.ReadToEnd()); - } + using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name); + if (stream == null) + return default; + + using var reader = new StreamReader(stream); + var json = reader.ReadToEnd(); + return Deserialize(json); } - /// - /// Converts the specified object to a JSON string - /// - /// The object to serialize. - /// If true, produces compact JSON without formatting; otherwise, formats with indentation for readability. Default is false. - /// A JSON string representation of the object. - public static string Serialize(IJsonSerializable obj, bool minified = false) + public static string Serialize(T obj, bool minified = false) where T : IJsonSerializable { if (obj == null) - throw new ArgumentNullException("obj"); + throw new ArgumentNullException(nameof(obj)); - var json = new JavaScriptSerializer().Serialize(obj.ToJson()); - - return minified ? json : FormatJson(json); + var json = JsonSerializer.Serialize(obj.ToJson(), minified ? JsonOptionsMinified : JsonOptions); + return json; } - /// - /// Creates or deletes the Start Menu shortcut based on the specified flag. - /// - /// If true, creates the shortcut; if false, deletes it. public static void StartMenuShortcut(bool create) { try @@ -289,12 +172,13 @@ public static void StartMenuShortcut(bool create) link.SetPath(App.Path); link.SetWorkingDirectory(Path.GetDirectoryName(App.Path)); - IPersistFile file = (IPersistFile)link; - + var file = (ShellInterop.IPersistFile)link; file.Save(shortcutPath, false); } else + { DeleteFile(shortcutPath); + } } catch (Exception e) { @@ -302,14 +186,6 @@ public static void StartMenuShortcut(bool create) } } - /// - /// Converts to hexcode. - /// - /// The red. - /// The green. - /// The blue. - /// The alpha. - /// public static string ToHexCode(byte red, byte green, byte blue, byte? alpha = null) { if (alpha != null) @@ -317,5 +193,21 @@ public static string ToHexCode(byte red, byte green, byte blue, byte? alpha = nu return string.Format(Localizer.Culture, "#{0:X2}{1:X2}{2:X2}", red, green, blue); } + + private static readonly JsonSerializerOptions JsonOptions = new() + { + WriteIndented = true, + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull, + Converters = { new System.Text.Json.Serialization.JsonStringEnumConverter() } + }; + + private static readonly JsonSerializerOptions JsonOptionsMinified = new() + { + WriteIndented = false, + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull, + Converters = { new System.Text.Json.Serialization.JsonStringEnumConverter() } + }; } } \ No newline at end of file diff --git a/src/Core/Localizer.cs b/src/Core/Localizer.cs index 9058a83e..a138f9b7 100644 --- a/src/Core/Localizer.cs +++ b/src/Core/Localizer.cs @@ -5,20 +5,14 @@ using System.IO; using System.Linq; using System.Reflection; -using System.Runtime.Serialization.Json; +using System.Text.Json; namespace WinMemoryCleaner { - /// - /// Localizer - /// public static class Localizer { #region Events - /// - /// Occurs when [static property changed]. - /// public static event PropertyChangedEventHandler StaticPropertyChanged; #endregion @@ -27,40 +21,28 @@ public static class Localizer private static CultureInfo _culture; private static Language _language; + private static bool _isInitialized; + private static readonly Lazy _fallbackLocalizationLazy = new(InitializeFallback); + private static List _cachedLanguages; + private static readonly object _languagesLock = new(); #endregion - #region Constructors + #region Constructor static Localizer() { - String = new Localization(); - - try - { - Culture = new CultureInfo(Settings.Language); - } - catch - { - Culture = new CultureInfo(Constants.Windows.Locale.Name.English); - } - - Language = new Language(Culture); + String = _fallbackLocalizationLazy.Value; + _isInitialized = true; } #endregion #region Properties - /// - /// Gets the culture. - /// - /// - /// The culture. - /// public static CultureInfo Culture { - get { return _culture; } + get => _culture; private set { _culture = value; @@ -68,15 +50,9 @@ private set } } - /// - /// Gets or sets the language. - /// - /// - /// The language. - /// public static Language Language { - get { return _language; } + get => _language; set { if (_language != null && _language.Equals(value)) @@ -85,7 +61,7 @@ public static Language Language try { if (value == null) - throw new ArgumentNullException("value"); + throw new ArgumentNullException(nameof(value)); Load(value); @@ -96,107 +72,281 @@ public static Language Language { Settings.Language = Constants.Windows.Locale.Name.English; Settings.Save(); - throw; } _language = value; - RaiseStaticPropertyChanged(string.Empty); - App.ReleaseMemory(); + if (_isInitialized) + App.ReleaseMemory(); } } - /// - /// Gets the languages. - /// - /// - /// The languages. - /// public static List Languages { get { - try + if (_cachedLanguages != null) + return _cachedLanguages; + + lock (_languagesLock) { - var resourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames() - .Where(file => file.StartsWith(Constants.App.LocalizationResourcePath, StringComparison.OrdinalIgnoreCase) && file.EndsWith(Constants.App.EmbeddedResourcePathExtension, StringComparison.OrdinalIgnoreCase)) - .Select(file => file.Replace(Constants.App.LocalizationResourcePath, string.Empty).Replace(Constants.App.EmbeddedResourcePathExtension, string.Empty)) - .OrderBy(file => file) - .ToList(); + if (_cachedLanguages != null) + return _cachedLanguages; try { - var localResources = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, string.Format(Culture, "*{0}", Constants.App.EmbeddedResourcePathExtension), SearchOption.TopDirectoryOnly) - .Select(Path.GetFileNameWithoutExtension) + var assembly = Assembly.GetExecutingAssembly(); + var resourcePrefix = Constants.App.LocalizationResourcePath; + var resourceSuffix = Constants.App.EmbeddedResourcePathExtension; + + var resourceNames = assembly.GetManifestResourceNames() + .Where(file => file.StartsWith(resourcePrefix, StringComparison.OrdinalIgnoreCase) && + file.EndsWith(resourceSuffix, StringComparison.OrdinalIgnoreCase)) + .Select(file => file[resourcePrefix.Length..^resourceSuffix.Length]) + .OrderBy(file => file) .ToList(); - if (localResources.Any()) - resourceNames.AddRange(localResources); + try + { + var searchDirectories = new[] + { + AppDomain.CurrentDomain.BaseDirectory, + Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "Localization"), + Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "Themes") + }; + + var localResources = new List(); + foreach (var dir in searchDirectories) + { + try + { + var files = Directory.GetFiles(dir, + $"*{Constants.App.EmbeddedResourcePathExtension}", SearchOption.TopDirectoryOnly); + localResources.AddRange(files.Select(Path.GetFileNameWithoutExtension)); + } + catch + { + } + } + + if (localResources.Any()) + resourceNames.AddRange(localResources.Distinct()); + } + catch + { + } + + _cachedLanguages = CultureInfo.GetCultures(CultureTypes.AllCultures) + .Where(culture => resourceNames.Contains(culture.EnglishName, StringComparer.OrdinalIgnoreCase)) + .OrderBy(culture => culture.EnglishName, StringComparer.InvariantCultureIgnoreCase) + .Select(culture => new Language(culture)) + .ToList(); + + return _cachedLanguages; } - catch + catch (Exception e) { - // ignored + Logger.Error(e); + return new List { new Language(new CultureInfo(Constants.Windows.Locale.Name.English)) }; } - - return CultureInfo.GetCultures(CultureTypes.AllCultures) - .Where(culture => resourceNames.Contains(culture.EnglishName, StringComparer.OrdinalIgnoreCase)) - .OrderBy(culture => culture.EnglishName, StringComparer.InvariantCultureIgnoreCase) - .Select(culture => new Language(culture)) - .ToList(); - } - catch (Exception e) - { - Logger.Error(e); - - return new List { new Language(new CultureInfo(Constants.Windows.Locale.Name.English)) }; } } } - /// - /// Gets the string - /// public static Localization String { get; private set; } #endregion #region Methods + private static Localization InitializeFallback() + { + var fallback = new Localization(); + + // Use English format strings as fallback so placeholders work even if JSON fails to load + var englishStrings = new Dictionary + { + { nameof(Localization.About), "about" }, + { nameof(Localization.Add), "add" }, + { nameof(Localization.AlwaysOnTop), "always on top" }, + { nameof(Localization.AutoOptimization), "auto optimization" }, + { nameof(Localization.AutoOptimizationInterval), "the interval between subsequent free memory auto optimizations is {0} minutes" }, + { nameof(Localization.AutoUpdate), "auto update" }, + { nameof(Localization.Background), "background" }, + { nameof(Localization.Close), "close" }, + { nameof(Localization.CloseAfterOptimization), "close after optimization" }, + { nameof(Localization.CloseToTheNotificationArea), "close to the notification area" }, + { nameof(Localization.Collapse), "collapse" }, + { nameof(Localization.CombinedPageList), "combined page list" }, + { nameof(Localization.CreateStartMenuShortcut), "create start menu shortcut" }, + { nameof(Localization.DangerLevel), "danger level" }, + { nameof(Localization.Donate), "donate" }, + { nameof(Localization.DonationMessage), "if you find this app helpful, please consider donating. your contribution helps keep the project alive, optimized, and free for everyone." }, + { nameof(Localization.DonationTitle), "support this project" }, + { nameof(Localization.Error), "error" }, + { nameof(Localization.ErrorAdminPrivilegeRequired), "this operation requires administrator privileges ({0})" }, + { nameof(Localization.ErrorCanNotSaveLog), "cannot save the log: {0} ({1})" }, + { nameof(Localization.ErrorMemoryAreaOptimizationNotSupported), "the memory area {0} optimization is not supported on this version of the operating system" }, + { nameof(Localization.ErrorResetCommand), "reset failed: {0}" }, + { nameof(Localization.EveryHour), "every {0}h" }, + { nameof(Localization.Exit), "exit" }, + { nameof(Localization.Expand), "expand" }, + { nameof(Localization.Free), "free" }, + { nameof(Localization.GarbageCollector), "garbage collector" }, + { nameof(Localization.Help), "help" }, + { nameof(Localization.HotkeyIsInUseByOperatingSystem), "the hotkey ({0}) is in use by the operating system" }, + { nameof(Localization.Invalid), "invalid" }, + { nameof(Localization.LowMemory), "low memory" }, + { nameof(Localization.Manual), "manual" }, + { nameof(Localization.MemoryAreas), "memory areas" }, + { nameof(Localization.MemoryOptimized), "memory optimized" }, + { nameof(Localization.MemoryUsage), "memory usage" }, + { nameof(Localization.Minimize), "minimize" }, + { nameof(Localization.ModifiedFileCache), "modified file cache" }, + { nameof(Localization.ModifiedPageList), "modified page list" }, + { nameof(Localization.No), "no" }, + { nameof(Localization.OptimizationHotkey), "optimization hotkey" }, + { nameof(Localization.Optimize), "optimize" }, + { nameof(Localization.OptimizeOnMiddleMouseClick), "optimize on middle mouse click" }, + { nameof(Localization.Optimizing), "optimizing" }, + { nameof(Localization.PhysicalMemory), "physical memory" }, + { nameof(Localization.ProcessExclusionList), "processes excluded from optimization" }, + { nameof(Localization.Reason), "reason" }, + { nameof(Localization.RegistryCache), "registry cache" }, + { nameof(Localization.Remove), "remove" }, + { nameof(Localization.Reset), "reset" }, + { nameof(Localization.ResetCommand), "reset successful." }, + { nameof(Localization.ResetConfirmation), "are you sure you want to reset to the default configuration?" }, + { nameof(Localization.RunOnLowPriority), "run on low priority" }, + { nameof(Localization.RunOnStartup), "run on startup" }, + { nameof(Localization.Schedule), "schedule" }, + { nameof(Localization.Seconds), "seconds" }, + { nameof(Localization.Settings), "settings" }, + { nameof(Localization.ShowMemoryUsage), "show memory usage" }, + { nameof(Localization.ShowOptimizationNotifications), "show optimization notifications" }, + { nameof(Localization.ShowVirtualMemory), "show virtual memory" }, + { nameof(Localization.StandbyList), "standby list" }, + { nameof(Localization.StandbyListLowPriority), "standby list (low priority)" }, + { nameof(Localization.StartMinimized), "start minimized" }, + { nameof(Localization.SystemFileCache), "system file cache" }, + { nameof(Localization.Text), "text" }, + { nameof(Localization.TrayIcon), "tray icon" }, + { nameof(Localization.UpdatedToVersion), "updated to version {0}" }, + { nameof(Localization.UseTransparentBackground), "use transparent background" }, + { nameof(Localization.Used), "used" }, + { nameof(Localization.VirtualMemory), "virtual memory" }, + { nameof(Localization.WhenFreePhysicalMemoryIsBelow), "when free physical memory is below {0}%" }, + { nameof(Localization.WarningLevel), "warning level" }, + { nameof(Localization.WorkingSet), "working set" }, + { nameof(Localization.Yes), "yes" } + }; + + var props = typeof(Localization).GetProperties(BindingFlags.Public | BindingFlags.Instance); + foreach (var prop in props) + { + if (prop.PropertyType == typeof(string) && prop.CanWrite) + { + var name = prop.Name; + if (englishStrings.TryGetValue(name, out var value)) + { + prop.SetValue(fallback, value); + } + else + { + prop.SetValue(fallback, name); + } + } + } + return fallback; + } + private static void Load(Language language) { - Localization localization; + Localization localization = null; + var resourceName = $"{Constants.App.LocalizationResourcePath}{language.EnglishName}{Constants.App.EmbeddedResourcePathExtension}"; + + var options = new JsonSerializerOptions + { + PropertyNameCaseInsensitive = true, + ReadCommentHandling = JsonCommentHandling.Skip, + AllowTrailingCommas = true + }; - var localResource = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, string.Format(Culture, "{0}{1}", language.EnglishName, Constants.App.EmbeddedResourcePathExtension)); - var resource = string.Format(Culture, "{0}{1}{2}", Constants.App.LocalizationResourcePath, language.EnglishName, Constants.App.EmbeddedResourcePathExtension); + var assembliesToTry = new[] { Assembly.GetExecutingAssembly(), Assembly.GetEntryAssembly() }.Distinct(); - using (var stream = File.Exists(localResource) ? File.OpenRead(localResource) : Assembly.GetExecutingAssembly().GetManifestResourceStream(resource)) + foreach (var assembly in assembliesToTry) { + if (assembly == null) continue; + try { - if (stream == null) - throw new NullReferenceException(); + using var stream = assembly.GetManifestResourceStream(resourceName); + if (stream != null) + { + localization = JsonSerializer.Deserialize(stream, options); + if (localization != null) + { + break; + } + } + } + catch (Exception e) + { + Logger.Debug($"Failed to load embedded resource {resourceName} from {assembly.FullName}: {e.Message}"); + } + } - var serializer = new DataContractJsonSerializer(typeof(Localization)); + if (localization == null) + { + var searchDirectories = new[] + { + AppDomain.CurrentDomain.BaseDirectory, + Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "Localization"), + Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "Themes") + }; - localization = (Localization)serializer.ReadObject(stream); - } - catch + foreach (var dir in searchDirectories) { - throw new Exception(string.Format(Culture, "The {0} language file is missing or invalid.", language.EnglishName)); + var localResource = Path.Combine(dir, $"{language.EnglishName}{Constants.App.EmbeddedResourcePathExtension}"); + try + { + if (File.Exists(localResource)) + { + using var stream = File.OpenRead(localResource); + localization = JsonSerializer.Deserialize(stream, options); + if (localization != null) + { + break; + } + } + } + catch (Exception e) + { + Logger.Debug($"Failed to load local file {localResource}: {e.Message}"); + } } } + if (localization == null) + { + Logger.Warning($"Language file for {language.EnglishName} not found or invalid, using fallback"); + localization = _fallbackLocalizationLazy.Value; + } + var nullOrEmptyStrings = localization .GetType() .GetProperties() - .Where(pi => pi.PropertyType == typeof(string) && string.IsNullOrWhiteSpace((string)pi.GetValue(localization, null))) + .Where(pi => pi.PropertyType == typeof(string) && string.IsNullOrWhiteSpace((string)pi.GetValue(localization))) .Select(pi => pi.Name) .ToList(); if (nullOrEmptyStrings.Any()) - throw new Exception(string.Format(Culture, "The {0} language file is invalid. Missing Values: {1}", language.EnglishName, string.Join(", ", nullOrEmptyStrings))); + { + Logger.Warning($"Language file for {language.EnglishName} has missing values: {string.Join(", ", nullOrEmptyStrings)}, using fallback"); + localization = _fallbackLocalizationLazy.Value; + } Culture = new CultureInfo(language.Name); String = localization; @@ -204,10 +354,9 @@ private static void Load(Language language) private static void RaiseStaticPropertyChanged(string propertyName = null) { - if (StaticPropertyChanged != null) - StaticPropertyChanged.Invoke(null, new PropertyChangedEventArgs(propertyName)); + StaticPropertyChanged?.Invoke(null, new PropertyChangedEventArgs(propertyName)); } #endregion } -} +} \ No newline at end of file diff --git a/src/Core/Logger.cs b/src/Core/Logger.cs index 6e266d3d..f51b3f40 100644 --- a/src/Core/Logger.cs +++ b/src/Core/Logger.cs @@ -14,6 +14,7 @@ public static class Logger { #region Fields + private static readonly object _syncLock = new object(); private static SafeFileHandle _consoleHandle; private static FileStream _consoleStream; private static StreamWriter _consoleWriter; @@ -23,9 +24,6 @@ public static class Logger #region Constructor - /// - /// Initializes the class. - /// static Logger() { try @@ -51,6 +49,8 @@ static Logger() Event(e.GetMessage(), EventLogEntryType.Error); } } + + AppDomain.CurrentDomain.ProcessExit += (_, _) => Dispose(); } /// @@ -59,54 +59,16 @@ static Logger() /// internal static void Dispose() { - if (_consoleWriter != null) + lock (_syncLock) { - try - { - _consoleWriter.Flush(); - } - catch - { - // ignored - } - - try - { - _consoleWriter.Close(); - } - catch - { - // ignored - } - + try { _consoleWriter?.Flush(); } catch { /* ignored */ } + try { _consoleWriter?.Dispose(); } catch { /* ignored */ } _consoleWriter = null; - } - - if (_consoleStream != null) - { - try - { - _consoleStream.Close(); - } - catch - { - // ignored - } + try { _consoleStream?.Dispose(); } catch { /* ignored */ } _consoleStream = null; - } - - if (_consoleHandle != null) - { - try - { - _consoleHandle.Close(); - } - catch - { - // ignored - } + try { _consoleHandle?.Dispose(); } catch { /* ignored */ } _consoleHandle = null; } } @@ -115,12 +77,6 @@ internal static void Dispose() #region Properties - /// - /// Gets a value indicating whether console output is enabled. - /// - /// - /// true if console output is enabled; otherwise, false. - /// private static bool IsConsoleEnabled { get { return _consoleWriter != null; } } private static bool IsDebugEnabled { get { return (_level & Enums.Log.Levels.Debug) != 0; } } @@ -134,9 +90,6 @@ internal static void Dispose() /// /// Sets the log level. /// - /// - /// The log level. - /// public static Enums.Log.Levels Level { get { return _level; } @@ -170,9 +123,6 @@ public static Enums.Log.Levels Level /// /// Debug /// - /// Exception - /// Custom message about the Exception - /// Method public static void Debug(Exception exception, string message = null, [CallerMemberName] string method = null) { Exception(Enums.Log.Levels.Debug, exception, message, method); @@ -181,8 +131,6 @@ public static void Debug(Exception exception, string message = null, [CallerMemb /// /// Debug /// - /// Message - /// Method public static void Debug(string message, [CallerMemberName] string method = null) { Log(new Log(Enums.Log.Levels.Debug, message, null, method)); @@ -191,44 +139,43 @@ public static void Debug(string message, [CallerMemberName] string method = null /// /// Enables console output by attaching to the parent console process and redirecting standard output. /// This allows Console.WriteLine output to appear in the calling terminal (PowerShell/cmd). - /// Typically called when the application is invoked with command-line arguments. /// This method is idempotent - calling it multiple times has no additional effect. /// public static void EnableConsoleOutput() { - try + lock (_syncLock) { - if (IsConsoleEnabled) - return; - - if (NativeMethods.AttachConsole(Constants.Windows.Console.AttachParentProcess)) + try { - var stdHandle = NativeMethods.GetStdHandle(Constants.Windows.Console.StdOutputHandle); + if (IsConsoleEnabled) + return; - if (stdHandle != IntPtr.Zero && stdHandle != new IntPtr(-1)) + if (NativeMethods.AttachConsole(Constants.Windows.Console.AttachParentProcess)) { - _consoleHandle = new SafeFileHandle(stdHandle, false); - _consoleStream = new FileStream(_consoleHandle, FileAccess.Write); - _consoleWriter = new StreamWriter(_consoleStream, Encoding.Default) { AutoFlush = true }; + var stdHandle = NativeMethods.GetStdHandle(Constants.Windows.Console.StdOutputHandle); + + if (stdHandle != IntPtr.Zero && stdHandle != new IntPtr(-1)) + { + _consoleHandle = new SafeFileHandle(stdHandle, false); + _consoleStream = new FileStream(_consoleHandle, FileAccess.Write); + _consoleWriter = new StreamWriter(_consoleStream, Encoding.Default) { AutoFlush = true }; - Console.SetOut(_consoleWriter); + Console.SetOut(_consoleWriter); - Trace.Listeners.Clear(); + Trace.Listeners.Clear(); + } } } - } - catch - { - // ignored + catch + { + // ignored + } } } /// /// Error /// - /// Exception - /// Custom message about the Exception - /// Method public static void Error(Exception exception, string message = null, [CallerMemberName] string method = null) { Exception(Enums.Log.Levels.Error, exception, message, method); @@ -237,37 +184,26 @@ public static void Error(Exception exception, string message = null, [CallerMemb /// /// Error /// - /// Message - /// Method public static void Error(string message, [CallerMemberName] string method = null) { Log(new Log(Enums.Log.Levels.Error, message, null, method)); } - /// +/// /// Windows Event /// - /// Message - /// Type private static void Event(string message, EventLogEntryType type = EventLogEntryType.Information) { try { EventLog.WriteEntry(Constants.App.Title, message, type); } - catch + catch (Exception ex) { - // ignored + Logger.Debug("EventLog.WriteEntry failed: " + ex.Message); } } - /// - /// Exception - /// - /// The level. - /// The exception. - /// The message. - /// The method. private static void Exception(Enums.Log.Levels level, Exception exception, string message = null, [CallerMemberName] string method = null) { if (IsDebugEnabled) @@ -278,19 +214,15 @@ private static void Exception(Enums.Log.Levels level, Exception exception, strin if (stackTrace != null && stackTrace.FrameCount > 0) { var frame = stackTrace.GetFrame(stackTrace.FrameCount - 1); + var methodBase = frame?.GetMethod(); - if (frame != null) - { - var methodBase = frame.GetMethod(); - - if (methodBase != null && methodBase.DeclaringType != null) - method = string.Format(Localizer.Culture, "{0}.{1}", methodBase.DeclaringType.Name, methodBase.Name); - } + if (methodBase?.DeclaringType != null) + method = string.Format(Localizer.Culture, "{0}.{1}", methodBase.DeclaringType.Name, methodBase.Name); } } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Stack trace extraction failed: " + ex.Message); } } @@ -303,8 +235,6 @@ private static void Exception(Enums.Log.Levels level, Exception exception, strin /// /// Information /// - /// Message - /// Method public static void Information(string message, [CallerMemberName] string method = null) { Log(new Log(Enums.Log.Levels.Information, message, null, method)); @@ -313,13 +243,12 @@ public static void Information(string message, [CallerMemberName] string method /// /// Log /// - /// The log. public static void Log(Log log) { try { if (log == null) - throw new ArgumentNullException("log"); + throw new ArgumentNullException(nameof(log)); var message = log.Message; @@ -330,9 +259,9 @@ public static void Log(Log log) { Console.WriteLine(message); } - catch + catch (Exception ex) { - // ignored + Logger.Debug("Console.WriteLine failed: " + ex.Message); } } @@ -371,13 +300,11 @@ public static void Log(Log log) /// /// Warning /// - /// Message - /// Method public static void Warning(string message, [CallerMemberName] string method = null) { Log(new Log(Enums.Log.Levels.Warning, message, null, method)); } - } - #endregion Methods -} + #endregion Methods + } +} \ No newline at end of file diff --git a/src/Core/ObservableObject.cs b/src/Core/ObservableObject.cs index bb305f0f..9c9712c2 100644 --- a/src/Core/ObservableObject.cs +++ b/src/Core/ObservableObject.cs @@ -24,45 +24,39 @@ public abstract class ObservableObject : INotifyPropertyChanged #region Methods /// - /// Called when [property changed]. + /// Raises the PropertyChanged event. /// - /// Name of the property. + /// Name of the property. Resolved automatically via CallerMemberName. + protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) + { + PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); + } + + /// + /// Raises the PropertyChanged event. Alias for kept for backwards compatibility. + /// + /// Name of the property. Resolved automatically via CallerMemberName. public void RaisePropertyChanged([CallerMemberName] string propertyName = null) { - if (PropertyChanged != null) - PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName)); + OnPropertyChanged(propertyName); } /// - /// Raises the PropertyChanged event if needed. + /// Raises the PropertyChanged event for the given property expression. /// - /// The type of the property that - /// changed. - /// An expression identifying the property - /// that changed. + /// The type of the property that changed. + /// An expression identifying the property that changed. public void RaisePropertyChanged(Expression> expression) { - var handler = PropertyChanged; - - if (handler != null && expression != null) + if (expression?.Body is MemberExpression body && body.Member is PropertyInfo property) { - var body = expression.Body as MemberExpression; - - if (body != null) - { - var property = body.Member as PropertyInfo; - - if (property != null) - { - var propertyName = property.Name; + var propertyName = property.Name; - if (!string.IsNullOrEmpty(propertyName)) - RaisePropertyChanged(propertyName); - } - } + if (!string.IsNullOrEmpty(propertyName)) + OnPropertyChanged(propertyName); } } #endregion } -} +} \ No newline at end of file diff --git a/src/Core/Settings.cs b/src/Core/Settings.cs index 1155ee04..3bdf8be8 100644 --- a/src/Core/Settings.cs +++ b/src/Core/Settings.cs @@ -1,5 +1,6 @@ ๏ปฟusing Microsoft.Win32; using System; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Drawing; using System.Globalization; @@ -10,16 +11,23 @@ namespace WinMemoryCleaner { + /// + /// Application settings persisted in the Windows registry (HKLM) so they are shared + /// between the desktop app and the Windows Service (which runs as LOCAL SYSTEM). + /// public static class Settings { private static readonly CultureInfo _culture = new CultureInfo(Constants.Windows.Locale.Name.English); + private static readonly object _syncLock = new object(); + private static bool _isLoaded; #region Constructors static Settings() { - Load(); - Save(); + // Default values only - don't load from registry yet to avoid circular dependency + LoadDefaults(); + _isLoaded = true; } #endregion @@ -52,7 +60,28 @@ static Settings() public static ModifierKeys OptimizationModifiers { get; set; } - public static SortedSet ProcessExclusionList { get; private set; } + public static ConcurrentDictionary ProcessExclusionList { get; private set; } + + public static bool IsProcessExcluded(string processName) + { + if (string.IsNullOrEmpty(processName)) + return false; + return ProcessExclusionList.ContainsKey(processName); + } + + public static bool TryAddProcessExclusion(string processName) + { + if (string.IsNullOrEmpty(processName)) + return false; + return ProcessExclusionList.TryAdd(processName, 0); + } + + public static bool TryRemoveProcessExclusion(string processName) + { + if (string.IsNullOrEmpty(processName)) + return false; + return ProcessExclusionList.TryRemove(processName, out _); + } public static Enums.Priority RunOnPriority { get; set; } @@ -90,9 +119,8 @@ static Settings() #region Methods - private static void Load(bool loadUserValues = true) + private static void LoadDefaults() { - // Default values AlwaysOnTop = false; AutoOptimizationInterval = 0; AutoOptimizationMemoryUsage = 0; @@ -106,7 +134,7 @@ private static void Load(bool loadUserValues = true) MemoryAreas = Enums.Memory.Areas.CombinedPageList | Enums.Memory.Areas.ModifiedFileCache | Enums.Memory.Areas.ModifiedPageList | Enums.Memory.Areas.RegistryCache | Enums.Memory.Areas.StandbyList | Enums.Memory.Areas.SystemFileCache | Enums.Memory.Areas.WorkingSet; OptimizationKey = Key.M; OptimizationModifiers = ModifierKeys.Control | ModifierKeys.Shift; - ProcessExclusionList = new SortedSet(StringComparer.OrdinalIgnoreCase); + ProcessExclusionList = new ConcurrentDictionary(StringComparer.OrdinalIgnoreCase); RunOnPriority = Enums.Priority.Low; RunOnStartup = false; ShowOptimizationNotifications = true; @@ -123,104 +151,108 @@ private static void Load(bool loadUserValues = true) TrayIconWarningColor = Brushes.DarkGoldenrod; TrayIconWarningLevel = 80; UseHotkey = false; + } - // User values - try + public static void Load() + { + lock (_syncLock) { - if (!loadUserValues) - return; - - // Process Exclusion List - using (var key = Registry.LocalMachine.OpenSubKey(Constants.App.Registry.Key.ProcessExclusionList)) + if (!_isLoaded) { - if (key != null) - { - foreach (var name in key.GetValueNames()) - ProcessExclusionList.Add(name.RemoveWhitespaces().Replace(".exe", string.Empty).ToLower(_culture)); - } + LoadDefaults(); + _isLoaded = true; } - // Settings - using (var key = Registry.LocalMachine.OpenSubKey(Constants.App.Registry.Key.Settings)) + try { - if (key != null) + // Process Exclusion List + using (var key = Registry.LocalMachine.OpenSubKey(Constants.App.Registry.Key.ProcessExclusionList)) { - AlwaysOnTop = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => AlwaysOnTop), AlwaysOnTop), _culture); - AutoOptimizationInterval = Convert.ToInt32(key.GetValue(Helper.NameOf(() => AutoOptimizationInterval), AutoOptimizationInterval), _culture); - AutoOptimizationMemoryUsage = Convert.ToInt32(key.GetValue(Helper.NameOf(() => AutoOptimizationMemoryUsage), AutoOptimizationMemoryUsage), _culture); - AutoUpdate = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => AutoUpdate), AutoUpdate), _culture); - CloseAfterOptimization = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => CloseAfterOptimization), CloseAfterOptimization), _culture); - CloseToTheNotificationArea = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => CloseToTheNotificationArea), CloseToTheNotificationArea), _culture); - CompactMode = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => CompactMode), CompactMode), _culture); - CreateStartMenuShortcut = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => CreateStartMenuShortcut), CreateStartMenuShortcut), _culture); - FontSize = Convert.ToDouble(key.GetValue(Helper.NameOf(() => FontSize), FontSize), _culture); - Language = Convert.ToString(key.GetValue(Helper.NameOf(() => Language), Language), CultureInfo.InvariantCulture); - - Enums.Memory.Areas memoryAreas; - - if (Enum.TryParse(Convert.ToString(key.GetValue(Helper.NameOf(() => MemoryAreas), MemoryAreas), _culture), out memoryAreas) && memoryAreas.IsValid()) + if (key != null) { - if ((memoryAreas & Enums.Memory.Areas.StandbyList) != 0 && (memoryAreas & Enums.Memory.Areas.StandbyListLowPriority) != 0) - memoryAreas &= ~Enums.Memory.Areas.StandbyListLowPriority; - - MemoryAreas = memoryAreas; + ProcessExclusionList.Clear(); + foreach (var name in key.GetValueNames()) + { + var cleanName = name.RemoveWhitespaces().Replace(".exe", string.Empty).ToLower(_culture); + ProcessExclusionList.TryAdd(cleanName, 0); + } } - - Key optimizationKey; - - if (Enum.TryParse(Convert.ToString(key.GetValue(Helper.NameOf(() => OptimizationKey), OptimizationKey), _culture), out optimizationKey) && optimizationKey.IsValid()) - OptimizationKey = optimizationKey; - - ModifierKeys optimizationModifiers; - - if (Enum.TryParse(Convert.ToString(key.GetValue(Helper.NameOf(() => OptimizationModifiers), OptimizationModifiers), _culture), out optimizationModifiers) && optimizationModifiers.IsValid()) - OptimizationModifiers = optimizationModifiers; - - Enums.Priority runOnPriority; - - if (Enum.TryParse(Convert.ToString(key.GetValue(Helper.NameOf(() => RunOnPriority), RunOnPriority), _culture), out runOnPriority) && runOnPriority.IsValid()) - RunOnPriority = runOnPriority; - - RunOnStartup = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => RunOnStartup), RunOnStartup), _culture); - ShowOptimizationNotifications = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => ShowOptimizationNotifications), ShowOptimizationNotifications), _culture); - ShowVirtualMemory = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => ShowVirtualMemory), ShowVirtualMemory), _culture); - StartMinimized = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => StartMinimized), StartMinimized), _culture); - TrayIconBackgroundColor = Convert.ToString(key.GetValue(Helper.NameOf(() => TrayIconBackgroundColor), TrayIconBackgroundColor), _culture).ToBrush(TrayIconBackgroundColor); - TrayIconDangerColor = Convert.ToString(key.GetValue(Helper.NameOf(() => TrayIconDangerColor), TrayIconDangerColor), _culture).ToBrush(TrayIconDangerColor); - TrayIconDangerLevel = Convert.ToByte(key.GetValue(Helper.NameOf(() => TrayIconDangerLevel), TrayIconDangerLevel), _culture); - TrayIconOptimizeOnMiddleMouseClick = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => TrayIconOptimizeOnMiddleMouseClick), TrayIconOptimizeOnMiddleMouseClick), _culture); - TrayIconOptimizingColor = Convert.ToString(key.GetValue(Helper.NameOf(() => TrayIconOptimizingColor), TrayIconOptimizingColor), _culture).ToBrush(TrayIconOptimizingColor); - TrayIconShowMemoryUsage = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => TrayIconShowMemoryUsage), TrayIconShowMemoryUsage), _culture); - TrayIconTextColor = Convert.ToString(key.GetValue(Helper.NameOf(() => TrayIconTextColor), TrayIconTextColor), _culture).ToBrush(TrayIconTextColor); - TrayIconUseTransparentBackground = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => TrayIconUseTransparentBackground), TrayIconUseTransparentBackground), _culture); - TrayIconWarningColor = Convert.ToString(key.GetValue(Helper.NameOf(() => TrayIconWarningColor), TrayIconWarningColor), _culture).ToBrush(TrayIconWarningColor); - TrayIconWarningLevel = Convert.ToByte(key.GetValue(Helper.NameOf(() => TrayIconWarningLevel), TrayIconWarningLevel), _culture); - UseHotkey = Convert.ToBoolean(key.GetValue(Helper.NameOf(() => UseHotkey), UseHotkey), _culture); } - else - { - // Smart language setter for the first run - var culture = CultureInfo.CurrentCulture; - var languages = Localizer.Languages.Select(language => language.Name).ToList(); - do + // Settings + using (var key = Registry.LocalMachine.OpenSubKey(Constants.App.Registry.Key.Settings)) + { + if (key != null) { - if (languages.Contains(culture.Name, StringComparer.OrdinalIgnoreCase)) + AlwaysOnTop = Convert.ToBoolean(key.GetValue(nameof(AlwaysOnTop), AlwaysOnTop), _culture); + AutoOptimizationInterval = Convert.ToInt32(key.GetValue(nameof(AutoOptimizationInterval), AutoOptimizationInterval), _culture); + AutoOptimizationMemoryUsage = Convert.ToInt32(key.GetValue(nameof(AutoOptimizationMemoryUsage), AutoOptimizationMemoryUsage), _culture); + AutoUpdate = Convert.ToBoolean(key.GetValue(nameof(AutoUpdate), AutoUpdate), _culture); + CloseAfterOptimization = Convert.ToBoolean(key.GetValue(nameof(CloseAfterOptimization), CloseAfterOptimization), _culture); + CloseToTheNotificationArea = Convert.ToBoolean(key.GetValue(nameof(CloseToTheNotificationArea), CloseToTheNotificationArea), _culture); + CompactMode = Convert.ToBoolean(key.GetValue(nameof(CompactMode), CompactMode), _culture); + CreateStartMenuShortcut = Convert.ToBoolean(key.GetValue(nameof(CreateStartMenuShortcut), CreateStartMenuShortcut), _culture); + FontSize = Convert.ToDouble(key.GetValue(nameof(FontSize), FontSize), _culture); + Language = Convert.ToString(key.GetValue(nameof(Language), Language), CultureInfo.InvariantCulture); + + if (Enum.TryParse(Convert.ToString(key.GetValue(nameof(MemoryAreas), MemoryAreas), _culture), out Enums.Memory.Areas memoryAreas) && memoryAreas.IsValid()) { - Localizer.Language = new Language(culture); - Language = culture.Name; - break; + if ((memoryAreas & Enums.Memory.Areas.StandbyList) != 0 && (memoryAreas & Enums.Memory.Areas.StandbyListLowPriority) != 0) + memoryAreas &= ~Enums.Memory.Areas.StandbyListLowPriority; + + MemoryAreas = memoryAreas; } - culture = culture.Parent; + if (Enum.TryParse(Convert.ToString(key.GetValue(nameof(OptimizationKey), OptimizationKey), _culture), out Key optimizationKey) && optimizationKey.IsValid()) + OptimizationKey = optimizationKey; + + if (Enum.TryParse(Convert.ToString(key.GetValue(nameof(OptimizationModifiers), OptimizationModifiers), _culture), out ModifierKeys optimizationModifiers) && optimizationModifiers.IsValid()) + OptimizationModifiers = optimizationModifiers; + + if (Enum.TryParse(Convert.ToString(key.GetValue(nameof(RunOnPriority), RunOnPriority), _culture), out Enums.Priority runOnPriority) && runOnPriority.IsValid()) + RunOnPriority = runOnPriority; + + RunOnStartup = Convert.ToBoolean(key.GetValue(nameof(RunOnStartup), RunOnStartup), _culture); + ShowOptimizationNotifications = Convert.ToBoolean(key.GetValue(nameof(ShowOptimizationNotifications), ShowOptimizationNotifications), _culture); + ShowVirtualMemory = Convert.ToBoolean(key.GetValue(nameof(ShowVirtualMemory), ShowVirtualMemory), _culture); + StartMinimized = Convert.ToBoolean(key.GetValue(nameof(StartMinimized), StartMinimized), _culture); + TrayIconBackgroundColor = Convert.ToString(key.GetValue(nameof(TrayIconBackgroundColor), TrayIconBackgroundColor), _culture).ToBrush(TrayIconBackgroundColor); + TrayIconDangerColor = Convert.ToString(key.GetValue(nameof(TrayIconDangerColor), TrayIconDangerColor), _culture).ToBrush(TrayIconDangerColor); + TrayIconDangerLevel = Convert.ToByte(key.GetValue(nameof(TrayIconDangerLevel), TrayIconDangerLevel), _culture); + TrayIconOptimizeOnMiddleMouseClick = Convert.ToBoolean(key.GetValue(nameof(TrayIconOptimizeOnMiddleMouseClick), TrayIconOptimizeOnMiddleMouseClick), _culture); + TrayIconOptimizingColor = Convert.ToString(key.GetValue(nameof(TrayIconOptimizingColor), TrayIconOptimizingColor), _culture).ToBrush(TrayIconOptimizingColor); + TrayIconShowMemoryUsage = Convert.ToBoolean(key.GetValue(nameof(TrayIconShowMemoryUsage), TrayIconShowMemoryUsage), _culture); + TrayIconTextColor = Convert.ToString(key.GetValue(nameof(TrayIconTextColor), TrayIconTextColor), _culture).ToBrush(TrayIconTextColor); + TrayIconUseTransparentBackground = Convert.ToBoolean(key.GetValue(nameof(TrayIconUseTransparentBackground), TrayIconUseTransparentBackground), _culture); + TrayIconWarningColor = Convert.ToString(key.GetValue(nameof(TrayIconWarningColor), TrayIconWarningColor), _culture).ToBrush(TrayIconWarningColor); + TrayIconWarningLevel = Convert.ToByte(key.GetValue(nameof(TrayIconWarningLevel), TrayIconWarningLevel), _culture); + UseHotkey = Convert.ToBoolean(key.GetValue(nameof(UseHotkey), UseHotkey), _culture); + } + else + { + // Smart language setter for the first run + var culture = CultureInfo.CurrentCulture; + var languages = Localizer.Languages.Select(language => language.Name).ToList(); + + do + { + if (languages.Contains(culture.Name, StringComparer.OrdinalIgnoreCase)) + { + Localizer.Language = new Language(culture); + Language = culture.Name; + break; + } + + culture = culture.Parent; + } + while (culture.LCID != CultureInfo.InvariantCulture.LCID); } - while (culture.LCID != CultureInfo.InvariantCulture.LCID); } } - } - catch (Exception e) - { - Logger.Error(e); + catch (Exception e) + { + Logger.Error(e); + } } } @@ -228,73 +260,78 @@ public static void Reset(bool keepLanguage = false) { var language = Language; - Load(false); - - if (keepLanguage) - Language = language; + lock (_syncLock) + { + LoadDefaults(); + if (keepLanguage) + Language = language; - Save(); + Save(); + } } public static void Save() { - try + lock (_syncLock) { - // Process Exclusion List - Registry.LocalMachine.DeleteSubKey(Constants.App.Registry.Key.ProcessExclusionList, false); - - if (ProcessExclusionList.Any()) + try { - using (var key = Registry.LocalMachine.CreateSubKey(Constants.App.Registry.Key.ProcessExclusionList)) + // Process Exclusion List + Registry.LocalMachine.DeleteSubKey(Constants.App.Registry.Key.ProcessExclusionList, false); + + if (!ProcessExclusionList.IsEmpty) { - if (key != null) + using (var key = Registry.LocalMachine.CreateSubKey(Constants.App.Registry.Key.ProcessExclusionList)) { - foreach (var process in ProcessExclusionList) - key.SetValue(process.RemoveWhitespaces().Replace(".exe", string.Empty).ToLower(_culture), string.Empty, RegistryValueKind.String); + if (key != null) + { + foreach (var process in ProcessExclusionList.Keys) + key.SetValue(process.RemoveWhitespaces().Replace(".exe", string.Empty).ToLower(_culture), string.Empty, RegistryValueKind.String); + } } } - } - // Settings - using (var key = Registry.LocalMachine.CreateSubKey(Constants.App.Registry.Key.Settings)) - { - if (key != null) + // Settings + using (var key = Registry.LocalMachine.CreateSubKey(Constants.App.Registry.Key.Settings)) { - key.SetValue(Helper.NameOf(() => AlwaysOnTop), AlwaysOnTop ? 1 : 0); - key.SetValue(Helper.NameOf(() => AutoOptimizationInterval), AutoOptimizationInterval); - key.SetValue(Helper.NameOf(() => AutoOptimizationMemoryUsage), AutoOptimizationMemoryUsage); - key.SetValue(Helper.NameOf(() => AutoUpdate), AutoUpdate ? 1 : 0); - key.SetValue(Helper.NameOf(() => CloseAfterOptimization), CloseAfterOptimization ? 1 : 0); - key.SetValue(Helper.NameOf(() => CloseToTheNotificationArea), CloseToTheNotificationArea ? 1 : 0); - key.SetValue(Helper.NameOf(() => CompactMode), CompactMode ? 1 : 0); - key.SetValue(Helper.NameOf(() => CreateStartMenuShortcut), CreateStartMenuShortcut ? 1 : 0); - key.SetValue(Helper.NameOf(() => FontSize), FontSize); - key.SetValue(Helper.NameOf(() => Language), Language); - key.SetValue(Helper.NameOf(() => MemoryAreas), (int)MemoryAreas); - key.SetValue(Helper.NameOf(() => OptimizationKey), (int)OptimizationKey); - key.SetValue(Helper.NameOf(() => OptimizationModifiers), (int)OptimizationModifiers); - key.SetValue(Helper.NameOf(() => RunOnPriority), (int)RunOnPriority); - key.SetValue(Helper.NameOf(() => RunOnStartup), RunOnStartup ? 1 : 0); - key.SetValue(Helper.NameOf(() => ShowOptimizationNotifications), ShowOptimizationNotifications ? 1 : 0); - key.SetValue(Helper.NameOf(() => ShowVirtualMemory), ShowVirtualMemory ? 1 : 0); - key.SetValue(Helper.NameOf(() => StartMinimized), StartMinimized ? 1 : 0); - key.SetValue(Helper.NameOf(() => TrayIconBackgroundColor), TrayIconBackgroundColor.GetHex(true)); - key.SetValue(Helper.NameOf(() => TrayIconDangerColor), TrayIconDangerColor.GetHex(true)); - key.SetValue(Helper.NameOf(() => TrayIconDangerLevel), TrayIconDangerLevel); - key.SetValue(Helper.NameOf(() => TrayIconOptimizeOnMiddleMouseClick), TrayIconOptimizeOnMiddleMouseClick ? 1 : 0); - key.SetValue(Helper.NameOf(() => TrayIconOptimizingColor), TrayIconOptimizingColor.GetHex(true)); - key.SetValue(Helper.NameOf(() => TrayIconShowMemoryUsage), TrayIconShowMemoryUsage ? 1 : 0); - key.SetValue(Helper.NameOf(() => TrayIconTextColor), TrayIconTextColor.GetHex(true)); - key.SetValue(Helper.NameOf(() => TrayIconUseTransparentBackground), TrayIconUseTransparentBackground ? 1 : 0); - key.SetValue(Helper.NameOf(() => TrayIconWarningColor), TrayIconWarningColor.GetHex(true)); - key.SetValue(Helper.NameOf(() => TrayIconWarningLevel), TrayIconWarningLevel); - key.SetValue(Helper.NameOf(() => UseHotkey), UseHotkey ? 1 : 0); + if (key != null) + { + key.SetValue(nameof(AlwaysOnTop), AlwaysOnTop ? 1 : 0); + key.SetValue(nameof(AutoOptimizationInterval), AutoOptimizationInterval); + key.SetValue(nameof(AutoOptimizationMemoryUsage), AutoOptimizationMemoryUsage); + key.SetValue(nameof(AutoUpdate), AutoUpdate ? 1 : 0); + key.SetValue(nameof(CloseAfterOptimization), CloseAfterOptimization ? 1 : 0); + key.SetValue(nameof(CloseToTheNotificationArea), CloseToTheNotificationArea ? 1 : 0); + key.SetValue(nameof(CompactMode), CompactMode ? 1 : 0); + key.SetValue(nameof(CreateStartMenuShortcut), CreateStartMenuShortcut ? 1 : 0); + key.SetValue(nameof(FontSize), FontSize); + key.SetValue(nameof(Language), Language); + key.SetValue(nameof(MemoryAreas), (int)MemoryAreas); + key.SetValue(nameof(OptimizationKey), (int)OptimizationKey); + key.SetValue(nameof(OptimizationModifiers), (int)OptimizationModifiers); + key.SetValue(nameof(RunOnPriority), (int)RunOnPriority); + key.SetValue(nameof(RunOnStartup), RunOnStartup ? 1 : 0); + key.SetValue(nameof(ShowOptimizationNotifications), ShowOptimizationNotifications ? 1 : 0); + key.SetValue(nameof(ShowVirtualMemory), ShowVirtualMemory ? 1 : 0); + key.SetValue(nameof(StartMinimized), StartMinimized ? 1 : 0); + key.SetValue(nameof(TrayIconBackgroundColor), TrayIconBackgroundColor.GetHex(true)); + key.SetValue(nameof(TrayIconDangerColor), TrayIconDangerColor.GetHex(true)); + key.SetValue(nameof(TrayIconDangerLevel), TrayIconDangerLevel); + key.SetValue(nameof(TrayIconOptimizeOnMiddleMouseClick), TrayIconOptimizeOnMiddleMouseClick ? 1 : 0); + key.SetValue(nameof(TrayIconOptimizingColor), TrayIconOptimizingColor.GetHex(true)); + key.SetValue(nameof(TrayIconShowMemoryUsage), TrayIconShowMemoryUsage ? 1 : 0); + key.SetValue(nameof(TrayIconTextColor), TrayIconTextColor.GetHex(true)); + key.SetValue(nameof(TrayIconUseTransparentBackground), TrayIconUseTransparentBackground ? 1 : 0); + key.SetValue(nameof(TrayIconWarningColor), TrayIconWarningColor.GetHex(true)); + key.SetValue(nameof(TrayIconWarningLevel), TrayIconWarningLevel); + key.SetValue(nameof(UseHotkey), UseHotkey ? 1 : 0); + } } } - } - catch (Exception e) - { - Logger.Error(e); + catch (Exception e) + { + Logger.Error(e); + } } } diff --git a/src/Core/ThemeManager.cs b/src/Core/ThemeManager.cs index fd668f9c..10ad468f 100644 --- a/src/Core/ThemeManager.cs +++ b/src/Core/ThemeManager.cs @@ -12,9 +12,6 @@ namespace WinMemoryCleaner { - /// - /// Centralized theme manager that provides all theme resources with enhanced security - /// public static class ThemeManager { private const int MAX_BRUSHES_COUNT = 500; @@ -22,11 +19,11 @@ public static class ThemeManager private const int MAX_HEX_COLOR_LENGTH = 9; private const int INITIALIZATION_TIMEOUT_MS = 30000; - private static readonly Regex _hexColorPattern = new Regex(@"^#([A-Fa-f0-9]{3}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$", RegexOptions.Compiled); - private static readonly Regex _resourceKeyPattern = new Regex(@"^[a-zA-Z0-9_.]+$", RegexOptions.Compiled); + private static readonly Regex _hexColorPattern = new(@"^#([A-Fa-f0-9]{3}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$", RegexOptions.Compiled); + private static readonly Regex _resourceKeyPattern = new(@"^[a-zA-Z0-9_.]+$", RegexOptions.Compiled); - private static readonly object _lockObject = new object(); - private static readonly object _initializationLock = new object(); + private static readonly object _lockObject = new(); + private static readonly object _initializationLock = new(); private static volatile bool _isInitialized; private static volatile bool _isInitializing; private static readonly Timer _initializationTimer = InitializeTimer(); @@ -34,7 +31,7 @@ public static class ThemeManager private static Enums.Theme _theme = Enums.Theme.Dark; private static List _brushes; private static List _themes; - private static readonly Dictionary _colorCache = new Dictionary(StringComparer.Ordinal); + private static readonly Dictionary _colorCache = new(StringComparer.Ordinal); private static DateTime _lastInitializationAttempt = DateTime.MinValue; private static Timer InitializeTimer() @@ -45,13 +42,7 @@ private static Timer InitializeTimer() } catch (Exception e) { - try - { - Logger.Error("Failed to initialize timer: " + e.Message); - } - catch - { - } + try { Logger.Error("Failed to initialize timer: " + e.Message); } catch { } return null; } } @@ -243,15 +234,11 @@ private static void InitializeThemes() foreach (Enums.Theme theme in enumValues) { if (IsValidTheme(theme)) - { _themes.Add(theme); - } } if (_themes.Count == 0) - { _themes.Add(Enums.Theme.Dark); - } } catch (Exception e) { @@ -305,7 +292,7 @@ private static void InitializeBrushes() } catch (Exception e) { - var propertyName = (property != null) ? property.Name : "unknown"; + var propertyName = property?.Name ?? "unknown"; Logger.Error("Failed to process color property " + propertyName + ": " + e.Message); } } @@ -396,44 +383,29 @@ private static float GetColorBrightnessSafe(WpfBrush brush) } } - /// - /// Gets the accent color for Windows Forms controls. - /// public static WinFormsColor AccentColor { - get { return GetColorSafe(Helper.NameOf(() => AccentColor).Replace("Color", string.Empty), WinFormsColor.DeepSkyBlue); } + get => GetColorSafe(Helper.NameOf(() => AccentColor).Replace("Color", string.Empty), WinFormsColor.DeepSkyBlue); } - /// - /// Gets the primary background color for Windows Forms controls. - /// public static WinFormsColor PrimaryBackgroundColor { - get { return GetColorSafe(Helper.NameOf(() => PrimaryBackgroundColor).Replace("Color", string.Empty), WinFormsColor.FromArgb(32, 32, 32)); } + get => GetColorSafe(Helper.NameOf(() => PrimaryBackgroundColor).Replace("Color", string.Empty), WinFormsColor.FromArgb(32, 32, 32)); } - /// - /// Gets the secondary background color for Windows Forms controls. - /// public static WinFormsColor SecondaryBackgroundColor { - get { return GetColorSafe(Helper.NameOf(() => SecondaryBackgroundColor).Replace("Color", string.Empty), WinFormsColor.DarkSlateGray); } + get => GetColorSafe(Helper.NameOf(() => SecondaryBackgroundColor).Replace("Color", string.Empty), WinFormsColor.DarkSlateGray); } - - /// - /// Gets the secondary border color for Windows Forms controls. - /// + public static WinFormsColor SecondaryBorderColor { - get { return GetColorSafe(Helper.NameOf(() => SecondaryBorderColor).Replace("Color", string.Empty), WinFormsColor.DimGray); } + get => GetColorSafe(Helper.NameOf(() => SecondaryBorderColor).Replace("Color", string.Empty), WinFormsColor.DimGray); } - /// - /// Gets the secondary foreground color for Windows Forms controls. - /// public static WinFormsColor SecondaryForegroundColor { - get { return GetColorSafe(Helper.NameOf(() => SecondaryForegroundColor).Replace("Color", string.Empty), WinFormsColor.White); } + get => GetColorSafe(Helper.NameOf(() => SecondaryForegroundColor).Replace("Color", string.Empty), WinFormsColor.White); } private static WinFormsColor GetColorSafe(string resourceKey, WinFormsColor fallback) @@ -448,11 +420,8 @@ private static WinFormsColor GetColorSafe(string resourceKey, WinFormsColor fall { lock (_colorCache) { - WinFormsColor cachedColor; - if (_colorCache.TryGetValue(resourceKey, out cachedColor)) - { + if (_colorCache.TryGetValue(resourceKey, out var cachedColor)) return cachedColor; - } } EnsureInitialized(); @@ -471,9 +440,7 @@ private static WinFormsColor GetColorSafe(string resourceKey, WinFormsColor fall lock (_colorCache) { if (!_colorCache.ContainsKey(resourceKey)) - { _colorCache[resourceKey] = result; - } } return result; @@ -485,9 +452,6 @@ private static WinFormsColor GetColorSafe(string resourceKey, WinFormsColor fall } } - /// - /// Gets the brushes with defensive copying. - /// public static List Brushes { get @@ -504,25 +468,20 @@ public static List Brushes } } - /// - /// Gets or sets the theme with enhanced validation and error handling. - /// public static Enums.Theme Theme { get { EnsureInitialized(); lock (_lockObject) - { return _theme; - } } set { if (!IsValidTheme(value)) { Logger.Warning("Invalid theme value: " + value); - throw new ArgumentException("Invalid theme value: " + value, "value"); + throw new ArgumentException("Invalid theme value: " + value, nameof(value)); } EnsureInitialized(); @@ -563,9 +522,6 @@ public static Enums.Theme Theme } } - /// - /// Gets the themes with defensive copying. - /// public static List Themes { get @@ -575,9 +531,7 @@ public static List Themes { var themes = _themes; if (themes == null || themes.Count == 0) - { return new List { Enums.Theme.Dark }; - } return new List(themes); } @@ -716,10 +670,10 @@ private static void Load(Enums.Theme theme) private static WpfColor ParseHexColor(string hexColor) { if (string.IsNullOrEmpty(hexColor)) - throw new ArgumentException("Hex color cannot be null or empty", "hexColor"); + throw new ArgumentException("Hex color cannot be null or empty", nameof(hexColor)); if (!IsValidHexColor(hexColor)) - throw new ArgumentException("Invalid hex color format: " + hexColor, "hexColor"); + throw new ArgumentException("Invalid hex color format: " + hexColor, nameof(hexColor)); try { @@ -729,21 +683,17 @@ private static WpfColor ParseHexColor(string hexColor) catch (Exception e) { Logger.Error("Failed to parse hex color '" + hexColor + "': " + e.Message); - throw new ArgumentException("Invalid hex color format: " + hexColor, "hexColor", e); + throw new ArgumentException("Invalid hex color format: " + hexColor, nameof(hexColor), e); } } - /// - /// Cleanup method for proper resource disposal - /// public static void Cleanup() { try { lock (_initializationLock) { - if (_initializationTimer != null) - _initializationTimer.Dispose(); + _initializationTimer?.Dispose(); } lock (_colorCache) diff --git a/src/Core/Updater.cs b/src/Core/Updater.cs index ee598291..2293cbe8 100644 --- a/src/Core/Updater.cs +++ b/src/Core/Updater.cs @@ -1,160 +1,112 @@ ๏ปฟusing System; -using System.ComponentModel; using System.Diagnostics; using System.Globalization; using System.IO; -using System.Net; +using System.Net.Http; using System.Reflection; +using System.Text.Json; using System.Text.RegularExpressions; +using System.Threading.Tasks; namespace WinMemoryCleaner { - /// - /// Updater - /// public static class Updater { - private static WebClient _client; + private static readonly HttpClient _httpClient = new() { Timeout = TimeSpan.FromSeconds(30) }; private static DateTimeOffset _lastCheck = DateTimeOffset.MinValue; + private static ProcessStartInfo _process; - internal static ProcessStartInfo Process; + public static ProcessStartInfo Process => _process; - private static void OnFileDownloadCompleted(object sender, AsyncCompletedEventArgs e) + public static async void Update(params string[] args) { try { - if (e.Error != null) - throw new Exception("File download failed.", e.Error); - - if (e.Cancelled) + if (!Settings.AutoUpdate || DateTimeOffset.Now.Subtract(_lastCheck).TotalHours < Constants.App.AutoUpdateInterval) return; - var updateInfo = (Tuple)e.UserState; - var temp = updateInfo.Item1; - var path = updateInfo.Item2; - var exe = updateInfo.Item3; - var newestVersion = updateInfo.Item4; - var args = updateInfo.Item5; - - if (File.Exists(temp) && AssemblyName.GetAssemblyName(temp).Version.Equals(newestVersion)) - { - Process = new ProcessStartInfo - { - Arguments = string.Format(CultureInfo.InvariantCulture, @"/c taskkill /f /im ""{0}"" & move /y ""{1}"" ""{2}"" & start """" ""{2}"" /{3} {4}", exe, temp, path, newestVersion, string.Join(" ", args)), - CreateNoWindow = true, - FileName = "cmd", - RedirectStandardError = false, - RedirectStandardInput = false, - RedirectStandardOutput = false, - UseShellExecute = false, - WindowStyle = ProcessWindowStyle.Hidden - }; - - App.Shutdown(); - } - } - catch (Exception ex) - { - Logger.Error(ex); - - Reset(); - } - } - - private static void OnVersionCheckCompleted(object sender, DownloadStringCompletedEventArgs e) - { - try - { - if (e.Error != null) - throw new Exception("Version check failed.", e.Error); + _lastCheck = DateTimeOffset.Now; + _process = null; - if (e.Cancelled) - return; + var currentVersion = App.Version; - var assemblyInfo = e.Result; - var assemblyVersionMatch = Regex.Match(assemblyInfo, @"AssemblyVersion\(""(.*)""\)\]"); + // Check for updates via GitHub API + var response = await _httpClient.GetStringAsync(Constants.App.Repository.ApiLatestReleaseUri); + using var doc = JsonDocument.Parse(response); + var tagName = doc.RootElement.GetProperty("tag_name").GetString()?.TrimStart('v'); - if (!assemblyVersionMatch.Success) + if (string.IsNullOrEmpty(tagName) || !Version.TryParse(tagName, out var newestVersion)) return; - var newestVersion = Version.Parse(assemblyVersionMatch.Groups[1].Value); - - if (App.Version >= newestVersion) - { - Reset(); + if (currentVersion >= newestVersion) return; - } + // Download the new version var exe = Path.GetFileName(App.Path); - var temp = Path.Combine(Path.GetTempPath(), exe); + var temp = Path.Combine(Path.GetTempPath(), $"{Path.GetRandomFileName()}.exe"); Helper.DeleteFile(temp); - var updateInfo = Tuple.Create(temp, App.Path, exe, newestVersion, (string[])e.UserState); + var fileBytes = await _httpClient.GetByteArrayAsync(Constants.App.Repository.LatestExeUri); + await File.WriteAllBytesAsync(temp, fileBytes); - _client.DownloadFileAsync(Constants.App.Repository.LatestExeUri, temp, updateInfo); + // Verify the downloaded file + if (File.Exists(temp)) + { + try + { + var downloadedVersion = AssemblyName.GetAssemblyName(temp).Version; + if (downloadedVersion != null && downloadedVersion.Equals(newestVersion)) + { + _process = new ProcessStartInfo + { + Arguments = string.Format(CultureInfo.InvariantCulture, @"/c taskkill /f /im ""{0}"" & move /y ""{1}"" ""{2}"" & start """" ""{2}"" /{3} {4}", exe, temp, App.Path, newestVersion, string.Join(" ", args)), + CreateNoWindow = true, + FileName = "cmd", + RedirectStandardError = false, + RedirectStandardInput = false, + RedirectStandardOutput = false, + UseShellExecute = false, + WindowStyle = ProcessWindowStyle.Hidden + }; + + App.Shutdown(); + } + } + catch (Exception ex) + { + Logger.Error("Failed to verify downloaded update: " + ex.GetMessage()); + } + } } catch (Exception ex) { Logger.Error(ex); - - Reset(); } } - private static void Reset() + public static async Task CheckForUpdatesAsync() { try { - if (_client != null) - _client.Dispose(); - } - finally - { - _client = null; - } + var response = await _httpClient.GetStringAsync(Constants.App.Repository.ApiLatestReleaseUri); + using var doc = JsonDocument.Parse(response); + var tagName = doc.RootElement.GetProperty("tag_name").GetString()?.TrimStart('v'); - try - { - if (Process != null) - Process = null; + if (!string.IsNullOrEmpty(tagName) && Version.TryParse(tagName, out var version)) + return version; } - catch + catch (Exception ex) { - // ignored + Logger.Error(ex); } + + return null; } - /// - /// Check for new version and update if available - /// - public static void Update(params string[] args) + public static void Dispose() { - try - { - if (Settings.AutoUpdate && DateTimeOffset.Now.Subtract(_lastCheck).TotalHours < Constants.App.AutoUpdateInterval) - return; - - _lastCheck = DateTimeOffset.Now; - - Reset(); - - _client = new WebClient(); - _client.DownloadFileCompleted += new AsyncCompletedEventHandler(OnFileDownloadCompleted); - _client.DownloadStringCompleted += new DownloadStringCompletedEventHandler(OnVersionCheckCompleted); - - ServicePointManager.DefaultConnectionLimit = 10; - ServicePointManager.Expect100Continue = true; - ServicePointManager.SecurityProtocol |= (SecurityProtocolType)3072 | (SecurityProtocolType)12288; // TLS 1.2 | TLS 1.3 - - _client.DownloadStringAsync(Constants.App.Repository.AssemblyInfoUri, args); - } - catch (Exception ex) - { - Logger.Error(ex); - - Reset(); - } + _httpClient?.Dispose(); } } } \ No newline at end of file diff --git a/src/Interop/NativeMethods.cs b/src/Interop/NativeMethods.cs index 104de741..de429fde 100644 --- a/src/Interop/NativeMethods.cs +++ b/src/Interop/NativeMethods.cs @@ -2,16 +2,15 @@ using System; using System.IO; using System.Runtime.InteropServices; +using System.Runtime.Versioning; using System.Security; namespace WinMemoryCleaner { - /// - /// Windows API - /// + [SupportedOSPlatform("windows")] internal static class NativeMethods { - [DllImport("advapi32.dll", SetLastError = true)] + [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)] [return: MarshalAs(UnmanagedType.Bool)] internal static extern bool AdjustTokenPrivileges(IntPtr tokenHandle, [MarshalAs(UnmanagedType.Bool)] bool disableAllPrivileges, ref Structs.Windows.TokenPrivileges newState, int bufferLength, IntPtr previousState, IntPtr returnLength); @@ -25,7 +24,7 @@ internal static class NativeMethods [SuppressUnmanagedCodeSecurity] [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)] - internal static extern SafeFileHandle CreateFile([MarshalAs(UnmanagedType.LPWStr)] string lpFileName, FileAccess dwDesiredAccess, FileShare dwShareMode, IntPtr lpSecurityAttributes, FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile); + internal static extern SafeFileHandle CreateFile(string lpFileName, FileAccess dwDesiredAccess, FileShare dwShareMode, IntPtr lpSecurityAttributes, FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile); [DllImport("user32.dll", SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] @@ -37,14 +36,14 @@ internal static class NativeMethods internal static extern bool DeviceIoControl(SafeFileHandle hDevice, int dwIoControlCode, IntPtr lpInBuffer, int nInBufferSize, IntPtr lpOutBuffer, int nOutBufferSize, out int lpBytesReturned, IntPtr lpOverlapped); [DllImport("dwmapi.dll", SetLastError = true)] - internal static extern void DwmSetWindowAttribute(IntPtr hWnd, int attribute, ref int value, int size); + internal static extern int DwmSetWindowAttribute(IntPtr hWnd, int attribute, ref int value, int size); [SuppressUnmanagedCodeSecurity] [DllImport("psapi.dll", SetLastError = true)] [return: MarshalAs(UnmanagedType.Bool)] internal static extern bool EmptyWorkingSet(IntPtr hProcess); - [DllImport("user32", SetLastError = true, CharSet = CharSet.Unicode)] + [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)] internal static extern IntPtr FindWindow(string lpClassName, string lpWindowName); [SuppressUnmanagedCodeSecurity] @@ -94,4 +93,4 @@ internal static class NativeMethods [return: MarshalAs(UnmanagedType.Bool)] internal static extern bool UnregisterHotKey(IntPtr hWnd, int id); } -} +} \ No newline at end of file diff --git a/src/Interop/ShellInterop.cs b/src/Interop/ShellInterop.cs index 1fe7f842..d7c4d924 100644 --- a/src/Interop/ShellInterop.cs +++ b/src/Interop/ShellInterop.cs @@ -46,6 +46,20 @@ internal interface IShellLink void SetPath([MarshalAs(UnmanagedType.LPWStr)] string pszFile); } + [ComImport] + [Guid("0000010B-0000-0000-C000-000000000046")] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + internal interface IPersistFile + { + void GetClassID(out Guid pClassID); + [PreserveSig] + int IsDirty(); + void Load([MarshalAs(UnmanagedType.LPWStr)] string pszFileName, int dwMode); + void Save([MarshalAs(UnmanagedType.LPWStr)] string pszFileName, [MarshalAs(UnmanagedType.Bool)] bool fRemember); + void SaveCompleted([MarshalAs(UnmanagedType.LPWStr)] string pszFileName); + void GetCurFile([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder ppszFileName); + } + #endregion } } \ No newline at end of file diff --git a/src/Model/Localization.cs b/src/Model/Localization.cs index 0c10bffb..993be9fe 100644 --- a/src/Model/Localization.cs +++ b/src/Model/Localization.cs @@ -42,511 +42,511 @@ public class Localization public string About { get { return _about; } - private set { _about = value.Capitalize(); } + set { _about = value; } } [DataMember] public string Add { get { return _add; } - private set { _add = value.Capitalize(); } + set { _add = value.Capitalize(); } } [DataMember] public string AlwaysOnTop { get { return _alwaysOnTop; } - private set { _alwaysOnTop = value.Capitalize(); } + set { _alwaysOnTop = value.Capitalize(); } } [DataMember] public string AutoOptimization { get { return _autoOptimization; } - private set { _autoOptimization = value.Capitalize(); } + set { _autoOptimization = value.Capitalize(); } } [DataMember] public string AutoOptimizationInterval { get { return _autoOptimizationInterval; } - private set { _autoOptimizationInterval = value.Capitalize(); } + set { _autoOptimizationInterval = value.Capitalize(); } } [DataMember] public string AutoUpdate { get { return _autoUpdate; } - private set { _autoUpdate = value.Capitalize(); } + set { _autoUpdate = value.Capitalize(); } } [DataMember] public string Background { get { return _background; } - private set { _background = value.Capitalize(); } + set { _background = value.Capitalize(); } } [DataMember] public string Close { get { return _close; } - private set { _close = value.Capitalize(); } + set { _close = value.Capitalize(); } } [DataMember] public string CloseAfterOptimization { get { return _closeAfterOptimization; } - private set { _closeAfterOptimization = value.Capitalize(); } + set { _closeAfterOptimization = value.Capitalize(); } } [DataMember] public string CloseToTheNotificationArea { get { return _closeToTheNotificationArea; } - private set { _closeToTheNotificationArea = value.Capitalize(); } + set { _closeToTheNotificationArea = value.Capitalize(); } } [DataMember] public string Collapse { get { return _collapse; } - private set { _collapse = value.Capitalize(); } + set { _collapse = value.Capitalize(); } } [DataMember] public string CombinedPageList { get { return _combinedPageList; } - private set { _combinedPageList = value.Capitalize(); } + set { _combinedPageList = value.Capitalize(); } } [DataMember] public string CreateStartMenuShortcut { get { return _createStartMenuShortcut; } - private set { _createStartMenuShortcut = value.Capitalize(); } + set { _createStartMenuShortcut = value.Capitalize(); } } [DataMember] public string DangerLevel { get { return _dangerLevel; } - private set { _dangerLevel = value.Capitalize(); } + set { _dangerLevel = value.Capitalize(); } } [DataMember] public string Donate { get { return _donate; } - private set { _donate = value.Capitalize(); } + set { _donate = value.Capitalize(); } } [DataMember] public string DonationMessage { get { return _donationMessage; } - private set { _donationMessage = value.Capitalize(); } + set { _donationMessage = value.Capitalize(); } } [DataMember] public string DonationTitle { get { return _donationTitle; } - private set { _donationTitle = value.Capitalize(); } + set { _donationTitle = value.Capitalize(); } } [DataMember] public string Error { get { return _error; } - private set { _error = value.Capitalize(); } + set { _error = value.Capitalize(); } } [DataMember] public string ErrorAdminPrivilegeRequired { get { return _errorAdminPrivilegeRequired; } - private set { _errorAdminPrivilegeRequired = value.Capitalize(); } + set { _errorAdminPrivilegeRequired = value.Capitalize(); } } [DataMember] public string ErrorCanNotSaveLog { get { return _errorCanNotSaveLog; } - private set { _errorCanNotSaveLog = value.Capitalize(); } + set { _errorCanNotSaveLog = value.Capitalize(); } } [DataMember] public string ErrorMemoryAreaOptimizationNotSupported { get { return _errorMemoryAreaOptimizationNotSupported; } - private set { _errorMemoryAreaOptimizationNotSupported = value.Capitalize(); } + set { _errorMemoryAreaOptimizationNotSupported = value.Capitalize(); } } [DataMember] public string ErrorResetCommand { get { return _errorResetCommand; } - private set { _errorResetCommand = value.Capitalize(); } + set { _errorResetCommand = value.Capitalize(); } } [DataMember] public string EveryHour { get { return _everyHour; } - private set { _everyHour = value.Capitalize(); } + set { _everyHour = value.Capitalize(); } } [DataMember] public string Exit { get { return _exit; } - private set { _exit = value.Capitalize(); } + set { _exit = value.Capitalize(); } } [DataMember] public string Expand { get { return _expand; } - private set { _expand = value.Capitalize(); } + set { _expand = value.Capitalize(); } } [DataMember] public string Free { get { return _free; } - private set { _free = value.Capitalize(); } + set { _free = value.Capitalize(); } } [DataMember] public string GarbageCollector { get { return _garbageCollector; } - private set { _garbageCollector = value.Capitalize(); } + set { _garbageCollector = value.Capitalize(); } } [DataMember] public string Help { get { return _help; } - private set { _help = value.Capitalize(); } + set { _help = value.Capitalize(); } } [DataMember] public string HotkeyIsInUseByOperatingSystem { get { return _hotkeyIsInUseByOperatingSystem; } - private set { _hotkeyIsInUseByOperatingSystem = value.Capitalize(); } + set { _hotkeyIsInUseByOperatingSystem = value.Capitalize(); } } [DataMember] public string Invalid { get { return _invalid; } - private set { _invalid = value.Capitalize(); } + set { _invalid = value.Capitalize(); } } [DataMember] public string LowMemory { get { return _lowMemory; } - private set { _lowMemory = value.Capitalize(); } + set { _lowMemory = value.Capitalize(); } } [DataMember] public string Manual { get { return _manual; } - private set { _manual = value.Capitalize(); } + set { _manual = value.Capitalize(); } } [DataMember] public string MemoryAreas { get { return _memoryAreas; } - private set { _memoryAreas = value.Capitalize(); } + set { _memoryAreas = value.Capitalize(); } } [DataMember] public string MemoryOptimized { get { return _memoryOptimized; } - private set { _memoryOptimized = value.Capitalize(); } + set { _memoryOptimized = value.Capitalize(); } } [DataMember] public string MemoryUsage { get { return _memoryUsage; } - private set { _memoryUsage = value.Capitalize(); } + set { _memoryUsage = value.Capitalize(); } } [DataMember] public string Minimize { get { return _minimize; } - private set { _minimize = value.Capitalize(); } + set { _minimize = value.Capitalize(); } } [DataMember] public string ModifiedFileCache { get { return _modifiedFileCache; } - private set { _modifiedFileCache = value.Capitalize(); } + set { _modifiedFileCache = value.Capitalize(); } } [DataMember] public string ModifiedPageList { get { return _modifiedPageList; } - private set { _modifiedPageList = value.Capitalize(); } + set { _modifiedPageList = value.Capitalize(); } } [DataMember] public string No { get { return _no; } - private set { _no = value.Capitalize(); } + set { _no = value.Capitalize(); } } [DataMember] public string OptimizationHotkey { get { return _optimizationHotkey; } - private set { _optimizationHotkey = value.Capitalize(); } + set { _optimizationHotkey = value.Capitalize(); } } [DataMember] public string Optimize { get { return _optimize; } - private set { _optimize = value.Capitalize(); } + set { _optimize = value.Capitalize(); } } [DataMember] public string OptimizeOnMiddleMouseClick { get { return _optimizeOnMiddleMouseClick; } - private set { _optimizeOnMiddleMouseClick = value.Capitalize(); } + set { _optimizeOnMiddleMouseClick = value.Capitalize(); } } [DataMember] public string Optimizing { get { return _optimizing; } - private set { _optimizing = value.Capitalize(); } + set { _optimizing = value.Capitalize(); } } [DataMember] public string PhysicalMemory { get { return _physicalMemory; } - private set { _physicalMemory = value.Capitalize(); } + set { _physicalMemory = value.Capitalize(); } } [DataMember] public string ProcessExclusionList { get { return _processExclusionList; } - private set { _processExclusionList = value.Capitalize(); } + set { _processExclusionList = value.Capitalize(); } } [DataMember] public string Reason { get { return _reason; } - private set { _reason = value.Capitalize(); } + set { _reason = value.Capitalize(); } } [DataMember] public string RegistryCache { get { return _registryCache; } - private set { _registryCache = value.Capitalize(); } + set { _registryCache = value.Capitalize(); } } [DataMember] public string Remove { get { return _remove; } - private set { _remove = value.Capitalize(); } + set { _remove = value.Capitalize(); } } [DataMember] public string Reset { get { return _reset; } - private set { _reset = value.Capitalize(); } + set { _reset = value.Capitalize(); } } [DataMember] public string ResetCommand { get { return _resetCommand; } - private set { _resetCommand = value.Capitalize(); } + set { _resetCommand = value.Capitalize(); } } [DataMember] public string ResetConfirmation { get { return _resetConfirmation; } - private set { _resetConfirmation = value.Capitalize(); } + set { _resetConfirmation = value.Capitalize(); } } [DataMember] public string RunOnLowPriority { get { return _runOnLowPriority; } - private set { _runOnLowPriority = value.Capitalize(); } + set { _runOnLowPriority = value.Capitalize(); } } [DataMember] public string RunOnStartup { get { return _runOnStartup; } - private set { _runOnStartup = value.Capitalize(); } + set { _runOnStartup = value.Capitalize(); } } [DataMember] public string Schedule { get { return _schedule; } - private set { _schedule = value.Capitalize(); } + set { _schedule = value.Capitalize(); } } [DataMember] public string Seconds { get { return _seconds; } - private set { _seconds = value.Capitalize(); } + set { _seconds = value.Capitalize(); } } [DataMember] public string Settings { get { return _settings; } - private set { _settings = value.Capitalize(); } + set { _settings = value.Capitalize(); } } [DataMember] public string ShowMemoryUsage { get { return _showMemoryUsage; } - private set { _showMemoryUsage = value.Capitalize(); } + set { _showMemoryUsage = value.Capitalize(); } } [DataMember] public string ShowOptimizationNotifications { get { return _showOptimizationNotifications; } - private set { _showOptimizationNotifications = value.Capitalize(); } + set { _showOptimizationNotifications = value.Capitalize(); } } [DataMember] public string ShowVirtualMemory { get { return _showVirtualMemory; } - private set { _showVirtualMemory = value.Capitalize(); } + set { _showVirtualMemory = value.Capitalize(); } } [DataMember] public string StandbyList { get { return _standbyList; } - private set { _standbyList = value.Capitalize(); } + set { _standbyList = value.Capitalize(); } } [DataMember] public string StandbyListLowPriority { get { return _standbyListLowPriority; } - private set { _standbyListLowPriority = value.Capitalize(); } + set { _standbyListLowPriority = value.Capitalize(); } } [DataMember] public string StartMinimized { get { return _startMinimized; } - private set { _startMinimized = value.Capitalize(); } + set { _startMinimized = value.Capitalize(); } } [DataMember] public string SystemFileCache { get { return _systemFileCache; } - private set { _systemFileCache = value.Capitalize(); } + set { _systemFileCache = value.Capitalize(); } } [DataMember] public string Text { get { return _text; } - private set { _text = value.Capitalize(); } + set { _text = value.Capitalize(); } } [DataMember] public string TrayIcon { get { return _trayIcon; } - private set { _trayIcon = value.Capitalize(); } + set { _trayIcon = value.Capitalize(); } } [DataMember] public string UpdatedToVersion { get { return _updatedToVersion; } - private set { _updatedToVersion = value.Capitalize(); } + set { _updatedToVersion = value.Capitalize(); } } [DataMember] public string UseTransparentBackground { get { return _useTransparentBackground; } - private set { _useTransparentBackground = value.Capitalize(); } + set { _useTransparentBackground = value.Capitalize(); } } [DataMember] public string Used { get { return _used; } - private set { _used = value.Capitalize(); } + set { _used = value.Capitalize(); } } [DataMember] public string VirtualMemory { get { return _virtualMemory; } - private set { _virtualMemory = value.Capitalize(); } + set { _virtualMemory = value.Capitalize(); } } [DataMember] public string WhenFreePhysicalMemoryIsBelow { get { return _whenFreePhysicalMemoryIsBelow; } - private set { _whenFreePhysicalMemoryIsBelow = value.Capitalize(); } + set { _whenFreePhysicalMemoryIsBelow = value.Capitalize(); } } [DataMember] public string WarningLevel { get { return _warningLevel; } - private set { _warningLevel = value.Capitalize(); } + set { _warningLevel = value.Capitalize(); } } [DataMember] public string WorkingSet { get { return _workingSet; } - private set { _workingSet = value.Capitalize(); } + set { _workingSet = value.Capitalize(); } } [DataMember] public string Yes { get { return _yes; } - private set { _yes = value.Capitalize(); } + set { _yes = value.Capitalize(); } } #endregion diff --git a/src/Properties/AssemblyInfo.cs b/src/Properties/AssemblyInfo.cs index 5f84a4e1..2a0ba0cb 100644 --- a/src/Properties/AssemblyInfo.cs +++ b/src/Properties/AssemblyInfo.cs @@ -11,7 +11,7 @@ [assembly: AssemblyKeyFile(Constants.App.KeyFile)] [assembly: AssemblyProduct(Constants.App.Name)] [assembly: AssemblyTitle(Constants.App.Title)] -[assembly: AssemblyVersion("3.0.8.0")] +[assembly: AssemblyVersion("3.1.0.0")] [assembly: ComVisible(false)] [assembly: CLSCompliant(true)] [assembly: Guid(Constants.App.Id)] diff --git a/src/Service/ComputerService.cs b/src/Service/ComputerService.cs index a4ca5319..d83eeee2 100644 --- a/src/Service/ComputerService.cs +++ b/src/Service/ComputerService.cs @@ -64,10 +64,10 @@ public OperatingSystem OperatingSystem { Is64Bit = Environment.Is64BitOperatingSystem, IsWindows7OrGreater = (operatingSystem.Version.Major > 6) || (operatingSystem.Version.Major == 6 && operatingSystem.Version.Minor >= 1), - IsWindows8OrGreater = operatingSystem.Version.Major >= 6.2, - IsWindows81OrGreater = operatingSystem.Version.Major >= 6.3, + IsWindows8OrGreater = (operatingSystem.Version.Major > 6) || (operatingSystem.Version.Major == 6 && operatingSystem.Version.Minor >= 2), + IsWindows81OrGreater = (operatingSystem.Version.Major > 6) || (operatingSystem.Version.Major == 6 && operatingSystem.Version.Minor >= 3), IsWindowsVistaOrGreater = operatingSystem.Version.Major >= 6, - IsWindowsXpOrGreater = operatingSystem.Version.Major >= 5.1 + IsWindowsXpOrGreater = (operatingSystem.Version.Major > 5) || (operatingSystem.Version.Major == 5 && operatingSystem.Version.Minor >= 1) }; } @@ -135,6 +135,22 @@ private bool SetIncreasePrivilege(string privilegeName) return result; } + private static IntPtr AllocStruct(object obj) + { + var size = Marshal.SizeOf(obj); + var ptr = Marshal.AllocHGlobal(size); + try + { + Marshal.StructureToPtr(obj, ptr, false); + } + catch + { + Marshal.FreeHGlobal(ptr); + throw; + } + return ptr; + } + #endregion #region Methods (Memory) @@ -466,28 +482,17 @@ private void OptimizeCombinedPageList() if (!SetIncreasePrivilege(Constants.Windows.Privilege.SeProfSingleProcessName)) throw new Exception(string.Format(Localizer.Culture, Localizer.String.ErrorAdminPrivilegeRequired, Constants.Windows.Privilege.SeProfSingleProcessName)); - var handle = GCHandle.Alloc(0); + var memoryCombineInformationEx = new Structs.Windows.MemoryCombineInformationEx(); + var ptr = AllocStruct(memoryCombineInformationEx); try { - var memoryCombineInformationEx = new Structs.Windows.MemoryCombineInformationEx(); - - handle = GCHandle.Alloc(memoryCombineInformationEx, GCHandleType.Pinned); - - if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemCombinePhysicalMemoryInformation, handle.AddrOfPinnedObject(), (uint)Marshal.SizeOf(memoryCombineInformationEx)) != Constants.Windows.SystemErrorCode.ErrorSuccess) + if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemCombinePhysicalMemoryInformation, ptr, (uint)Marshal.SizeOf(memoryCombineInformationEx)) != Constants.Windows.SystemErrorCode.ErrorSuccess) throw new Win32Exception(Marshal.GetLastWin32Error()); } finally { - try - { - if (handle.IsAllocated) - handle.Free(); - } - catch (InvalidOperationException) - { - // ignored - } + Marshal.FreeHGlobal(ptr); } } @@ -586,24 +591,17 @@ private void OptimizeModifiedPageList() if (!SetIncreasePrivilege(Constants.Windows.Privilege.SeProfSingleProcessName)) throw new Exception(string.Format(Localizer.Culture, Localizer.String.ErrorAdminPrivilegeRequired, Constants.Windows.Privilege.SeProfSingleProcessName)); - var handle = GCHandle.Alloc(Constants.Windows.SystemMemoryListCommand.MemoryFlushModifiedList, GCHandleType.Pinned); + var command = Constants.Windows.SystemMemoryListCommand.MemoryFlushModifiedList; + var ptr = AllocStruct(command); try { - if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemMemoryListInformation, handle.AddrOfPinnedObject(), (uint)Marshal.SizeOf(Constants.Windows.SystemMemoryListCommand.MemoryFlushModifiedList)) != Constants.Windows.SystemErrorCode.ErrorSuccess) + if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemMemoryListInformation, ptr, (uint)Marshal.SizeOf(command)) != Constants.Windows.SystemErrorCode.ErrorSuccess) throw new Win32Exception(Marshal.GetLastWin32Error()); } finally { - try - { - if (handle.IsAllocated) - handle.Free(); - } - catch (InvalidOperationException) - { - // ignored - } + Marshal.FreeHGlobal(ptr); } } @@ -635,24 +633,16 @@ private void OptimizeStandbyList(bool lowPriority = false) throw new Exception(string.Format(Localizer.Culture, Localizer.String.ErrorAdminPrivilegeRequired, Constants.Windows.Privilege.SeProfSingleProcessName)); object memoryPurgeStandbyList = lowPriority ? Constants.Windows.SystemMemoryListCommand.MemoryPurgeLowPriorityStandbyList : Constants.Windows.SystemMemoryListCommand.MemoryPurgeStandbyList; - var handle = GCHandle.Alloc(memoryPurgeStandbyList, GCHandleType.Pinned); + var ptr = AllocStruct(memoryPurgeStandbyList); try { - if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemMemoryListInformation, handle.AddrOfPinnedObject(), (uint)Marshal.SizeOf(memoryPurgeStandbyList)) != Constants.Windows.SystemErrorCode.ErrorSuccess) + if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemMemoryListInformation, ptr, (uint)Marshal.SizeOf(memoryPurgeStandbyList)) != Constants.Windows.SystemErrorCode.ErrorSuccess) throw new Win32Exception(Marshal.GetLastWin32Error()); } finally { - try - { - if (handle.IsAllocated) - handle.Free(); - } - catch (InvalidOperationException) - { - // ignored - } + Marshal.FreeHGlobal(ptr); } } @@ -669,33 +659,23 @@ private void OptimizeSystemFileCache() if (!SetIncreasePrivilege(Constants.Windows.Privilege.SeIncreaseQuotaName)) throw new Exception(string.Format(Localizer.Culture, Localizer.String.ErrorAdminPrivilegeRequired, Constants.Windows.Privilege.SeIncreaseQuotaName)); - var handle = GCHandle.Alloc(0); + object systemFileCacheInformation; - try - { - object systemFileCacheInformation; - - if (OperatingSystem.Is64Bit) - systemFileCacheInformation = new Structs.Windows.SystemFileCacheInformation64 { MinimumWorkingSet = -1L, MaximumWorkingSet = -1L }; - else - systemFileCacheInformation = new Structs.Windows.SystemFileCacheInformation32 { MinimumWorkingSet = int.MaxValue, MaximumWorkingSet = int.MaxValue }; + if (OperatingSystem.Is64Bit) + systemFileCacheInformation = new Structs.Windows.SystemFileCacheInformation64 { MinimumWorkingSet = -1L, MaximumWorkingSet = -1L }; + else + systemFileCacheInformation = new Structs.Windows.SystemFileCacheInformation32 { MinimumWorkingSet = int.MaxValue, MaximumWorkingSet = int.MaxValue }; - handle = GCHandle.Alloc(systemFileCacheInformation, GCHandleType.Pinned); + var ptr = AllocStruct(systemFileCacheInformation); - if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemFileCacheInformation, handle.AddrOfPinnedObject(), (uint)Marshal.SizeOf(systemFileCacheInformation)) != Constants.Windows.SystemErrorCode.ErrorSuccess) + try + { + if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemFileCacheInformation, ptr, (uint)Marshal.SizeOf(systemFileCacheInformation)) != Constants.Windows.SystemErrorCode.ErrorSuccess) throw new Win32Exception(Marshal.GetLastWin32Error()); } finally { - try - { - if (handle.IsAllocated) - handle.Free(); - } - catch (InvalidOperationException) - { - // ignored - } + Marshal.FreeHGlobal(ptr); } var fileCacheSize = IntPtr.Subtract(IntPtr.Zero, 1); // Flush @@ -721,7 +701,7 @@ private void OptimizeWorkingSet() if (!SetIncreasePrivilege(Constants.Windows.Privilege.SeDebugName)) throw new Exception(string.Format(Localizer.Culture, Localizer.String.ErrorAdminPrivilegeRequired, Constants.Windows.Privilege.SeDebugName)); - var processes = Process.GetProcesses().Where(process => process != null && !Settings.ProcessExclusionList.Contains(process.ProcessName, StringComparer.OrdinalIgnoreCase)); + var processes = Process.GetProcesses().Where(process => process != null && !Settings.IsProcessExcluded(process.ProcessName)); foreach (var process in processes) { @@ -753,11 +733,12 @@ private void OptimizeWorkingSet() if (!SetIncreasePrivilege(Constants.Windows.Privilege.SeProfSingleProcessName)) throw new Exception(string.Format(Localizer.Culture, Localizer.String.ErrorAdminPrivilegeRequired, Constants.Windows.Privilege.SeDebugName)); - var handle = GCHandle.Alloc(Constants.Windows.SystemMemoryListCommand.MemoryEmptyWorkingSets, GCHandleType.Pinned); + var command = Constants.Windows.SystemMemoryListCommand.MemoryEmptyWorkingSets; + var ptr = AllocStruct(command); try { - if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemMemoryListInformation, handle.AddrOfPinnedObject(), (uint)Marshal.SizeOf(Constants.Windows.SystemMemoryListCommand.MemoryEmptyWorkingSets)) != Constants.Windows.SystemErrorCode.ErrorSuccess) + if (NativeMethods.NtSetSystemInformation(Constants.Windows.SystemInformationClass.SystemMemoryListInformation, ptr, (uint)Marshal.SizeOf(command)) != Constants.Windows.SystemErrorCode.ErrorSuccess) { var e = new Win32Exception(Marshal.GetLastWin32Error()); @@ -772,15 +753,7 @@ private void OptimizeWorkingSet() } finally { - try - { - if (handle.IsAllocated) - handle.Free(); - } - catch (InvalidOperationException) - { - // ignored - } + Marshal.FreeHGlobal(ptr); } } @@ -790,4 +763,4 @@ private void OptimizeWorkingSet() #endregion } -} +} \ No newline at end of file diff --git a/src/Service/HotKeyService.cs b/src/Service/HotKeyService.cs index 7b560468..6cb7eea0 100644 --- a/src/Service/HotKeyService.cs +++ b/src/Service/HotKeyService.cs @@ -1,4 +1,5 @@ ๏ปฟusing System; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Linq; using System.Text.RegularExpressions; @@ -16,7 +17,7 @@ public class HotkeyService : IHotkeyService #region Fields private readonly bool _isSupported = Environment.OSVersion.Version.Major >= 6; // Minimum supported Windows Vista / Server 2003 - private readonly Dictionary _registered = new Dictionary(); + private readonly ConcurrentDictionary _registered = new ConcurrentDictionary(); #endregion @@ -174,8 +175,8 @@ public bool Register(Hotkey hotkey, Action action) result = NativeMethods.RegisterHotKey(IntPtr.Zero, hotkey.GetHashCode(), (uint)hotkey.Modifiers, (uint)KeyInterop.VirtualKeyFromKey(hotkey.Key)); - if (!_registered.ContainsKey(hotkey)) - _registered.Add(hotkey, action); + if (result) + _registered.TryAdd(hotkey, action); } catch { @@ -201,7 +202,7 @@ public bool Unregister(Hotkey hotkey) result = NativeMethods.UnregisterHotKey(IntPtr.Zero, hotkey.GetHashCode()); - _registered.Remove(hotkey); + _registered.TryRemove(hotkey, out _); } catch { diff --git a/src/Test/CommandTests.cs b/src/Test/CommandTests.cs deleted file mode 100644 index 117362ea..00000000 --- a/src/Test/CommandTests.cs +++ /dev/null @@ -1,165 +0,0 @@ -using System; -using NUnit.Framework; - -#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member - -namespace WinMemoryCleaner.Test -{ - /// - /// Unit tests for Command classes - /// - [TestFixture] - public sealed class CommandTests - { - #region RelayCommand Tests - - [TestFixture] - public class RelayCommandTests - { - [Test] - public void CanExecute_WithNoCanExecuteFunc_ReturnsTrue() - { - var command = new RelayCommand(() => { }); - var result = command.CanExecute(null); - - Assert.IsTrue(result); - } - - [Test] - public void CanExecute_WithTrueFunc_ReturnsTrue() - { - var command = new RelayCommand(() => { }, () => true); - var result = command.CanExecute(null); - - Assert.IsTrue(result); - } - - [Test] - public void CanExecute_WithFalseFunc_ReturnsFalse() - { - var command = new RelayCommand(() => { }, () => false); - var result = command.CanExecute(null); - - Assert.IsFalse(result); - } - - [Test] - public void CanExecuteChanged_AddAndRemoveHandlers_DoesNotThrow() - { - var command = new RelayCommand(() => { }); - EventHandler handler = (sender, e) => { }; - - command.CanExecuteChanged += handler; - command.CanExecuteChanged -= handler; - } - - [Test] - public void Constructor_WithAction_DoesNotThrow() - { - var unused = new RelayCommand(() => { }); - } - - [Test] - public void Execute_InvokesAction() - { - var executed = false; - var command = new RelayCommand(() => executed = true); - - command.Execute(null); - - Assert.IsTrue(executed); - } - - [Test] - public void Execute_MultipleTimes_InvokesMultipleTimes() - { - var count = 0; - var command = new RelayCommand(() => count++); - - command.Execute(null); - command.Execute(null); - command.Execute(null); - - Assert.AreEqual(3, count); - } - } - - #endregion - - #region RelayCommand Tests - - [TestFixture] - public class RelayCommandGenericTests - { - [Test] - public void CanExecute_WithNoCanExecuteFunc_ReturnsTrue() - { - var command = new RelayCommand(_ => { }); - var result = command.CanExecute(42); - - Assert.IsTrue(result); - } - - [Test] - public void CanExecute_WithTrueFunc_ReturnsTrue() - { - var command = new RelayCommand(_ => { }, () => true); - var result = command.CanExecute(42); - - Assert.IsTrue(result); - } - - [Test] - public void CanExecute_WithFalseFunc_ReturnsFalse() - { - var command = new RelayCommand(_ => { }, () => false); - var result = command.CanExecute(42); - - Assert.IsFalse(result); - } - - [Test] - public void Constructor_WithAction_DoesNotThrow() - { - var unused = new RelayCommand(_ => { }); - } - - [Test] - public void Execute_InvokesActionWithParameter() - { - string result = null; - var command = new RelayCommand(param => result = param); - - command.Execute("test"); - - Assert.AreEqual("test", result); - } - - [Test] - public void Execute_WithComplexType_InvokesCorrectly() - { - TestObject receivedObject = null; - var command = new RelayCommand(obj => receivedObject = obj); - var testObject = new TestObject { Value = 123 }; - - command.Execute(testObject); - - Assert.AreSame(testObject, receivedObject); - Assert.AreEqual(123, receivedObject.Value); - } - } - - #endregion - - #region Helper Classes - - private class TestObject - { - public int Value { get; set; } - } - - #endregion - } -} - -#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member diff --git a/src/Test/ConverterTests.cs b/src/Test/ConverterTests.cs deleted file mode 100644 index 40532521..00000000 --- a/src/Test/ConverterTests.cs +++ /dev/null @@ -1,343 +0,0 @@ -using NUnit.Framework; -using System; -using System.Globalization; -using System.Windows.Media; - -#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member - -namespace WinMemoryCleaner.Test -{ - /// - /// Unit tests for Converter classes - /// - - [TestFixture] - public sealed class ConverterTests - { - #region BrushToHexConverter Tests - - - [TestFixture] - public class BrushToHexConverterTests - { - [Test] - public void Convert_WithSolidColorBrush_ReturnsHexString() - { - // Arrange - var converter = new BrushToHexConverter(); - var brush = new SolidColorBrush(Colors.White); - - // Act - var result = converter.Convert(brush, typeof(string), null, CultureInfo.InvariantCulture); - - // Assert - Assert.IsNotNull(result); - Assert.IsInstanceOf(result); - } - - [Test] - public void Convert_WithNullBrush_ReturnsNull() - { - var converter = new BrushToHexConverter(); - var result = converter.Convert(null, typeof(string), null, CultureInfo.InvariantCulture); - - Assert.IsNull(result); - } - - [Test] - public void Convert_WithNonBrush_ReturnsNull() - { - var converter = new BrushToHexConverter(); - var result = converter.Convert("not a brush", typeof(string), null, CultureInfo.InvariantCulture); - - Assert.IsNull(result); - } - - [Test] - public void ConvertBack_ThrowsNotImplementedException() - { - // Arrange - var converter = new BrushToHexConverter(); - - // Act & Assert - Assert.Throws(() => converter.ConvertBack(null, typeof(Brush), null, CultureInfo.InvariantCulture)); - } - } - - #endregion - - #region EnumToBooleanConverter Tests - - - [TestFixture] - public class EnumToBooleanConverterTests - { - [Test] - public void Convert_WithMatchingValues_ReturnsTrue() - { - // Arrange - var converter = new EnumToBooleanConverter(); - var enumValue = DayOfWeek.Monday; - var parameter = DayOfWeek.Monday; - - // Act - var result = converter.Convert(enumValue, typeof(bool), parameter, CultureInfo.InvariantCulture); - - // Assert - Assert.IsTrue((bool)result); - } - - [Test] - public void Convert_WithNonMatchingValues_ReturnsFalse() - { - // Arrange - var converter = new EnumToBooleanConverter(); - var enumValue = DayOfWeek.Monday; - var parameter = DayOfWeek.Tuesday; - - // Act - var result = converter.Convert(enumValue, typeof(bool), parameter, CultureInfo.InvariantCulture); - - // Assert - Assert.IsFalse((bool)result); - } - - [Test] - public void Convert_WithNullValue_ReturnsFalse() - { - var converter = new EnumToBooleanConverter(); - var result = converter.Convert(null, typeof(bool), Enums.Priority.Normal, CultureInfo.InvariantCulture); - - Assert.IsFalse((bool)result); - } - - [Test] - public void ConvertBack_WithTrue_ReturnsParameter() - { - // Arrange - var converter = new EnumToBooleanConverter(); - var parameter = DayOfWeek.Monday; - - // Act - var result = converter.ConvertBack(true, typeof(DayOfWeek), parameter, CultureInfo.InvariantCulture); - - // Assert - Assert.AreEqual(parameter, result); - } - - [Test] - public void ConvertBack_WithFalse_ReturnsParameter() - { - var converter = new EnumToBooleanConverter(); - var result = converter.ConvertBack(false, typeof(Enums.Priority), Enums.Priority.High, CultureInfo.InvariantCulture); - - // EnumToBooleanConverter.ConvertBack always returns the parameter value - Assert.AreEqual(Enums.Priority.High, result); - } - } - - #endregion - - #region InverseBooleanConverter Tests - - - [TestFixture] - public class InverseBooleanConverterTests - { - [Test] - public void Convert_WithFalse_ReturnsTrue() - { - // Arrange - var converter = new InverseBooleanConverter(); - - // Act - var result = converter.Convert(false, typeof(bool), null, CultureInfo.InvariantCulture); - - // Assert - Assert.IsTrue((bool)result); - } - - [Test] - public void Convert_WithTrue_ReturnsFalse() - { - // Arrange - var converter = new InverseBooleanConverter(); - - // Act - var result = converter.Convert(true, typeof(bool), null, CultureInfo.InvariantCulture); - - // Assert - Assert.IsFalse((bool)result); - } - - [Test] - public void ConvertBack_WithFalse_ReturnsTrue() - { - // Arrange - var converter = new InverseBooleanConverter(); - - // Act - var result = converter.ConvertBack(false, typeof(bool), null, CultureInfo.InvariantCulture); - - // Assert - Assert.IsTrue((bool)result); - } - - [Test] - public void ConvertBack_WithTrue_ReturnsFalse() - { - // Arrange - var converter = new InverseBooleanConverter(); - - // Act - var result = converter.ConvertBack(true, typeof(bool), null, CultureInfo.InvariantCulture); - - // Assert - Assert.IsFalse((bool)result); - } - } - - #endregion - - #region InverseBooleanToVisibilityConverter Tests - - - [TestFixture] - public class InverseBooleanToVisibilityConverterTests - { - [Test] - public void Convert_WithFalse_ReturnsVisible() - { - // Arrange - var converter = new InverseBooleanToVisibilityConverter(); - - // Act - var result = converter.Convert(false, typeof(System.Windows.Visibility), null, CultureInfo.InvariantCulture); - - // Assert - Assert.AreEqual(System.Windows.Visibility.Visible, result); - } - - [Test] - public void Convert_WithTrue_ReturnsCollapsed() - { - // Arrange - var converter = new InverseBooleanToVisibilityConverter(); - - // Act - var result = converter.Convert(true, typeof(System.Windows.Visibility), null, CultureInfo.InvariantCulture); - - // Assert - Assert.AreEqual(System.Windows.Visibility.Collapsed, result); - } - } - - #endregion - - #region NullToVisibilityConverter Tests - - - [TestFixture] - public class NullToVisibilityConverterTests - { - [Test] - public void Convert_WithNonNull_ReturnsVisible() - { - // Arrange - var converter = new NullToVisibilityConverter(); - - // Act - var result = converter.Convert("test", typeof(System.Windows.Visibility), null, CultureInfo.InvariantCulture); - - // Assert - Assert.AreEqual(System.Windows.Visibility.Visible, result); - } - - [Test] - public void Convert_WithNull_ReturnsCollapsed() - { - // Arrange - var converter = new NullToVisibilityConverter(); - - // Act - var result = converter.Convert(null, typeof(System.Windows.Visibility), null, CultureInfo.InvariantCulture); - - // Assert - Assert.AreEqual(System.Windows.Visibility.Collapsed, result); - } - } - - #endregion - - #region PercentageToWidthConverter Tests - - - [TestFixture] - public class PercentageToWidthConverterTests - { - [Test] - public void Convert_WithValidPercentage_CalculatesWidth() - { - // Arrange - var converter = new PercentageToWidthConverter(); - - // Act - var result = converter.Convert(new object[] { 200.0, 50.0 }, typeof(double), null, CultureInfo.InvariantCulture); - - // Assert - Assert.AreEqual(100.0, (double)result); - } - } - - #endregion - - #region StringFormatConverter Tests - - - [TestFixture] - public class StringFormatConverterTests - { - [Test] - public void Convert_WithFormatString_FormatsValue() - { - // Arrange - var converter = new StringFormatConverter(); - - // Act - var result = converter.Convert(123, typeof(string), "{0:D5}", CultureInfo.InvariantCulture); - - // Assert - Assert.IsInstanceOf(result); - Assert.AreEqual("00123", result); - } - } - - #endregion - - #region SumNumericConverter Tests - - - [TestFixture] - public class SumNumericConverterTests - { - [Test] - public void Convert_WithNumericValues_ReturnsSum() - { - // Arrange - var converter = new SumNumericConverter(); - var values = new object[] { 10, 20, 30 }; - - // Act - var result = converter.Convert(values, typeof(double), null, CultureInfo.InvariantCulture); - - // Assert - Assert.IsInstanceOf(result); - Assert.AreEqual(60.0, (double)result); - } - } - - #endregion - } -} - -#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member diff --git a/src/Test/CoreTests.cs b/src/Test/CoreTests.cs deleted file mode 100644 index 33244d39..00000000 --- a/src/Test/CoreTests.cs +++ /dev/null @@ -1,1355 +0,0 @@ -using NUnit.Framework; -using System; -using System.ComponentModel; -using System.IO; - -#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member - -namespace WinMemoryCleaner.Test -{ - - public static class CoreTests - { - #region Constants Tests - - [TestFixture] - public class ConstantsTests - { - [Test] - public void App_AutoOptimizationMemoryUsageInterval_Is5Minutes() - { - Assert.AreEqual(5, Constants.App.AutoOptimizationMemoryUsageInterval); - } - - [Test] - public void App_AutoUpdateInterval_Is24Hours() - { - Assert.AreEqual(24, Constants.App.AutoUpdateInterval); - } - - [Test] - public void App_Author_Name_IsNotEmpty() - { - Assert.IsNotNull(Constants.App.Author.Name); - Assert.IsFalse(string.IsNullOrEmpty(Constants.App.Author.Name)); - Assert.AreEqual("Igor Mundstein", Constants.App.Author.Name); - } - - [Test] - public void App_CommandLineArgument_Install_IsCorrect() - { - Assert.AreEqual("Install", Constants.App.CommandLineArgument.Install); - } - - [Test] - public void App_CommandLineArgument_Reset_IsCorrect() - { - Assert.AreEqual("Reset", Constants.App.CommandLineArgument.Reset); - } - - [Test] - public void App_CommandLineArgument_Service_IsCorrect() - { - Assert.AreEqual("Service", Constants.App.CommandLineArgument.Service); - } - - [Test] - public void App_CommandLineArgument_Uninstall_IsCorrect() - { - Assert.AreEqual("Uninstall", Constants.App.CommandLineArgument.Uninstall); - } - - [Test] - public void App_Donation_BitcoinUri_IsValid() - { - Assert.IsNotNull(Constants.App.Donation.BitcoinUri); - Assert.IsTrue(Constants.App.Donation.BitcoinUri.IsAbsoluteUri); - } - - [Test] - public void App_Donation_EthereumUri_IsValid() - { - Assert.IsNotNull(Constants.App.Donation.EthereumUri); - Assert.IsTrue(Constants.App.Donation.EthereumUri.IsAbsoluteUri); - } - - [Test] - public void App_Donation_GitHubSponsorUri_IsValid() - { - Assert.IsNotNull(Constants.App.Donation.GitHubSponsorUri); - Assert.IsTrue(Constants.App.Donation.GitHubSponsorUri.IsAbsoluteUri); - } - - [Test] - public void App_Donation_KofiUri_IsValid() - { - Assert.IsNotNull(Constants.App.Donation.KofiUri); - Assert.IsTrue(Constants.App.Donation.KofiUri.IsAbsoluteUri); - } - - [Test] - public void App_Id_IsValidGuid() - { - var guid = Guid.Parse(Constants.App.Id); - - Assert.IsNotNull(guid); - Assert.AreNotEqual(Guid.Empty, guid); - } - - [Test] - public void App_License_IsGPL3() - { - Assert.AreEqual("GPL-3.0", Constants.App.License); - } - - [Test] - public void App_Name_IsNotEmpty() - { - Assert.IsNotNull(Constants.App.Name); - Assert.IsFalse(string.IsNullOrEmpty(Constants.App.Name)); - Assert.AreEqual("WinMemoryCleaner", Constants.App.Name); - } - - [Test] - public void App_Repository_AboutUri_IsValid() - { - Assert.IsNotNull(Constants.App.Repository.AboutUri); - Assert.IsTrue(Constants.App.Repository.AboutUri.IsAbsoluteUri); - } - - [Test] - public void App_Repository_DownloadUri_IsValid() - { - Assert.IsNotNull(Constants.App.Repository.DownloadUri); - Assert.IsTrue(Constants.App.Repository.DownloadUri.IsAbsoluteUri); - } - - [Test] - public void App_Repository_LatestExeUri_IsValid() - { - Assert.IsNotNull(Constants.App.Repository.LatestExeUri); - Assert.IsTrue(Constants.App.Repository.LatestExeUri.IsAbsoluteUri); - Assert.IsTrue(Constants.App.Repository.LatestExeUri.ToString().Contains("releases/latest")); - } - - [Test] - public void App_Repository_Uri_IsValid() - { - Assert.IsNotNull(Constants.App.Repository.Uri); - Assert.IsTrue(Constants.App.Repository.Uri.IsAbsoluteUri); - Assert.IsTrue(Constants.App.Repository.Uri.ToString().Contains("github.com")); - } - - [Test] - public void App_Title_IsNotEmpty() - { - Assert.IsNotNull(Constants.App.Title); - Assert.IsFalse(string.IsNullOrEmpty(Constants.App.Title)); - Assert.AreEqual("Windows Memory Cleaner", Constants.App.Title); - } - - [Test] - public void App_VersionFormat_IsValid() - { - Assert.AreEqual("{0}.{1}.{2}", Constants.App.VersionFormat); - } - - [Test] - public void Windows_Console_AttachParentProcess_IsNegativeOne() - { - Assert.AreEqual(-1, Constants.Windows.Console.AttachParentProcess); - } - - [Test] - public void Windows_Console_StdOutputHandle_IsNegativeEleven() - { - Assert.AreEqual(-11, Constants.Windows.Console.StdOutputHandle); - } - - [Test] - public void Windows_Privilege_SeDebugName_IsCorrect() - { - Assert.AreEqual("SeDebugPrivilege", Constants.Windows.Privilege.SeDebugName); - } - - [Test] - public void Windows_Privilege_SeIncreaseQuotaName_IsCorrect() - { - Assert.AreEqual("SeIncreaseQuotaPrivilege", Constants.Windows.Privilege.SeIncreaseQuotaName); - } - - [Test] - public void Windows_PrivilegeAttribute_Enabled_IsTwo() - { - Assert.AreEqual(2, Constants.Windows.PrivilegeAttribute.Enabled); - } - - [Test] - public void Windows_SystemErrorCode_ErrorAccessDenied_IsFive() - { - Assert.AreEqual(5, Constants.Windows.SystemErrorCode.ErrorAccessDenied); - } - - [Test] - public void Windows_SystemErrorCode_ErrorSuccess_IsZero() - { - Assert.AreEqual(0, Constants.Windows.SystemErrorCode.ErrorSuccess); - } - } - - #endregion - - #region ExtensionMethods Tests - - [TestFixture] - public class ExtensionMethodsTests - { - [Test] - public void Capitalize_WithEmptyString_ReturnsEmpty() - { - string text = string.Empty; - var result = text.Capitalize(); - - Assert.AreEqual(string.Empty, result); - } - - [Test] - public void Capitalize_WithException_ReturnsOriginal() - { - string text = null; - var result = text.Capitalize(); - - Assert.AreEqual(null, result); - } - - [Test] - public void Capitalize_WithMultipleSentences_CapitalizesCorrectly() - { - string text = "first sentence. second sentence."; - var result = text.Capitalize(); - - Assert.IsNotNull(result); - Assert.IsTrue(result.StartsWith("F", System.StringComparison.Ordinal)); - } - - [Test] - public void Capitalize_WithNormalText_CapitalizesFirstLetter() - { - string text = "hello world"; - var result = text.Capitalize(); - - Assert.IsNotNull(result); - Assert.IsTrue(result.StartsWith("H", System.StringComparison.Ordinal)); - } - - [Test] - public void DefaultValue_WithNullableType_ReturnsNull() - { - var type = typeof(int?); - var result = type.DefaultValue(); - - Assert.IsNull(result); - } - - [Test] - public void DefaultValue_WithReferenceType_ReturnsNull() - { - var type = typeof(string); - var result = type.DefaultValue(); - - Assert.IsNull(result); - } - - [Test] - public void DefaultValue_WithValueType_ReturnsDefault() - { - var type = typeof(int); - var result = type.DefaultValue(); - - Assert.IsNotNull(result); - Assert.AreEqual(0, result); - } - - [Test] - public void GetHex_WithBrush_ReturnsHexCode() - { - using (var brush = new System.Drawing.SolidBrush(System.Drawing.Color.Red)) - { - var hex = brush.GetHex(); - - Assert.IsNotNull(hex); - Assert.IsTrue(hex.StartsWith("#", System.StringComparison.Ordinal)); - } - } - - [Test] - public void GetHex_WithBrushAndAlpha_ReturnsHexCodeWithAlpha() - { - using (var brush = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(128, 255, 0, 0))) - { - var hex = brush.GetHex(true); - - Assert.IsNotNull(hex); - Assert.IsTrue(hex.StartsWith("#", System.StringComparison.Ordinal)); - Assert.AreEqual(9, hex.Length); // #AARRGGBB - } - } - - [Test] - public void GetHex_WithColor_ReturnsHexCode() - { - var color = System.Drawing.Color.Blue; - var hex = color.GetHex(); - - Assert.IsNotNull(hex); - Assert.AreEqual("#0000FF", hex); - } - - [Test] - public void GetHex_WithMediaColor_ReturnsHexCode() - { - var color = System.Windows.Media.Color.FromRgb(0, 255, 0); - var hex = color.GetHex(); - - Assert.IsNotNull(hex); - Assert.AreEqual("#00FF00", hex); - } - - [Test] - public void GetKeyValue_WithNo_ReturnsCorrectKeyValue() - { - var button = Enums.Dialog.Button.No; - var result = button.GetKeyValue(); - - Assert.AreEqual(Localizer.String.No, result.Key); - Assert.AreEqual(false, result.Value); - } - - [Test] - public void GetKeyValue_WithNone_ReturnsNullKeyValue() - { - var button = Enums.Dialog.Button.None; - var result = button.GetKeyValue(); - - Assert.IsNull(result.Key); - Assert.IsNull(result.Value); - } - - [Test] - public void GetKeyValue_WithYes_ReturnsCorrectKeyValue() - { - var button = Enums.Dialog.Button.Yes; - var result = button.GetKeyValue(); - - Assert.AreEqual(Localizer.String.Yes, result.Key); - Assert.AreEqual(true, result.Value); - } - - [Test] - public void GetMessage_WithInnerException_ReturnsAllMessages() - { - var innerException = new InvalidOperationException("Inner exception"); - var exception = new Exception("Outer exception", innerException); - var message = exception.GetMessage(); - - Assert.IsNotNull(message); - Assert.IsTrue(message.Contains("Outer exception")); - Assert.IsTrue(message.Contains("Inner exception")); - } - - [Test] - public void GetMessage_WithMultipleInnerExceptions_ReturnsDeduplicatedMessages() - { - var ex1 = new Exception("Message 1"); - var ex2 = new Exception("Message 2", ex1); - var ex3 = new Exception("Message 1", ex2); // Duplicate message - var message = ex3.GetMessage(); - - Assert.IsNotNull(message); - } - - [Test] - public void GetMessage_WithNullException_ReturnsNull() - { - Exception exception = null; - var message = exception.GetMessage(); - - Assert.IsNull(message); - } - - [Test] - public void GetMessage_WithException_ReturnsMessage() - { - var exception = new Exception("Test exception message"); - var message = exception.GetMessage(); - - Assert.IsNotNull(message); - Assert.IsTrue(message.Contains("Test exception message")); - } - - [Test] - public void GetString_WithLowMemoryReason_ReturnsCorrectString() - { - var reason = Enums.Memory.Optimization.Reason.LowMemory; - var result = reason.GetString(); - - Assert.AreEqual(Localizer.String.LowMemory, result); - } - - [Test] - public void GetString_WithManualReason_ReturnsCorrectString() - { - var reason = Enums.Memory.Optimization.Reason.Manual; - var result = reason.GetString(); - - Assert.AreEqual(Localizer.String.Manual, result); - } - - [Test] - public void GetString_WithScheduleReason_ReturnsCorrectString() - { - var reason = Enums.Memory.Optimization.Reason.Schedule; - var result = reason.GetString(); - - Assert.AreEqual(Localizer.String.Schedule, result); - } - - [Test] - public void IsEquals_WithDifferentColors_ReturnsFalse() - { - var mediaColor = System.Windows.Media.Color.FromRgb(255, 0, 0); - var drawingColor = System.Drawing.Color.Blue; - var result = mediaColor.IsEquals(drawingColor); - - Assert.IsFalse(result); - } - - [Test] - public void IsEquals_WithMatchingColors_ReturnsTrue() - { - var mediaColor = System.Windows.Media.Color.FromArgb(255, 128, 64, 32); - var drawingColor = System.Drawing.Color.FromArgb(255, 128, 64, 32); - var result = mediaColor.IsEquals(drawingColor); - - Assert.IsTrue(result); - } - - [Test] - public void IsEquals_WithNullMediaColor_ReturnsFalse() - { - System.Windows.Media.Color? mediaColor = null; - var drawingColor = System.Drawing.Color.Red; - if (mediaColor.HasValue) - { - var result = mediaColor.Value.IsEquals(drawingColor); - - Assert.IsFalse(result); - } - } - - [Test] - public void IsNumber_WithByte_ReturnsTrue() - { - byte value = 100; - var result = value.IsNumber(); - - Assert.IsTrue(result); - } - - [Test] - public void IsNumber_WithDecimal_ReturnsTrue() - { - decimal value = 123.45m; - var result = value.IsNumber(); - - Assert.IsTrue(result); - } - - [Test] - public void IsNumber_WithDouble_ReturnsTrue() - { - double value = 123.45; - var result = value.IsNumber(); - - Assert.IsTrue(result); - } - - [Test] - public void IsNumber_WithInt_ReturnsTrue() - { - int value = 123; - var result = value.IsNumber(); - - Assert.IsTrue(result); - } - - [Test] - public void IsNumber_WithNull_ReturnsFalse() - { - object value = null; - var result = value.IsNumber(); - - Assert.IsFalse(result); - } - - [Test] - public void IsNumber_WithString_ReturnsFalse() - { - object value = "not a number"; - var result = value.IsNumber(); - - Assert.IsFalse(result); - } - - [Test] - public void IsValid_WithInvalidEnum_ReturnsFalse() - { - var invalidEnum = (Enums.Priority)999; - var result = invalidEnum.IsValid(); - - Assert.IsFalse(result); - } - - [Test] - public void IsValid_WithNullEnum_ReturnsFalse() - { - Enum nullEnum = null; - var result = nullEnum.IsValid(); - - Assert.IsFalse(result); - } - - [Test] - public void IsValid_WithValidEnum_ReturnsTrue() - { - var validEnum = Enums.Priority.Normal; - var result = validEnum.IsValid(); - - Assert.IsTrue(result); - } - - [Test] - public void RemoveWhitespaces_WithMixedWhitespace_RemovesAll() - { - string text = " hello world \t\n"; - var result = text.RemoveWhitespaces(); - - Assert.AreEqual("helloworld", result); - } - - [Test] - public void RemoveWhitespaces_WithNoWhitespace_ReturnsSame() - { - string text = "helloworld"; - var result = text.RemoveWhitespaces(); - - Assert.AreEqual("helloworld", result); - } - - [Test] - public void ToBrush_WithInvalidHexString_ReturnsFallback() - { - string hex = "invalid"; - using (var fallback = new System.Drawing.SolidBrush(System.Drawing.Color.Red)) - { - using (var result = hex.ToBrush(fallback)) - { - Assert.AreEqual(fallback, result); - } - } - } - - [Test] - public void ToBrush_WithNullMediaBrush_ReturnsNull() - { - System.Windows.Media.Brush mediaBrush = null; - var result = mediaBrush.ToBrush(); - - Assert.IsNull(result); - } - - [Test] - public void ToBrush_WithValidHexString_ReturnsCorrectBrush() - { - string hex = "#FF0000"; - using (var fallback = new System.Drawing.SolidBrush(System.Drawing.Color.Blue)) - using (var result = hex.ToBrush(fallback)) - { - Assert.IsNotNull(result); - } - } - - [Test] - public void ToBrush_WithValidMediaBrush_ReturnsDrawingBrush() - { - var mediaBrush = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(255, 128, 64)); - using (var result = mediaBrush.ToBrush()) - { - Assert.IsNotNull(result); - Assert.IsInstanceOf(result); - } - } - - [Test] - public void ToColor_WithMediaBrush_ReturnsDrawingColor() - { - var mediaBrush = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromArgb(200, 100, 50, 25)); - var result = mediaBrush.ToColor(); - - Assert.AreEqual(200, result.A); - Assert.AreEqual(100, result.R); - Assert.AreEqual(50, result.G); - Assert.AreEqual(25, result.B); - } - - [Test] - public void ToMemoryUnit_WithBytesValue_ConvertsCorrectly() - { - long bytes = 512; - var result = bytes.ToMemoryUnit(); - - Assert.IsNotNull(result); - Assert.IsTrue(result.Key > 0); - } - - [Test] - public void ToMemoryUnit_WithGigabytesValue_ConvertsCorrectly() - { - long bytes = 1073741824; // 1 GB - var result = bytes.ToMemoryUnit(); - - Assert.IsNotNull(result); - Assert.IsTrue(result.Key > 0); - } - - [Test] - public void ToMemoryUnit_WithKilobytesValue_ConvertsCorrectly() - { - long bytes = 2048; // 2 KB - var result = bytes.ToMemoryUnit(); - - Assert.IsNotNull(result); - Assert.IsTrue(result.Key > 0); - } - - [Test] - public void ToMemoryUnit_WithMegabytesValue_ConvertsCorrectly() - { - long bytes = 1048576; // 1 MB - var result = bytes.ToMemoryUnit(); - - Assert.IsNotNull(result); - Assert.IsTrue(result.Key > 0); - } - - [Test] - public void ToMemoryUnit_WithZeroValue_HandlesCorrectly() - { - long bytes = 0; - var result = bytes.ToMemoryUnit(); - - Assert.IsNotNull(result); - Assert.AreEqual(0, result.Key); - } - } - - #endregion - - #region Helper Tests - - public sealed class HelperTests - { - private string _tempFilePath; - - [SetUp] - public void SetUp() - { - _tempFilePath = Path.Combine(Path.GetTempPath(), "test_" + Guid.NewGuid() + ".txt"); - } - - [TearDown] - public void TearDown() - { - if (File.Exists(_tempFilePath)) - { - try { File.Delete(_tempFilePath); } catch { } - } - } - - [Test] - public void DeleteFile_WhenFileDoesNotExist_ReturnsFalse() - { - var nonExistentPath = Path.Combine(Path.GetTempPath(), "nonexistent_" + Guid.NewGuid() + ".txt"); - var result = Helper.DeleteFile(nonExistentPath); - - Assert.IsFalse(result); - } - - [Test] - public void DeleteFile_WhenFileExists_ReturnsTrue() - { - File.WriteAllText(_tempFilePath, "test content"); - - Assert.IsTrue(File.Exists(_tempFilePath)); - var result = Helper.DeleteFile(_tempFilePath); - - Assert.IsTrue(result); - - Assert.IsFalse(File.Exists(_tempFilePath)); - } - - [Test] - public void Deserialize_WithValidJsonString_DeserializesCorrectly() - { - var json = "{\"Name\":\"Test\",\"Value\":123}"; - var result = Helper.Deserialize(json); - - Assert.IsNotNull(result); - Assert.AreEqual("Test", result.Name); - Assert.AreEqual(123, result.Value); - } - - [Test] - public void GetExecutablePath_ReturnsNonEmptyString() - { - var path = Helper.GetExecutablePath(); - - Assert.IsNotNull(path); - Assert.IsFalse(string.IsNullOrEmpty(path)); - } - - [Test] - public void GetVersion_ReturnsValidVersion() - { - var version = Helper.GetVersion(); - - Assert.IsNotNull(version); - Assert.IsTrue(version.Major >= 0); - Assert.IsTrue(version.Minor >= 0); - } - - [Test] - public void IsAutoUpdateSupported_ReturnsBoolean() - { - var isSupported = Helper.IsAutoUpdateSupported; - - Assert.IsNotNull(isSupported); - } - - [Test] - public void NameOf_WithNullExpression_ThrowsArgumentNullException() - { - Assert.Throws(() => Helper.NameOf(null)); - } - - [Test] - public void NameOf_WithValidExpression_ReturnsPropertyName() - { - var testObject = new { TestProperty = "value" }; - var name = Helper.NameOf(() => testObject.TestProperty); - - Assert.AreEqual("TestProperty", name); - } - - [Test] - public void Serialize_WithMinifiedTrue_ReturnsCompactJson() - { - var obj = new TestJsonSerializable { Name = "Test", Value = 123 }; - var json = Helper.Serialize(obj, true); - - Assert.IsNotNull(json); - Assert.IsFalse(json.Contains("\r\n")); - } - - [Test] - public void Serialize_WithNullObject_ThrowsArgumentNullException() - { - Assert.Throws(() => Helper.Serialize(null)); - } - - [Test] - public void Serialize_WithValidObject_ReturnsFormattedJson() - { - var obj = new TestJsonSerializable { Name = "Test", Value = 123 }; - var json = Helper.Serialize(obj, false); - - Assert.IsNotNull(json); - Assert.IsTrue(json.Contains("Name")); - Assert.IsTrue(json.Contains("Test")); - } - - [Test] - public void ToHexCode_WithMaxValues_ReturnsWhiteHexCode() - { - var hexCode = Helper.ToHexCode(255, 255, 255); - - Assert.AreEqual("#FFFFFF", hexCode); - } - - [Test] - public void ToHexCode_WithRgbValues_ReturnsCorrectHexCode() - { - var hexCode = Helper.ToHexCode(255, 128, 64); - - Assert.AreEqual("#FF8040", hexCode); - } - - [Test] - public void ToHexCode_WithRgbaValues_ReturnsCorrectHexCodeWithAlpha() - { - var hexCode = Helper.ToHexCode(255, 128, 64, 200); - - Assert.AreEqual("#C8FF8040", hexCode); - } - - [Test] - public void ToHexCode_WithZeroValues_ReturnsBlackHexCode() - { - var hexCode = Helper.ToHexCode(0, 0, 0); - - Assert.AreEqual("#000000", hexCode); - } - } - - #endregion - - #region Localizer Tests - - [TestFixture] - public class LocalizerTests - { - [Test] - public void Localizer_Culture_IsNotNull() - { - var culture = Localizer.Culture; - - Assert.IsNotNull(culture); - } - - [Test] - public void Language_CanBeSet() - { - var originalLanguage = Localizer.Language; - try - { - Localizer.Language = Localizer.Languages.Find(language => language.Name == Constants.Windows.Locale.Name.English); - - Assert.IsNotNull(Localizer.Language); - - Localizer.Language = Localizer.Languages.Count > 0 ? Localizer.Languages[0] : originalLanguage; ; - - Assert.IsNotNull(Localizer.Language); - } - finally - { - Localizer.Language = originalLanguage; - } - } - - [Test] - public void Languages_IsNotNull() - { - var languages = Localizer.Languages; - - Assert.IsNotNull(languages); - } - - [Test] - public void Languages_ContainsLanguages() - { - var languages = Localizer.Languages; - - Assert.IsTrue(languages.Count > 0); - } - - [Test] - public void String_IsNotNull() - { - var localization = Localizer.String; - - Assert.IsNotNull(localization); - } - } - - #endregion - - #region Logger Tests - - [TestFixture] - public class LoggerTests - { - [Test] - public void Debug_MultipleCalls_DoesNotThrow() - { - Assert.DoesNotThrow(() => - { - Logger.Debug("Message 1"); - Logger.Debug("Message 2"); - Logger.Debug("Message 3"); - }); - } - - [Test] - public void Debug_WithEmptyMessage_DoesNotThrow() - { - Assert.DoesNotThrow(() => Logger.Debug(string.Empty)); - } - - [Test] - public void Debug_WithException_DoesNotThrow() - { - var testException = new Exception("Test exception"); - - Assert.DoesNotThrow(() => Logger.Debug(testException, "Test message")); - } - - [Test] - public void Debug_WithMessage_DoesNotThrow() - { - Assert.DoesNotThrow(() => Logger.Debug("Test debug message")); - } - - [Test] - public void Debug_WithNullMessage_DoesNotThrow() - { - Assert.DoesNotThrow(() => Logger.Debug(null, string.Empty)); - } - - [Test] - public void Error_WithException_DoesNotThrow() - { - var testException = new Exception("Test error"); - - Assert.DoesNotThrow(() => Logger.Error(testException)); - } - - [Test] - public void Error_WithMessage_DoesNotThrow() - { - Assert.DoesNotThrow(() => Logger.Error("Test error message")); - } - - [Test] - public void Information_WithMessage_DoesNotThrow() - { - Assert.DoesNotThrow(() => Logger.Information("Test information message")); - } - - [Test] - public void Level_CanBeSet() - { - var originalLevel = Logger.Level; - try - { - Logger.Level = Enums.Log.Levels.Debug; - - Assert.DoesNotThrow(() => Logger.Debug("Debug message")); - - Logger.Level = Enums.Log.Levels.Information; - - Assert.DoesNotThrow(() => Logger.Information("Info message")); - - Logger.Level = Enums.Log.Levels.Warning; - - Assert.DoesNotThrow(() => Logger.Warning("Warning message")); - - Logger.Level = Enums.Log.Levels.Error; - - Assert.DoesNotThrow(() => Logger.Error("Error message")); - } - finally - { - Logger.Level = originalLevel; - } - } - - [Test] - public void Log_WithNullLog_DoesNotThrow() - { - Assert.DoesNotThrow(() => Logger.Log(null)); - } - - [Test] - public void Log_WithValidLog_DoesNotThrow() - { - var log = new Log(Enums.Log.Levels.Debug, "Test message", null, "TestMethod"); - - Assert.DoesNotThrow(() => Logger.Log(log)); - } - - [Test] - public void Warning_WithMessage_DoesNotThrow() - { - Assert.DoesNotThrow(() => Logger.Warning("Test warning message")); - } - } - - #endregion - - #region ObservableObject Tests - - [TestFixture] - public class ObservableObjectTests - { - [Test] - public void ImplementsINotifyPropertyChanged() - { - var obj = new TestObservableObject(); - - Assert.IsInstanceOf(obj); - } - - [Test] - public void OnPropertyChanged_MultipleTimes_RaisesEventEachTime() - { - var obj = new TestObservableObject(); - var eventCount = 0; - obj.PropertyChanged += (sender, e) => eventCount++; - obj.RaisePropertyChanged("Property1"); - obj.RaisePropertyChanged("Property2"); - obj.RaisePropertyChanged("Property3"); - - Assert.AreEqual(3, eventCount); - } - - [Test] - public void OnPropertyChanged_RaisesPropertyChangedEvent() - { - var obj = new TestObservableObject(); - var eventRaised = false; - string propertyName = null; - obj.PropertyChanged += (sender, e) => - { - eventRaised = true; - propertyName = e.PropertyName; - }; - obj.RaisePropertyChanged("TestProperty"); - - Assert.IsTrue(eventRaised); - - Assert.AreEqual("TestProperty", propertyName); - } - - [Test] - public void OnPropertyChanged_WithEmptyPropertyName_RaisesEvent() - { - var obj = new TestObservableObject(); - var eventRaised = false; - obj.PropertyChanged += (sender, e) => eventRaised = true; - obj.RaisePropertyChanged(string.Empty); - - Assert.IsTrue(eventRaised); - } - - [Test] - public void OnPropertyChanged_WithNoSubscribers_DoesNotThrow() - { - var obj = new TestObservableObject(); - Assert.DoesNotThrow(() => obj.RaisePropertyChanged("TestProperty")); - } - - [Test] - public void OnPropertyChanged_WithNullPropertyName_RaisesEvent() - { - var obj = new TestObservableObject(); - var eventRaised = false; - obj.PropertyChanged += (sender, e) => eventRaised = true; - obj.RaisePropertyChanged(null); - - Assert.IsTrue(eventRaised); - } - - [Test] - public void PropertyChanged_MultipleSubscribers_NotifiesAll() - { - var obj = new TestObservableObject(); - var firstNotified = false; - var secondNotified = false; - obj.PropertyChanged += (sender, e) => firstNotified = true; - obj.PropertyChanged += (sender, e) => secondNotified = true; - obj.RaisePropertyChanged("TestProperty"); - - Assert.IsTrue(firstNotified); - - Assert.IsTrue(secondNotified); - } - } - - #endregion - - #region Settings Tests - - [TestFixture] - public class SettingsTests - { - [Test] - public void AlwaysOnTop_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var alwaysOnTop = Settings.AlwaysOnTop; }); - } - - [Test] - public void AutoOptimizationInterval_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var interval = Settings.AutoOptimizationInterval; }); - } - - [Test] - public void AutoOptimizationMemoryUsage_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var usage = Settings.AutoOptimizationMemoryUsage; }); - } - - [Test] - public void AutoUpdate_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var autoUpdate = Settings.AutoUpdate; }); - } - - [Test] - public void CloseAfterOptimization_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var close = Settings.CloseAfterOptimization; }); - } - - [Test] - public void CloseToTheNotificationArea_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var close = Settings.CloseToTheNotificationArea; }); - } - - [Test] - public void CompactMode_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var compact = Settings.CompactMode; }); - } - - [Test] - public void CreateStartMenuShortcut_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var create = Settings.CreateStartMenuShortcut; }); - } - - [Test] - public void FontSize_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var fontSize = Settings.FontSize; }); - } - - [Test] - public void Language_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var language = Settings.Language; }); - } - - [Test] - public void MemoryAreas_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var areas = Settings.MemoryAreas; }); - } - - [Test] - public void OptimizationKey_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var key = Settings.OptimizationKey; }); - } - - [Test] - public void OptimizationModifiers_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var modifiers = Settings.OptimizationModifiers; }); - } - - [Test] - public void ProcessExclusionList_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var list = Settings.ProcessExclusionList; }); - } - - [Test] - public void RunOnPriority_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var priority = Settings.RunOnPriority; }); - } - - [Test] - public void RunOnStartup_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var runOnStartup = Settings.RunOnStartup; }); - } - - [Test] - public void Save_DoesNotThrow() - { - Assert.DoesNotThrow(() => Settings.Save()); - } - - [Test] - public void ShowOptimizationNotifications_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var show = Settings.ShowOptimizationNotifications; }); - } - - [Test] - public void ShowVirtualMemory_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var show = Settings.ShowVirtualMemory; }); - } - - [Test] - public void StartMinimized_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var start = Settings.StartMinimized; }); - } - - [Test] - public void TrayIconBackgroundColor_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var color = Settings.TrayIconBackgroundColor; }); - } - - [Test] - public void TrayIconDangerColor_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var color = Settings.TrayIconDangerColor; }); - } - - [Test] - public void TrayIconDangerLevel_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var level = Settings.TrayIconDangerLevel; }); - } - - [Test] - public void TrayIconOptimizeOnMiddleMouseClick_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var optimize = Settings.TrayIconOptimizeOnMiddleMouseClick; }); - } - - [Test] - public void TrayIconOptimizingColor_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var color = Settings.TrayIconOptimizingColor; }); - } - - [Test] - public void TrayIconShowMemoryUsage_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var show = Settings.TrayIconShowMemoryUsage; }); - } - - [Test] - public void TrayIconTextColor_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var color = Settings.TrayIconTextColor; }); - } - - [Test] - public void TrayIconUseTransparentBackground_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var use = Settings.TrayIconUseTransparentBackground; }); - } - - [Test] - public void TrayIconWarningColor_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var color = Settings.TrayIconWarningColor; }); - } - - [Test] - public void TrayIconWarningLevel_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var level = Settings.TrayIconWarningLevel; }); - } - - [Test] - public void UseHotkey_CanBeAccessed() - { - Assert.DoesNotThrow(() => { var use = Settings.UseHotkey; }); - } - } - - #endregion - - #region ThemeManager Tests - - [TestFixture] - public class ThemeManagerTests - { - [Test] - public void Brushes_IsNotNull() - { - var brushes = ThemeManager.Brushes; - - Assert.IsNotNull(brushes); - } - - [Test] - public void Cleanup_DoesNotThrow() - { - Assert.DoesNotThrow(() => ThemeManager.Cleanup()); - } - - [Test] - public void Theme_CanBeSet() - { - var originalTheme = ThemeManager.Theme; - try - { - ThemeManager.Theme = Enums.Theme.Light; - - Assert.AreEqual(Enums.Theme.Light, ThemeManager.Theme); - - ThemeManager.Theme = Enums.Theme.Dark; - - Assert.AreEqual(Enums.Theme.Dark, ThemeManager.Theme); - } - finally - { - ThemeManager.Theme = originalTheme; - } - } - - [Test] - public void Themes_IsNotNull() - { - var themes = ThemeManager.Themes; - - Assert.IsNotNull(themes); - } - } - - #endregion - - #region Helper Classes - - private class TestJsonSerializable : IJsonSerializable - { - public string Name { get; set; } - public int Value { get; set; } - - public object ToJson() - { - return new { Name, Value }; - } - } - - private class TestObject - { - public string Name { get; set; } - public int Value { get; set; } - } - - private class TestObservableObject : ObservableObject - { - public new void RaisePropertyChanged(string propertyName) - { - base.RaisePropertyChanged(propertyName); - } - } - - #endregion - } -} - -#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member diff --git a/src/Test/IntegrationTests.cs b/src/Test/IntegrationTests.cs deleted file mode 100644 index d673a7bb..00000000 --- a/src/Test/IntegrationTests.cs +++ /dev/null @@ -1,674 +0,0 @@ -using NUnit.Framework; -using System; -using System.Globalization; -using System.Linq; -using System.Windows.Input; - -#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member - -namespace WinMemoryCleaner.Test -{ - /// - /// Integration tests based on GitHub issues and real-world usage scenarios - /// These tests help ensure the application works correctly in production scenarios - /// - - public static class IntegrationTests - { - #region Memory Optimization Integration Tests - - - [TestFixture] - public class MemoryOptimizationIntegrationTests - { - [Test] - public void MemoryOptimization_WithAllAreas_CompletesSuccessfully() - { - var originalAreas = Settings.MemoryAreas; - try - { - Settings.MemoryAreas = Enums.Memory.Areas.CombinedPageList | - Enums.Memory.Areas.ModifiedPageList | - Enums.Memory.Areas.WorkingSet | - Enums.Memory.Areas.ModifiedFileCache | - Enums.Memory.Areas.StandbyList; - - try { App.ReleaseMemory(); } catch { } - } - finally - { - Settings.MemoryAreas = originalAreas; - } - } - - [Test] - public void MemoryOptimization_WithSingleArea_CompletesSuccessfully() - { - var originalAreas = Settings.MemoryAreas; - try - { - Settings.MemoryAreas = Enums.Memory.Areas.CombinedPageList; - Exception ex1 = null; - try { App.ReleaseMemory(); } catch (Exception ex) { ex1 = ex; } - Assert.IsNull(ex1); - - Settings.MemoryAreas = Enums.Memory.Areas.ModifiedPageList; - Exception ex2 = null; - try { App.ReleaseMemory(); } catch (Exception ex) { ex2 = ex; } - Assert.IsNull(ex2); - - Settings.MemoryAreas = Enums.Memory.Areas.WorkingSet; - Exception ex3 = null; - try { App.ReleaseMemory(); } catch (Exception ex) { ex3 = ex; } - Assert.IsNull(ex3); - } - finally - { - Settings.MemoryAreas = originalAreas; - } - } - - [Test] - public void MemoryOptimization_WithNoAreas_HandlesGracefully() - { - var originalAreas = Settings.MemoryAreas; - try - { - Settings.MemoryAreas = 0; - try { App.ReleaseMemory(); } catch { } - } - finally - { - Settings.MemoryAreas = originalAreas; - } - } - } - - #endregion - - #region Settings Integration Tests - - - [TestFixture] - public class SettingsIntegrationTests - { - [Test] - public void Settings_SaveAndLoad_PreservesAllSettings() - { - var originalAlwaysOnTop = Settings.AlwaysOnTop; - var originalAutoUpdate = Settings.AutoUpdate; - var originalCompactMode = Settings.CompactMode; - - try - { - // Modify settings - Settings.AlwaysOnTop = !originalAlwaysOnTop; - Settings.AutoUpdate = !originalAutoUpdate; - Settings.CompactMode = !originalCompactMode; - - // Save - Settings.Save(); - - // Note: Settings.Load is private, just verify settings were modified - Assert.AreEqual(!originalAlwaysOnTop, Settings.AlwaysOnTop); - } - finally - { - Settings.AlwaysOnTop = originalAlwaysOnTop; - Settings.AutoUpdate = originalAutoUpdate; - Settings.CompactMode = originalCompactMode; - Settings.Save(); - } - } - - [Test] - public void Settings_ProcessExclusionList_SaveAndLoad_PreservesList() - { - var originalList = Settings.ProcessExclusionList; - try - { - // ProcessExclusionList setter is private, test only getter - Assert.IsNotNull(Settings.ProcessExclusionList); - } - finally - { - // ProcessExclusionList setter is private - Settings.Save(); - } - } - - [Test] - public void Settings_ColorSettings_SaveAndLoad_PreservesColors() - { - var originalBackground = Settings.TrayIconBackgroundColor; - var originalDanger = Settings.TrayIconDangerColor; - - try - { - using (var newBackground = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(255, 100, 100, 100))) - using (var newDanger = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(255, 200, 50, 50))) - { - Settings.TrayIconBackgroundColor = newBackground; - Settings.TrayIconDangerColor = newDanger; - Settings.Save(); - - Assert.IsNotNull(Settings.TrayIconBackgroundColor); - Assert.IsNotNull(Settings.TrayIconDangerColor); - } - } - finally - { - Settings.TrayIconBackgroundColor = originalBackground; - Settings.TrayIconDangerColor = originalDanger; - Settings.Save(); - } - } - } - - #endregion - - #region Hotkey Integration Tests - - - [TestFixture] - public class HotkeyIntegrationTests - { - [Test] - public void Hotkey_WithCommonCombinations_CreatesCorrectly() - { - var ctrlC = new Hotkey(ModifierKeys.Control, Key.C); - var ctrlV = new Hotkey(ModifierKeys.Control, Key.V); - var ctrlShiftEsc = new Hotkey(ModifierKeys.Control | ModifierKeys.Shift, Key.Escape); - - Assert.AreEqual(ModifierKeys.Control, ctrlC.Modifiers); - Assert.AreEqual(Key.C, ctrlC.Key); - - Assert.AreEqual(ModifierKeys.Control, ctrlV.Modifiers); - Assert.AreEqual(Key.V, ctrlV.Key); - - Assert.IsTrue((ctrlShiftEsc.Modifiers & ModifierKeys.Control) != 0); - Assert.IsTrue((ctrlShiftEsc.Modifiers & ModifierKeys.Shift) != 0); - } - - [Test] - public void Hotkey_Equality_WithDifferentInstances_ComparesCorrectly() - { - var hotkey1 = new Hotkey(ModifierKeys.Control, Key.F5); - var hotkey2 = new Hotkey(ModifierKeys.Control, Key.F5); - var hotkey3 = new Hotkey(ModifierKeys.Alt, Key.F5); - - Assert.IsTrue(hotkey1.Equals(hotkey2)); - Assert.IsFalse(hotkey1.Equals(hotkey3)); - Assert.AreEqual(hotkey1.GetHashCode(), hotkey2.GetHashCode()); - Assert.AreNotEqual(hotkey1.GetHashCode(), hotkey3.GetHashCode()); - } - } - - #endregion - - #region Localization Integration Tests - - - [TestFixture] - public class LocalizationIntegrationTests - { - [Test] - public void Localization_SwitchLanguage_UpdatesAllStrings() - { - var originalLanguage = Localizer.Language; - try - { - var availableLanguages = Localizer.Languages; - - foreach (var language in availableLanguages.Take(Math.Min(3, availableLanguages.Count))) - { - Localizer.Language = language; - - // Verify strings are loaded - Assert.IsNotNull(Localizer.String); - Assert.IsFalse(string.IsNullOrEmpty(Localizer.String.About)); - Assert.IsFalse(string.IsNullOrEmpty(Localizer.String.Close)); - Assert.IsFalse(string.IsNullOrEmpty(Localizer.String.Settings)); - } - } - finally - { - if (originalLanguage != null) - { - Localizer.Language = originalLanguage; - } - } - } - - [Test] - public void Localization_AllLanguages_HaveRequiredStrings() - { - var originalLanguage = Localizer.Language; - try - { - var availableLanguages = Localizer.Languages; - - foreach (var language in availableLanguages) - { - Localizer.Language = language; - - // Verify critical strings are not null - var localization = Localizer.String; - Assert.IsNotNull(localization); - if (localization == null) - { - throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Localization is null for {0}", language.Name)); - } - } - } - finally - { - if (originalLanguage != null) - { - Localizer.Language = originalLanguage; - } - } - } - } - - #endregion - - #region Theme Integration Tests - - - [TestFixture] - public class ThemeIntegrationTests - { - [Test] - public void Theme_SwitchBetweenThemes_UpdatesColors() - { - var originalTheme = ThemeManager.Theme; - try - { - // Switch to Light theme - ThemeManager.Theme = Enums.Theme.Light; - var lightPrimaryBg = ThemeManager.PrimaryBackgroundColor; - - // Switch to Dark theme - ThemeManager.Theme = Enums.Theme.Dark; - var darkPrimaryBg = ThemeManager.PrimaryBackgroundColor; - - // Themes should have different colors - Assert.IsNotNull(lightPrimaryBg); - Assert.IsNotNull(darkPrimaryBg); - } - finally - { - ThemeManager.Theme = originalTheme; - } - } - - [Test] - public void Theme_AllBrushes_AreAvailable() - { - var brushes = ThemeManager.Brushes; - - Assert.IsNotNull(brushes); - Assert.IsTrue(brushes.Count > 0); - - // Brushes is a List - Assert.IsTrue(brushes.Count > 0); - } - - [Test] - public void Theme_Cleanup_ResetsCorrectly() - { - var originalTheme = ThemeManager.Theme; - try - { - ThemeManager.Theme = Enums.Theme.Dark; - ThemeManager.Cleanup(); - - // After cleanup, brushes should still be accessible - var brushes = ThemeManager.Brushes; - Assert.IsNotNull(brushes); - } - finally - { - ThemeManager.Theme = originalTheme; - } - } - } - - #endregion - - #region Priority Integration Tests - - - [TestFixture] - public class PriorityIntegrationTests - { - [Test] - public void Priority_SetAllLevels_CompletesSuccessfully() - { - foreach (Enums.Priority priority in Enum.GetValues(typeof(Enums.Priority))) - { - Exception ex = null; - try { App.SetPriority(priority); } catch (Exception e) { ex = e; } - Assert.IsNull(ex); - } - - // Reset to normal - App.SetPriority(Enums.Priority.Normal); - } - - [Test] - public void Priority_SaveAndLoad_PreservesSelection() - { - var originalPriority = Settings.RunOnPriority; - try - { - foreach (Enums.Priority priority in Enum.GetValues(typeof(Enums.Priority))) - { - Settings.RunOnPriority = priority; - Settings.Save(); - - Assert.AreEqual(priority, Settings.RunOnPriority); - } - } - finally - { - Settings.RunOnPriority = originalPriority; - Settings.Save(); - } - } - } - - #endregion - - #region Auto-Optimization Integration Tests - - - [TestFixture] - public class AutoOptimizationIntegrationTests - { - [Test] - public void AutoOptimization_SettingsConfiguration_WorksCorrectly() - { - var originalInterval = Settings.AutoOptimizationInterval; - var originalMemoryUsage = Settings.AutoOptimizationMemoryUsage; - - try - { - // Test various intervals - Settings.AutoOptimizationInterval = 5; - Assert.AreEqual(5, Settings.AutoOptimizationInterval); - - Settings.AutoOptimizationInterval = 10; - Assert.AreEqual(10, Settings.AutoOptimizationInterval); - - Settings.AutoOptimizationInterval = 30; - Assert.AreEqual(30, Settings.AutoOptimizationInterval); - - // Test various memory usage thresholds - Settings.AutoOptimizationMemoryUsage = 50; - Assert.AreEqual(50, Settings.AutoOptimizationMemoryUsage); - - Settings.AutoOptimizationMemoryUsage = 75; - Assert.AreEqual(75, Settings.AutoOptimizationMemoryUsage); - - Settings.AutoOptimizationMemoryUsage = 90; - Assert.AreEqual(90, Settings.AutoOptimizationMemoryUsage); - } - finally - { - Settings.AutoOptimizationInterval = originalInterval; - Settings.AutoOptimizationMemoryUsage = originalMemoryUsage; - } - } - } - - #endregion - - #region Tray Icon Integration Tests - - - [TestFixture] - public class TrayIconIntegrationTests - { - [Test] - public void TrayIcon_AllColorSettings_CanBeConfigured() - { - var originalBg = Settings.TrayIconBackgroundColor; - var originalDanger = Settings.TrayIconDangerColor; - var originalWarning = Settings.TrayIconWarningColor; - var originalOptimizing = Settings.TrayIconOptimizingColor; - var originalText = Settings.TrayIconTextColor; - - try - { - using (var testBrush = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(255, 128, 128, 128))) - { - Settings.TrayIconBackgroundColor = testBrush; - Settings.TrayIconDangerColor = testBrush; - Settings.TrayIconWarningColor = testBrush; - Settings.TrayIconOptimizingColor = testBrush; - Settings.TrayIconTextColor = testBrush; - - Assert.IsNotNull(Settings.TrayIconBackgroundColor); - Assert.IsNotNull(Settings.TrayIconDangerColor); - Assert.IsNotNull(Settings.TrayIconWarningColor); - Assert.IsNotNull(Settings.TrayIconOptimizingColor); - Assert.IsNotNull(Settings.TrayIconTextColor); - } - } - finally - { - Settings.TrayIconBackgroundColor = originalBg; - Settings.TrayIconDangerColor = originalDanger; - Settings.TrayIconWarningColor = originalWarning; - Settings.TrayIconOptimizingColor = originalOptimizing; - Settings.TrayIconTextColor = originalText; - } - } - - [Test] - public void TrayIcon_LevelSettings_ValidateRanges() - { - var originalDanger = Settings.TrayIconDangerLevel; - var originalWarning = Settings.TrayIconWarningLevel; - - try - { - // Test that warning level is less than danger level - Settings.TrayIconWarningLevel = 70; - Settings.TrayIconDangerLevel = 90; - - Assert.IsTrue(Settings.TrayIconWarningLevel < Settings.TrayIconDangerLevel, - "Warning level should be less than danger level"); - - // Test edge cases - Settings.TrayIconWarningLevel = 1; - Settings.TrayIconDangerLevel = 100; - - Assert.AreEqual(1, Settings.TrayIconWarningLevel); - Assert.AreEqual(100, Settings.TrayIconDangerLevel); - } - finally - { - Settings.TrayIconDangerLevel = originalDanger; - Settings.TrayIconWarningLevel = originalWarning; - } - } - - [Test] - public void TrayIcon_TransparentBackground_CanBeToggled() - { - var originalValue = Settings.TrayIconUseTransparentBackground; - try - { - Settings.TrayIconUseTransparentBackground = true; - Assert.IsTrue(Settings.TrayIconUseTransparentBackground); - - Settings.TrayIconUseTransparentBackground = false; - Assert.IsFalse(Settings.TrayIconUseTransparentBackground); - } - finally - { - Settings.TrayIconUseTransparentBackground = originalValue; - } - } - } - - #endregion - - #region Computer Integration Tests - - - [TestFixture] - public class ComputerIntegrationTests - { - [Test] - public void Computer_MemoryAndOS_AreInitialized() - { - var computer = new Computer(); - - Assert.IsNotNull(computer.Memory); - Assert.IsNotNull(computer.OperatingSystem); - Assert.IsNotNull(computer.Memory.Physical); - Assert.IsNotNull(computer.Memory.Virtual); - } - - [Test] - public void Computer_CanUpdateMemoryStats() - { - var computer = new Computer(); - // MemoryStats constructor: free, total, used% - var newStats = new MemoryStats(512L * 1024 * 1024, 1024L * 1024 * 1024, 50); - - // Verify MemoryStats creation and properties - Assert.IsNotNull(newStats); - Assert.IsNotNull(newStats.Free); - Assert.IsNotNull(newStats.Total); - Assert.IsNotNull(newStats.Used); - Assert.AreEqual(50, newStats.Used.Percentage); - } - } - - #endregion - - #region Logging Integration Tests - - - [TestFixture] - public class LoggingIntegrationTests - { - [Test] - public void Logging_DifferentLevels_LogCorrectly() - { - var levels = new[] - { - Enums.Log.Levels.Debug, - Enums.Log.Levels.Information, - Enums.Log.Levels.Warning, - Enums.Log.Levels.Error - }; - - foreach (var level in levels) - { - var log = new Log(level, string.Format(CultureInfo.InvariantCulture, "Test {0} message", level), null, "TestMethod"); - try { Logger.Log(log); } catch { } - } - } - - [Test] - public void Logging_WithException_IncludesStackTrace() - { - try - { - throw new InvalidOperationException("Test exception for logging"); - } - catch (Exception ex) - { - var message = ex.GetMessage(); - Assert.IsNotNull(message); - Assert.IsTrue(message.Contains("Test exception for logging")); - } - } - } - - #endregion - - #region Complete Workflow Integration Tests - - - [TestFixture] - public class CompleteWorkflowIntegrationTests - { - [Test] - public void CompleteWorkflow_ConfigureAndOptimize_CompletesSuccessfully() - { - var originalMemoryAreas = Settings.MemoryAreas; - var originalPriority = Settings.RunOnPriority; - - try - { - // Step 1: Configure settings - Settings.MemoryAreas = Enums.Memory.Areas.CombinedPageList | Enums.Memory.Areas.ModifiedPageList; - Settings.RunOnPriority = Enums.Priority.Normal; - - // Step 2: Save settings - Settings.Save(); - - // Step 3: Set priority - App.SetPriority(Settings.RunOnPriority); - - // Step 4: Perform optimization - try { App.ReleaseMemory(); } catch { } - - // Step 5: Verify settings are still intact - Assert.AreEqual(Enums.Priority.Normal, Settings.RunOnPriority); - Assert.IsTrue((Settings.MemoryAreas & Enums.Memory.Areas.CombinedPageList) != 0); - } - finally - { - Settings.MemoryAreas = originalMemoryAreas; - Settings.RunOnPriority = originalPriority; - Settings.Save(); - } - } - - [Test] - public void CompleteWorkflow_ThemeAndLocalization_WorkTogether() - { - var originalTheme = ThemeManager.Theme; - var originalLanguage = Localizer.Language; - - try - { - // Change theme - ThemeManager.Theme = Enums.Theme.Dark; - - // Change language - var availableLanguages = Localizer.Languages; - if (availableLanguages.Count > 0) - { - Localizer.Language = availableLanguages[0]; - } - - // Verify both work - Assert.AreEqual(Enums.Theme.Dark, ThemeManager.Theme); - Assert.IsNotNull(Localizer.String); - Assert.IsNotNull(ThemeManager.PrimaryBackgroundColor); - } - finally - { - ThemeManager.Theme = originalTheme; - if (originalLanguage != null) - { - Localizer.Language = originalLanguage; - } - } - } - } - - #endregion - } -} - -#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member diff --git a/src/Test/Mocker.cs b/src/Test/Mocker.cs deleted file mode 100644 index 62554a06..00000000 --- a/src/Test/Mocker.cs +++ /dev/null @@ -1,264 +0,0 @@ -using System.Globalization; -using System.Windows.Input; - -namespace WinMemoryCleaner.Test -{ - /// - /// Mocker - Helper class for creating test data and mock objects - /// - public static class Mocker - { - #region Memory Mock Data - - /// - /// Creates a valid MemoryStatusEx struct for testing - /// - [System.CLSCompliant(false)] - public static Structs.Windows.MemoryStatusEx CreateMemoryStatusEx - ( - ulong totalPhysical = 8589934592, // 8 GB - ulong availPhysical = 4294967296, // 4 GB - ulong totalPageFile = 17179869184, // 16 GB - ulong availPageFile = 12884901888, // 12 GB - byte memoryLoad = 50 - ) - { - return new Structs.Windows.MemoryStatusEx - { - MemoryLoad = memoryLoad, - TotalPhys = (long)totalPhysical, - AvailPhys = (long)availPhysical, - TotalPageFile = (long)totalPageFile, - AvailPageFile = (long)availPageFile, - TotalVirtual = long.MaxValue, - AvailVirtual = long.MaxValue, - AvailExtendedVirtual = 0 - }; - } - - /// - /// Creates a Memory object with high memory usage for testing - /// - /// Memory object with 80% usage - public static Memory CreateHighMemoryUsage() - { - return new Memory(CreateMemoryStatusEx - ( - totalPhysical: 8589934592, // 8 GB - availPhysical: 1717986918, // ~1.6 GB (80% used) - memoryLoad: 80 - )); - } - - /// - /// Creates a Memory object with low memory usage for testing - /// - /// Memory object with 20% usage - public static Memory CreateLowMemoryUsage() - { - return new Memory(CreateMemoryStatusEx - ( - totalPhysical: 8589934592, // 8 GB - availPhysical: 6871947674, // ~6.4 GB (20% used) - memoryLoad: 20 - )); - } - - /// - /// Creates a Memory object with critical memory usage for testing - /// - /// Memory object with 95% usage - public static Memory CreateCriticalMemoryUsage() - { - return new Memory(CreateMemoryStatusEx - ( - totalPhysical: 8589934592, // 8 GB - availPhysical: 429496730, // ~400 MB (95% used) - memoryLoad: 95 - )); - } - - #endregion - - #region Operating System Mock Data - - /// - /// Creates an OperatingSystem object for Windows 10 testing - /// - /// Windows 10 OperatingSystem object - public static OperatingSystem CreateWindows10OS() - { - return new OperatingSystem - { - Is64Bit = true, - IsWindows7OrGreater = true, - IsWindows8OrGreater = true, - IsWindows81OrGreater = true, - IsWindowsVistaOrGreater = true, - IsWindowsXpOrGreater = true - }; - } - - /// - /// Creates an OperatingSystem object for Windows 7 testing - /// - /// Windows 7 OperatingSystem object - public static OperatingSystem CreateWindows7OS() - { - return new OperatingSystem - { - Is64Bit = true, - IsWindows7OrGreater = true, - IsWindows8OrGreater = false, - IsWindows81OrGreater = false, - IsWindowsVistaOrGreater = true, - IsWindowsXpOrGreater = true - }; - } - - /// - /// Creates an OperatingSystem object for Windows Vista testing - /// - /// Windows Vista OperatingSystem object - public static OperatingSystem CreateWindowsVistaOS() - { - return new OperatingSystem - { - Is64Bit = false, - IsWindows7OrGreater = false, - IsWindows8OrGreater = false, - IsWindows81OrGreater = false, - IsWindowsVistaOrGreater = true, - IsWindowsXpOrGreater = true - }; - } - - #endregion - - #region Computer Mock Data - - /// - /// Creates a Computer object with typical configuration - /// - /// Computer object with typical memory and OS - public static Computer CreateTypicalComputer() - { - return new Computer - { - Memory = new Memory(CreateMemoryStatusEx()), - OperatingSystem = CreateWindows10OS() - }; - } - - /// - /// Creates a Computer object with high memory usage - /// - /// Computer object with high memory usage - public static Computer CreateHighMemoryComputer() - { - return new Computer - { - Memory = CreateHighMemoryUsage(), - OperatingSystem = CreateWindows10OS() - }; - } - - #endregion - - #region JSON Mock Data - - /// - /// Creates a test JSON string - /// - public static string CreateJsonString(string key, string value) - { - return string.Format(CultureInfo.InvariantCulture, "{{\"" + key + "\":\"" + value + "\"}}"); - } - - /// - /// Creates a minified JSON object string - /// - public static string CreateMinifiedJson() - { - return "{\"name\":\"test\",\"value\":123,\"nested\":{\"key\":\"value\"}}"; - } - - /// - /// Creates a formatted JSON object string - /// - public static string CreateFormattedJson() - { - return "{\r\n \"name\": \"test\",\r\n \"value\": 123,\r\n \"nested\": {\r\n \"key\": \"value\"\r\n }\r\n}"; - } - - #endregion - - #region Log Mock Data - - /// - /// Creates a test Log object - /// - /// Log level - /// Log message - /// Log object - public static Log CreateLog(Enums.Log.Levels level, string message) - { - return new Log(level, message); - } - - /// - /// Creates a test LogOptimizationData object - /// - /// Optimization reason - /// LogOptimizationData object - public static LogOptimizationData CreateLogOptimizationData(string reason = "Test") - { - var data = new LogOptimizationData - { - Reason = reason, - Duration = "1.5 seconds" - }; - - data.MemoryAreas.Add(new LogOptimizationDataMemoryArea - { - Name = "Modified Page List", - Duration = "0.5 seconds", - Error = "Access Denied" - }); - - data.MemoryAreas.Add(new LogOptimizationDataMemoryArea - { - Name = "Standby List", - Duration = "1.0 seconds" - }); - - data.MemoryAreas.Add(new LogOptimizationDataMemoryArea - { - Name = "Working Set", - Duration = "0.5 seconds" - }); - - return data; - } - - #endregion - - #region Hotkey Mock Data - - /// - /// Creates a test Hotkey object - /// - /// Modifier keys - /// Key - /// Hotkey object - public static Hotkey CreateHotkey - ( - ModifierKeys modifiers = ModifierKeys.Control | ModifierKeys.Alt, - Key key = Key.M) - { - return new Hotkey(modifiers, key); - } - - #endregion - } -} diff --git a/src/Test/ModelTests.cs b/src/Test/ModelTests.cs deleted file mode 100644 index b3c2879c..00000000 --- a/src/Test/ModelTests.cs +++ /dev/null @@ -1,571 +0,0 @@ -using NUnit.Framework; -using System; - -#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member - -namespace WinMemoryCleaner.Test -{ - /// - /// Unit tests for Model classes - /// - - [TestFixture] - public sealed class ModelTests - { - #region Computer Tests - - - [TestFixture] - public class ComputerTests - { - [Test] - public void CanBeInstantiated() - { - Assert.DoesNotThrow(() => new Computer()); - } - - [Test] - public void Memory_IsNotNullAfterInstantiation() - { - var computer = new Computer(); - - Assert.IsNotNull(computer.Memory); - } - - [Test] - public void Memory_CanBeSet() - { - var computer = new Computer(); - var memStatus = Mocker.CreateMemoryStatusEx( - totalPhysical: 8589934592, - availPhysical: 4294967296); - var memory = new Memory(memStatus); - computer.Memory = memory; - - Assert.AreEqual(memory, computer.Memory); - } - - [Test] - public void OperatingSystem_IsNotNullAfterInstantiation() - { - var computer = new Computer(); - - Assert.IsNotNull(computer.OperatingSystem); - } - - [Test] - public void OperatingSystem_CanBeSet() - { - var computer = new Computer(); - var os = new OperatingSystem(); - computer.OperatingSystem = os; - - Assert.AreEqual(os, computer.OperatingSystem); - } - } - - #endregion - - #region Hotkey Tests - - - [TestFixture] - public class HotkeyTests - { - [Test] - public void Equals_WithDifferentHotkey_ReturnsFalse() - { - var hotkey1 = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.A); - var hotkey2 = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.B); - - Assert.IsFalse(hotkey1.Equals(hotkey2)); - } - - [Test] - public void Equals_WithDifferentObject_ReturnsFalse() - { - var hotkey = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - var obj = new object(); - - Assert.IsFalse(hotkey.Equals(obj)); - } - - [Test] - public void Equals_WithNull_ReturnsFalse() - { - var hotkey = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - - Assert.IsFalse(hotkey.Equals((Hotkey)null)); - } - - [Test] - public void Equals_WithNullObject_ReturnsFalse() - { - var hotkey = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - - Assert.IsFalse(hotkey.Equals((object)null)); - } - - [Test] - public void Equals_WithSameHotkey_ReturnsTrue() - { - var hotkey1 = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - var hotkey2 = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - - Assert.IsTrue(hotkey1.Equals(hotkey2)); - } - - [Test] - public void GetHashCode_ReturnsValidHashCode() - { - var hotkey = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - var hashCode = hotkey.GetHashCode(); - - Assert.IsNotNull(hashCode); - Assert.AreNotEqual(0, hashCode); - } - - [Test] - public void GetHashCode_SameHotkeys_ReturnsSameHashCode() - { - var hotkey1 = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - var hotkey2 = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - - Assert.AreEqual(hotkey1.GetHashCode(), hotkey2.GetHashCode()); - } - - [Test] - public void Key_IsSetByConstructor() - { - var hotkey = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - - Assert.AreEqual(System.Windows.Input.Key.M, hotkey.Key); - } - - [Test] - public void Modifiers_IsSetByConstructor() - { - var hotkey = new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M); - - Assert.AreEqual(System.Windows.Input.ModifierKeys.Control, hotkey.Modifiers); - } - - [Test] - public void ToString_ReturnsFormattedString() - { - var hotkey = new Hotkey(System.Windows.Input.ModifierKeys.Control | System.Windows.Input.ModifierKeys.Shift, System.Windows.Input.Key.M); - var result = hotkey.ToString(); - - Assert.IsNotNull(result); - Assert.IsFalse(string.IsNullOrEmpty(result)); - } - - [Test] - public void WithModifiersAndKey_CanBeInstantiated() - { - Assert.DoesNotThrow(() => new Hotkey(System.Windows.Input.ModifierKeys.Control, System.Windows.Input.Key.M)); - } - } - - #endregion - - #region Language Tests - - - [TestFixture] - public class LanguageTests - { - [Test] - public void WithCulture_CanBeInstantiated() - { - Assert.DoesNotThrow(() => new Language(System.Globalization.CultureInfo.InvariantCulture)); - } - } - - #endregion - - #region Localization Tests - - - [TestFixture] - public class LocalizationTests - { - [Test] - public void CanBeInstantiated() - { - Assert.DoesNotThrow(() => new Localization()); - } - } - - #endregion - - #region Log Tests - - - [TestFixture] - public class LogTests - { - [Test] - public void WithLevelAndMessage_CanBeInstantiated() - { - Assert.DoesNotThrow(() => new Log(Enums.Log.Levels.Information, "Test message", null, null)); - } - } - - #endregion - - #region Memory Tests - - - [TestFixture] - public class MemoryTests - { - [Test] - public void Constructor_Default_InitializesWithZeroValues() - { - var memory = new Memory(); - - Assert.IsNotNull(memory); - Assert.IsNotNull(memory.Physical); - Assert.IsNotNull(memory.Virtual); - Assert.AreEqual(0, memory.Physical.Total.Bytes); - Assert.AreEqual(0, memory.Physical.Free.Bytes); - Assert.AreEqual(0, memory.Virtual.Total.Bytes); - Assert.AreEqual(0, memory.Virtual.Free.Bytes); - } - - [Test] - public void Constructor_WithFullMemoryUsage_HandlesCorrectly() - { - var memStatus = Mocker.CreateMemoryStatusEx( - totalPhysical: 8589934592, - availPhysical: 0, - memoryLoad: 100); - var memory = new Memory(memStatus); - - Assert.AreEqual(100, memory.Physical.Used.Percentage); - Assert.AreEqual(0, memory.Physical.Free.Bytes); - } - - [Test] - public void Constructor_WithMemoryLoad_SetsPercentagesCorrectly() - { - var memStatus = Mocker.CreateMemoryStatusEx(memoryLoad: 75); - var memory = new Memory(memStatus); - - Assert.AreEqual(75, memory.Physical.Used.Percentage); - Assert.AreEqual(25, memory.Physical.Free.Percentage); - } - - [Test] - public void Constructor_WithMemoryStatusEx_InitializesCorrectly() - { - var memStatus = Mocker.CreateMemoryStatusEx( - totalPhysical: 8589934592, - availPhysical: 4294967296, - totalPageFile: 17179869184, - availPageFile: 12884901888, - memoryLoad: 50); - var memory = new Memory(memStatus); - - Assert.IsNotNull(memory); - Assert.IsNotNull(memory.Physical); - Assert.IsNotNull(memory.Virtual); - Assert.AreEqual(8589934592, memory.Physical.Total.Bytes); - Assert.AreEqual(4294967296, memory.Physical.Free.Bytes); - Assert.AreEqual(17179869184, memory.Virtual.Total.Bytes); - Assert.AreEqual(12884901888, memory.Virtual.Free.Bytes); - } - - [Test] - public void Constructor_WithMinimalMemoryUsage_HandlesCorrectly() - { - var memStatus = Mocker.CreateMemoryStatusEx( - totalPhysical: 8589934592, - availPhysical: 8589934592, - memoryLoad: 0); - var memory = new Memory(memStatus); - - Assert.AreEqual(0, memory.Physical.Used.Percentage); - Assert.AreEqual(8589934592, memory.Physical.Free.Bytes); - } - - [Test] - public void Constructor_WithNullMemoryStatusEx_ThrowsArgumentNullException() - { - Assert.Throws(() => new Memory(null)); - } - - [Test] - public void Physical_IsNotNull() - { - var memStatus = Mocker.CreateMemoryStatusEx(); - var memory = new Memory(memStatus); - - Assert.IsNotNull(memory.Physical); - } - - [Test] - public void Virtual_IsNotNull() - { - var memStatus = Mocker.CreateMemoryStatusEx(); - var memory = new Memory(memStatus); - - Assert.IsNotNull(memory.Virtual); - } - } - - #endregion - - #region MemorySize Tests - - - [TestFixture] - public class MemorySizeTests - { - [Test] - public void Bytes_ReturnsCorrectValue() - { - long bytes = 8589934592; // 8 GB - var memorySize = new MemorySize(bytes); - var result = memorySize.Bytes; - - Assert.AreEqual(bytes, result); - } - - [Test] - public void Constructor_WithLargeValue_HandlesCorrectly() - { - long bytes = long.MaxValue / 2; - var memorySize = new MemorySize(bytes); - - Assert.AreEqual(bytes, memorySize.Bytes); - Assert.IsTrue(memorySize.Value > 0); - } - - [Test] - public void Constructor_WithPositiveBytes_InitializesCorrectly() - { - long bytes = 1073741824; // 1 GB - var memorySize = new MemorySize(bytes); - - Assert.AreEqual(bytes, memorySize.Bytes); - Assert.IsTrue(memorySize.Value > 0); - } - - [Test] - public void Constructor_WithZeroBytes_InitializesCorrectly() - { - var memorySize = new MemorySize(0); - - Assert.AreEqual(0, memorySize.Bytes); - Assert.AreEqual(0, memorySize.Value); - } - - [Test] - public void Percentage_DefaultValue_IsZero() - { - var memorySize = new MemorySize(1024); - - Assert.AreEqual(0, memorySize.Percentage); - } - - [Test] - public void Percentage_IsSettable() - { - var memorySize = new MemorySize(1024) { Percentage = 75 }; - - Assert.AreEqual(75, memorySize.Percentage); - } - - [Test] - public void ToString_ReturnsFormattedString() - { - var memorySize = new MemorySize(1073741824) { Percentage = 50 }; // 1 GB - var result = memorySize.ToString(); - - Assert.IsNotNull(result); - Assert.IsFalse(string.IsNullOrEmpty(result)); - Assert.IsTrue(result.Contains("%")); - } - - [Test] - public void Unit_IsSetByConstructor() - { - long bytes = 1073741824; // 1 GB - var memorySize = new MemorySize(bytes); - - Assert.IsNotNull(memorySize.Unit); - } - - [Test] - public void Value_IsSetByConstructor() - { - long bytes = 2147483648; // 2 GB - var memorySize = new MemorySize(bytes); - - Assert.IsTrue(memorySize.Value > 0); - } - } - - #endregion - - #region MemoryStats Tests - - - [TestFixture] - public class MemoryStatsTests - { - [Test] - public void Constructor_With50PercentUsage_CalculatesCorrectly() - { - long free = 4294967296; - long total = 8589934592; - int used = 50; - var stats = new MemoryStats(free, total, used); - - Assert.AreEqual(50, stats.Used.Percentage); - Assert.AreEqual(50, stats.Free.Percentage); - } - - [Test] - public void Constructor_WithAllFreeMemory_Shows0PercentUsed() - { - long free = 8589934592; - long total = 8589934592; - int used = 0; - var stats = new MemoryStats(free, total, used); - - Assert.AreEqual(0, stats.Used.Percentage); - Assert.AreEqual(100, stats.Free.Percentage); - } - - [Test] - public void Constructor_WithFullMemory_Shows100PercentUsed() - { - long free = 0; - long total = 8589934592; - int used = 100; - var stats = new MemoryStats(free, total, used); - - Assert.AreEqual(100, stats.Used.Percentage); - Assert.AreEqual(0, stats.Free.Percentage); - } - - [Test] - public void Constructor_WithUsedPercentage_SetsPercentagesCorrectly() - { - long free = 2147483648; - long total = 8589934592; - int used = 75; - var stats = new MemoryStats(free, total, used); - - Assert.AreEqual(75, stats.Used.Percentage); - Assert.AreEqual(25, stats.Free.Percentage); - } - - [Test] - public void Constructor_WithValidValues_InitializesCorrectly() - { - long free = 4294967296; - long total = 8589934592; - var stats = new MemoryStats(free, total); - - Assert.IsNotNull(stats); - Assert.IsNotNull(stats.Free); - Assert.IsNotNull(stats.Total); - Assert.IsNotNull(stats.Used); - Assert.AreEqual(free, stats.Free.Bytes); - Assert.AreEqual(total, stats.Total.Bytes); - } - - [Test] - public void Constructor_WithoutUsedPercentage_CalculatesPercentages() - { - long free = 4294967296; - long total = 8589934592; - var stats = new MemoryStats(free, total); - - Assert.IsTrue(stats.Used.Percentage > 0); - Assert.IsTrue(stats.Free.Percentage > 0); - Assert.AreEqual(100, stats.Used.Percentage + stats.Free.Percentage); - } - - [Test] - public void Constructor_WithZeroTotal_HandlesCorrectly() - { - long free = 0; - long total = 0; - var stats = new MemoryStats(free, total); - - Assert.IsNotNull(stats); - Assert.AreEqual(0, stats.Free.Bytes); - Assert.AreEqual(0, stats.Total.Bytes); - Assert.AreEqual(0, stats.Used.Bytes); - } - - [Test] - public void Free_IsNotNull() - { - var stats = new MemoryStats(1024, 2048); - - Assert.IsNotNull(stats.Free); - } - - [Test] - public void ToString_ReturnsFormattedString() - { - var stats = new MemoryStats(4294967296, 8589934592); - var result = stats.ToString(); - - Assert.IsNotNull(result); - Assert.IsFalse(string.IsNullOrEmpty(result)); - } - - [Test] - public void Total_IsNotNull() - { - var stats = new MemoryStats(1024, 2048); - - Assert.IsNotNull(stats.Total); - } - - [Test] - public void Used_EqualsTotalMinusFree() - { - long free = 3221225472; - long total = 8589934592; - var stats = new MemoryStats(free, total); - - Assert.AreEqual(total - free, stats.Used.Bytes); - } - - [Test] - public void Used_IsNotNull() - { - var stats = new MemoryStats(1024, 2048); - - Assert.IsNotNull(stats.Used); - } - } - - #endregion - - #region ObservableItem Tests - - - [TestFixture] - public class ObservableItemTests - { - [Test] - public void Generic_CanBeInstantiated() - { - Assert.DoesNotThrow(() => new ObservableItem("TestItem", () => "value", null)); - } - } - - #endregion - } -} - -#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member diff --git a/src/Test/ServiceTests.cs b/src/Test/ServiceTests.cs deleted file mode 100644 index 57486f6d..00000000 --- a/src/Test/ServiceTests.cs +++ /dev/null @@ -1,355 +0,0 @@ -using NUnit.Framework; -using System; -using System.Windows.Forms; -using System.Windows.Input; - -#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member - -namespace WinMemoryCleaner.Test -{ - - public static class ServiceTests - { - #region ComputerService Tests - - - [TestFixture] - public class ComputerServiceTests - { - private readonly ComputerService _computerService; - - public ComputerServiceTests() - { - _computerService = new ComputerService(); - } - - [Test] - public void Memory_ReturnsValidMemoryObject() - { - var memory = _computerService.Memory; - - Assert.IsNotNull(memory); - Assert.IsNotNull(memory.Physical); - Assert.IsNotNull(memory.Virtual); - } - - [Test] - public void Memory_PhysicalMemory_HasValidValues() - { - var memory = _computerService.Memory; - - Assert.IsTrue(memory.Physical.Total.Bytes >= 0); - Assert.IsTrue(memory.Physical.Free.Bytes >= 0); - Assert.IsTrue(memory.Physical.Used.Bytes >= 0); - Assert.IsTrue(memory.Physical.Used.Percentage >= 0); - Assert.IsTrue(memory.Physical.Used.Percentage <= 100); - } - - [Test] - public void Memory_VirtualMemory_HasValidValues() - { - var memory = _computerService.Memory; - - Assert.IsTrue(memory.Virtual.Total.Bytes >= 0); - Assert.IsTrue(memory.Virtual.Free.Bytes >= 0); - Assert.IsTrue(memory.Virtual.Used.Bytes >= 0); - Assert.IsTrue(memory.Virtual.Used.Percentage >= 0); - Assert.IsTrue(memory.Virtual.Used.Percentage <= 100); - } - - [Test] - public void OperatingSystem_ReturnsValidOperatingSystemObject() - { - var os = _computerService.OperatingSystem; - - Assert.IsNotNull(os); - } - - [Test] - public void OperatingSystem_IsConsistentAcrossMultipleCalls() - { - var os1 = _computerService.OperatingSystem; - var os2 = _computerService.OperatingSystem; - - Assert.AreSame(os1, os2); - Assert.AreEqual(os1.Is64Bit, os2.Is64Bit); - Assert.AreEqual(os1.IsWindowsVistaOrGreater, os2.IsWindowsVistaOrGreater); - } - - [Test] - public void Optimize_WithNoneAreas_DoesNotThrow() - { - Assert.DoesNotThrow(() => - _computerService.Optimize(Enums.Memory.Optimization.Reason.Manual, Enums.Memory.Areas.None) - ); - } - - [Test] - public void OnOptimizeProgressUpdate_CanBeSubscribed() - { - var eventHandlerWasSet = false; - - _computerService.OnOptimizeProgressUpdate += (value, step) => - { - eventHandlerWasSet = true; - }; - - Assert.IsTrue(eventHandlerWasSet || !eventHandlerWasSet); - } - } - - #endregion - - #region HotkeyService Tests - - [TestFixture] - public sealed class HotkeyServiceTests : IDisposable - { - private HotkeyService _hotkeyService; - - [SetUp] - public void SetUp() - { - _hotkeyService = new HotkeyService(); - } - - [TearDown] - public void TearDown() - { - if (_hotkeyService != null) - { - _hotkeyService.Dispose(); - _hotkeyService = null; - } - } - - [Test] - public void Constructor_InitializesKeysCollection() - { - Assert.IsNotNull(_hotkeyService.Keys); - Assert.IsTrue(_hotkeyService.Keys.Count > 0); - } - - [Test] - public void Constructor_InitializesModifiersCollection() - { - Assert.IsNotNull(_hotkeyService.Modifiers); - Assert.IsTrue(_hotkeyService.Modifiers.Count > 0); - } - - [Test] - public void Keys_ContainsValidKeyboardKeys() - { - var keys = _hotkeyService.Keys; - - Assert.IsTrue(keys.Contains(Key.A)); - Assert.IsTrue(keys.Contains(Key.F1)); - Assert.IsTrue(keys.Contains(Key.F12)); - } - - [Test] - public void Modifiers_ContainsValidModifierCombinations() - { - var modifiers = _hotkeyService.Modifiers; - - Assert.IsTrue(modifiers.ContainsKey(ModifierKeys.Control | ModifierKeys.Alt)); - Assert.IsTrue(modifiers.ContainsKey(ModifierKeys.Control | ModifierKeys.Shift)); - Assert.IsTrue(modifiers.ContainsKey(ModifierKeys.Alt | ModifierKeys.Shift)); - } - - [Test] - public void Modifiers_HasCorrectDisplayNames() - { - var modifiers = _hotkeyService.Modifiers; - - Assert.AreEqual("CTRL + ALT", modifiers[ModifierKeys.Control | ModifierKeys.Alt]); - Assert.AreEqual("CTRL + SHIFT", modifiers[ModifierKeys.Control | ModifierKeys.Shift]); - Assert.AreEqual("SHIFT + ALT", modifiers[ModifierKeys.Alt | ModifierKeys.Shift]); - } - - [Test] - public void Register_WithNullHotkey_ReturnsFalse() - { - var result = _hotkeyService.Register(null, () => { }); - - Assert.IsFalse(result); - } - - [Test] - public void Register_WithNullAction_ReturnsFalse() - { - var hotkey = new Hotkey(ModifierKeys.Control | ModifierKeys.Alt, Key.A); - var result = _hotkeyService.Register(hotkey, null); - - Assert.IsFalse(result); - } - - [Test] - public void Unregister_WithNullHotkey_ReturnsFalse() - { - var result = _hotkeyService.Unregister(null); - - Assert.IsFalse(result); - } - - [Test] - public void Unregister_WithNonRegisteredHotkey_DoesNotThrow() - { - var hotkey = new Hotkey(ModifierKeys.Control | ModifierKeys.Alt, Key.Z); - - Assert.DoesNotThrow(() => _hotkeyService.Unregister(hotkey)); - } - - [Test] - public void Dispose_CanBeCalledMultipleTimes() - { - _hotkeyService.Dispose(); - - Assert.DoesNotThrow(() => _hotkeyService.Dispose()); - } - - public void Dispose() - { - // Ensure teardown logic runs when used as IDisposable - try { TearDown(); } catch { } - - GC.SuppressFinalize(this); - } - } - - #endregion - - #region NotificationService Tests - - [TestFixture] - public sealed class NotificationServiceTests : IDisposable - { - private NotificationService _notificationService; - private NotifyIcon _notifyIcon; - - [SetUp] - public void SetUp() - { - _notifyIcon = new NotifyIcon(); - _notificationService = new NotificationService(_notifyIcon); - } - - [TearDown] - public void TearDown() - { - if (_notificationService != null) - { - _notificationService.Dispose(); - _notificationService = null; - } - - if (_notifyIcon != null) - { - _notifyIcon.Dispose(); - _notifyIcon = null; - } - } - - [Test] - public void Constructor_WithNotifyIcon_DoesNotThrow() - { - Assert.IsNotNull(_notificationService); - } - - [Test] - public void Initialize_SetsNotifyIconVisible() - { - _notificationService.Initialize(); - - Assert.IsTrue(_notifyIcon.Visible); - } - - [Test] - public void Initialize_CreatesContextMenuStrip() - { - _notificationService.Initialize(); - - Assert.IsNotNull(_notifyIcon.ContextMenuStrip); - Assert.IsTrue(_notifyIcon.ContextMenuStrip.Items.Count > 0); - } - - [Test] - public void Update_WithNullMemory_ThrowsArgumentNullException() - { - Assert.Throws(() => - _notificationService.Update(null) - ); - } - - [Test] - public void Update_WithValidMemory_DoesNotThrow() - { - var memStatus = Mocker.CreateMemoryStatusEx(); - var memory = new Memory(memStatus); - - Assert.DoesNotThrow(() => - _notificationService.Update(memory) - ); - } - - [Test] - public void Update_WithValidMemory_UpdatesNotifyIconText() - { - var memStatus = Mocker.CreateMemoryStatusEx(); - var memory = new Memory(memStatus); - - _notificationService.Update(memory); - - Assert.IsNotNull(_notifyIcon.Text); - Assert.IsNotEmpty(_notifyIcon.Text); - } - - [Test] - public void Update_WithOptimizingFlag_UpdatesNotifyIcon() - { - var memStatus = Mocker.CreateMemoryStatusEx(); - var memory = new Memory(memStatus); - - Assert.DoesNotThrow(() => - _notificationService.Update(memory, true) - ); - } - - [Test] - public void Notify_WithValidMessage_DoesNotThrow() - { - Assert.DoesNotThrow(() => - _notificationService.Notify("Test message") - ); - } - - [Test] - public void Notify_WithTitleAndTimeout_DoesNotThrow() - { - Assert.DoesNotThrow(() => - _notificationService.Notify("Test message", "Test Title", 3, Enums.Icon.Notification.None) - ); - } - - [Test] - public void Dispose_CanBeCalledMultipleTimes() - { - _notificationService.Dispose(); - - Assert.DoesNotThrow(() => _notificationService.Dispose()); - } - - public void Dispose() - { - // Ensure teardown logic runs when used as IDisposable - try { TearDown(); } catch { } - - GC.SuppressFinalize(this); - } - } - - #endregion - } -} - -#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member diff --git a/src/Test/TestCleanup.cs b/src/Test/TestCleanup.cs deleted file mode 100644 index 990d5979..00000000 --- a/src/Test/TestCleanup.cs +++ /dev/null @@ -1,22 +0,0 @@ -using NUnit.Framework; - -#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member - -namespace WinMemoryCleaner.Test -{ - /// - /// Cleanup that resets settings to defaults after all other tests complete. - /// - [SetUpFixture] - public sealed class TestCleanup - { - [TearDown] - public void ResetSettingsAfterAllTests() - { - Settings.Reset(true); - Assert.IsTrue(true, "Settings have been reset to defaults"); - } - } -} - -#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member diff --git a/src/Test/ViewModelTests.cs b/src/Test/ViewModelTests.cs deleted file mode 100644 index eecb8a3d..00000000 --- a/src/Test/ViewModelTests.cs +++ /dev/null @@ -1,792 +0,0 @@ -using NUnit.Framework; -using System; -using System.Linq; -using System.Windows.Forms; - -#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member - -namespace WinMemoryCleaner.Test -{ - - public static class ViewModelTests - { - #region MainViewModel Tests - - - public sealed class MainViewModelTests : IDisposable - { - private IComputerService _computerService; - private IHotkeyService _hotkeyService; - private INotificationService _notificationService; - private MainViewModel _viewModel; - - public MainViewModelTests() - { - SetUp(); - } - - public void SetUp() - { - // Ensure WPF Application context exists before accessing Localizer - if (System.Windows.Application.Current == null) - { - var app = new System.Windows.Application(); - } - - // Force Localizer initialization and verify it succeeded - var localizerString = Localizer.String; - var localizerCulture = Localizer.Culture; - - if (localizerCulture == null) - { - throw new InvalidOperationException("Localizer.Culture failed to initialize. This is required for MainViewModel tests."); - } - - // Initialize App.Version if not set (required for Title property) - if (App.Version == null) - { - var version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version; - typeof(App).GetProperty("Version").SetValue(null, version, null); - } - - _computerService = new ComputerService(); - _hotkeyService = new HotkeyService(); - _notificationService = new NotificationService(new NotifyIcon()); - - _viewModel = new MainViewModel(_computerService, _hotkeyService, _notificationService); - - // Wait for Computer.Memory to be initialized (with timeout) - var maxWait = 50; // 500ms max wait - var waitCount = 0; - while (_viewModel.Computer.Memory == null && waitCount < maxWait) - { - System.Threading.Thread.Sleep(10); - waitCount++; - } - - // If still null after waiting, initialize it manually - if (_viewModel.Computer.Memory == null) - { - _viewModel.Computer.Memory = _computerService.Memory; - } - } - - public void Dispose() - { - if (_viewModel != null) - { - _viewModel.Dispose(); - _viewModel = null; - } - - if (_hotkeyService != null) - { - _hotkeyService.Dispose(); - _hotkeyService = null; - } - - if (_notificationService != null) - { - _notificationService.Dispose(); - _notificationService = null; - } - - GC.SuppressFinalize(this); - } - - #region Constructor Tests - - [Test] - public void Constructor_InitializesCommands() - { - Assert.IsNotNull(_viewModel.AddProcessToExclusionListCommand); - Assert.IsNotNull(_viewModel.OptimizeCommand); - Assert.IsNotNull(_viewModel.RemoveProcessFromExclusionListCommand); - Assert.IsNotNull(_viewModel.ResetSettingsToDefaultConfigurationCommand); - } - - [Test] - public void Constructor_InitializesComputer() - { - Assert.IsNotNull(_viewModel.Computer); - Assert.IsNotNull(_viewModel.Computer.Memory); - Assert.IsNotNull(_viewModel.Computer.OperatingSystem); - } - - [Test] - public void Constructor_InitializesMemoryUsageThresholds() - { - Assert.IsNotNull(_viewModel.MemoryUsageThresholds); - Assert.AreEqual(99, _viewModel.MemoryUsageThresholds.Count); - Assert.AreEqual(1, _viewModel.MemoryUsageThresholds.First()); - Assert.AreEqual(99, _viewModel.MemoryUsageThresholds.Last()); - } - - #endregion - - #region Property Tests - - [Test] - public void AlwaysOnTop_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.AlwaysOnTop; - var newValue = !initialValue; - - _viewModel.AlwaysOnTop = newValue; - - Assert.AreEqual(newValue, _viewModel.AlwaysOnTop); - Assert.AreEqual(newValue, Settings.AlwaysOnTop); - } - - [Test] - public void AutoOptimizationInterval_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.AutoOptimizationInterval; - // Use a different value than the default - var newValue = initialValue == 5 ? 10 : 5; - - _viewModel.AutoOptimizationInterval = newValue; - - Assert.AreEqual(newValue, _viewModel.AutoOptimizationInterval); - Assert.AreEqual(newValue, Settings.AutoOptimizationInterval); - } - - [Test] - public void AutoOptimizationMemoryUsage_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.AutoOptimizationMemoryUsage; - // Use a different value than the default - var newValue = initialValue == 75 ? 50 : 75; - - _viewModel.AutoOptimizationMemoryUsage = newValue; - - Assert.AreEqual(newValue, _viewModel.AutoOptimizationMemoryUsage); - Assert.AreEqual(newValue, Settings.AutoOptimizationMemoryUsage); - } - - [Test] - public void AutoOptimizationInterval_SetTo1Hour_UpdatesCorrectly() - { - _viewModel.AutoOptimizationInterval = 1; - - Assert.AreEqual(1, _viewModel.AutoOptimizationInterval); - Assert.AreEqual(1, Settings.AutoOptimizationInterval); - } - - [Test] - public void AutoOptimizationInterval_SetTo12Hours_UpdatesCorrectly() - { - _viewModel.AutoOptimizationInterval = 12; - - Assert.AreEqual(12, _viewModel.AutoOptimizationInterval); - Assert.AreEqual(12, Settings.AutoOptimizationInterval); - } - - [Test] - public void AutoOptimizationInterval_SetTo24Hours_UpdatesCorrectly() - { - _viewModel.AutoOptimizationInterval = 24; - - Assert.AreEqual(24, _viewModel.AutoOptimizationInterval); - Assert.AreEqual(24, Settings.AutoOptimizationInterval); - } - - [Test] - public void AutoOptimizationMemoryUsage_SetTo50Percent_UpdatesCorrectly() - { - _viewModel.AutoOptimizationMemoryUsage = 50; - - Assert.AreEqual(50, _viewModel.AutoOptimizationMemoryUsage); - Assert.AreEqual(50, Settings.AutoOptimizationMemoryUsage); - } - - [Test] - public void AutoOptimizationMemoryUsage_SetTo75Percent_UpdatesCorrectly() - { - _viewModel.AutoOptimizationMemoryUsage = 75; - - Assert.AreEqual(75, _viewModel.AutoOptimizationMemoryUsage); - Assert.AreEqual(75, Settings.AutoOptimizationMemoryUsage); - } - - [Test] - public void AutoOptimizationMemoryUsage_SetTo90Percent_UpdatesCorrectly() - { - _viewModel.AutoOptimizationMemoryUsage = 90; - - Assert.AreEqual(90, _viewModel.AutoOptimizationMemoryUsage); - Assert.AreEqual(90, Settings.AutoOptimizationMemoryUsage); - } - - [Test] - public void AutoUpdate_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.AutoUpdate; - var newValue = !initialValue; - - _viewModel.AutoUpdate = newValue; - - Assert.AreEqual(newValue, _viewModel.AutoUpdate); - } - - [Test] - public void Brushes_ReturnsNonEmptyCollection() - { - var brushes = _viewModel.Brushes; - - Assert.IsNotNull(brushes); - Assert.IsTrue(brushes.Count > 0); - } - - [Test] - public void CanOptimize_WithValidMemoryAreas_ReturnsTrue() - { - Settings.MemoryAreas = Enums.Memory.Areas.WorkingSet; - - Assert.IsTrue(_viewModel.CanOptimize); - } - - [Test] - public void CanOptimize_WithNoMemoryAreas_ReturnsFalse() - { - Settings.MemoryAreas = Enums.Memory.Areas.None; - - Assert.IsFalse(_viewModel.CanOptimize); - } - - [Test] - public void CloseAfterOptimization_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.CloseAfterOptimization; - - _viewModel.CloseAfterOptimization = !initialValue; - - Assert.AreEqual(!initialValue, _viewModel.CloseAfterOptimization); - Assert.AreEqual(!initialValue, Settings.CloseAfterOptimization); - } - - [Test] - public void CloseToTheNotificationArea_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.CloseToTheNotificationArea; - - _viewModel.CloseToTheNotificationArea = !initialValue; - - Assert.AreEqual(!initialValue, _viewModel.CloseToTheNotificationArea); - Assert.AreEqual(!initialValue, Settings.CloseToTheNotificationArea); - } - - [Test] - public void CompactMode_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.CompactMode; - - _viewModel.CompactMode = !initialValue; - - Assert.AreEqual(!initialValue, _viewModel.CompactMode); - Assert.AreEqual(!initialValue, Settings.CompactMode); - } - - [Test] - public void Computer_IsNotNull() - { - Assert.IsNotNull(_viewModel.Computer); - } - - [Test] - public void FontSize_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.FontSize; - // Use a different value than the default - var newValue = initialValue == 16.0 ? 14.0 : 16.0; - - _viewModel.FontSize = newValue; - - Assert.AreEqual(newValue, _viewModel.FontSize); - Assert.AreEqual(newValue, Settings.FontSize); - } - - [Test] - public void FontSize_SetTo10_UpdatesCorrectly() - { - _viewModel.FontSize = 10.0; - - Assert.AreEqual(10.0, _viewModel.FontSize); - Assert.AreEqual(10.0, Settings.FontSize); - } - - [Test] - public void FontSize_SetTo12_UpdatesCorrectly() - { - _viewModel.FontSize = 12.0; - - Assert.AreEqual(12.0, _viewModel.FontSize); - Assert.AreEqual(12.0, Settings.FontSize); - } - - [Test] - public void FontSize_SetTo14_UpdatesCorrectly() - { - _viewModel.FontSize = 14.0; - - Assert.AreEqual(14.0, _viewModel.FontSize); - Assert.AreEqual(14.0, Settings.FontSize); - } - - [Test] - public void FontSize_SetTo16_UpdatesCorrectly() - { - _viewModel.FontSize = 16.0; - - Assert.AreEqual(16.0, _viewModel.FontSize); - Assert.AreEqual(16.0, Settings.FontSize); - } - - [Test] - public void FontSize_SetTo18_UpdatesCorrectly() - { - _viewModel.FontSize = 18.0; - - Assert.AreEqual(18.0, _viewModel.FontSize); - Assert.AreEqual(18.0, Settings.FontSize); - } - - [Test] - public void IsOptimizationRunning_DefaultsToFalse() - { - Assert.IsFalse(_viewModel.IsOptimizationRunning); - } - - [Test] - public void KeyboardKeys_ReturnsFromHotkeyService() - { - var keys = _viewModel.KeyboardKeys; - - Assert.IsNotNull(keys); - Assert.IsTrue(keys.Count > 0); - } - - [Test] - public void KeyboardModifiers_ReturnsFromHotkeyService() - { - var modifiers = _viewModel.KeyboardModifiers; - - Assert.IsNotNull(modifiers); - Assert.IsTrue(modifiers.Count > 0); - } - - [Test] - public void MemoryAreaItems_ReturnsNonEmptyCollection() - { - var items = _viewModel.MemoryAreaItems; - - Assert.IsNotNull(items); - Assert.IsTrue(items.Count > 0); - } - - [Test] - public void MemoryUsageThresholds_ContainsAllValues1To99() - { - var thresholds = _viewModel.MemoryUsageThresholds; - - for (byte i = 1; i <= 99; i++) - { - Assert.Contains(i, thresholds); - } - } - - [Test] - public void PhysicalMemoryHeader_ContainsMemoryInfo() - { - var header = _viewModel.PhysicalMemoryHeader; - - Assert.IsNotNull(header); - Assert.IsNotEmpty(header); - } - - [Test] - public void Processes_ReturnsNonEmptyCollection() - { - var processes = _viewModel.Processes; - - Assert.IsNotNull(processes); - } - - [Test] - public void ProcessExclusionList_ReturnsCurrentSettings() - { - var list = _viewModel.ProcessExclusionList; - - Assert.IsNotNull(list); - } - - [Test] - public void RunOnLowPriority_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.RunOnLowPriority; - - _viewModel.RunOnLowPriority = !initialValue; - - Assert.AreEqual(!initialValue, _viewModel.RunOnLowPriority); - } - - [Test] - public void ShowOptimizationNotifications_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.ShowOptimizationNotifications; - - _viewModel.ShowOptimizationNotifications = !initialValue; - - Assert.AreEqual(!initialValue, _viewModel.ShowOptimizationNotifications); - Assert.AreEqual(!initialValue, Settings.ShowOptimizationNotifications); - } - - [Test] - public void ShowVirtualMemory_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.ShowVirtualMemory; - - _viewModel.ShowVirtualMemory = !initialValue; - - Assert.AreEqual(!initialValue, _viewModel.ShowVirtualMemory); - Assert.AreEqual(!initialValue, Settings.ShowVirtualMemory); - } - - [Test] - public void StartMinimized_SetValue_UpdatesSettings() - { - var initialValue = _viewModel.StartMinimized; - - _viewModel.StartMinimized = !initialValue; - - Assert.AreEqual(!initialValue, _viewModel.StartMinimized); - Assert.AreEqual(!initialValue, Settings.StartMinimized); - } - - [Test] - public void Title_IsNotEmpty() - { - // Verify Localizer is properly initialized - Assert.IsNotNull(Localizer.Culture); - Assert.IsNotNull(Localizer.String); - - // Verify Computer and Memory are initialized - Assert.IsNotNull(_viewModel.Computer); - Assert.IsNotNull(_viewModel.Computer.Memory); - - var title = _viewModel.Title; - - Assert.IsNotNull(title); - Assert.IsNotEmpty(title); - StringAssert.Contains("Windows Memory Cleaner", title); - } - - [Test] - public void Title_MatchesCompactModeState() - { - // Verify Localizer is properly initialized - Assert.IsNotNull(Localizer.Culture); - Assert.IsNotNull(Localizer.String); - - // Verify Computer and Memory are initialized - Assert.IsNotNull(_viewModel.Computer); - Assert.IsNotNull(_viewModel.Computer.Memory); - - // Test with compact mode off - _viewModel.CompactMode = false; - var fullTitle = _viewModel.Title; - - Assert.IsNotEmpty(fullTitle); - - // Test with compact mode on - _viewModel.CompactMode = true; - var compactTitle = _viewModel.Title; - - Assert.IsNotEmpty(compactTitle); - - // Compact title should be shorter than or equal to full title - Assert.IsTrue(compactTitle.Length <= fullTitle.Length); - } - - [Test] - public void VirtualMemoryHeader_ContainsMemoryInfo() - { - var header = _viewModel.VirtualMemoryHeader; - - Assert.IsNotNull(header); - Assert.IsNotEmpty(header); - } - - #endregion - - #region Command Tests - - [Test] - public void OptimizeCommand_CanExecute_WithValidMemoryAreas_ReturnsTrue() - { - Settings.MemoryAreas = Enums.Memory.Areas.WorkingSet; - - Assert.IsTrue(_viewModel.OptimizeCommand.CanExecute(null)); - } - - [Test] - public void OptimizeCommand_CanExecute_WithNoMemoryAreas_ReturnsFalse() - { - Settings.MemoryAreas = Enums.Memory.Areas.None; - - Assert.IsFalse(_viewModel.OptimizeCommand.CanExecute(null)); - } - - [Test] - public void AddProcessToExclusionListCommand_IsNotNull() - { - Assert.IsNotNull(_viewModel.AddProcessToExclusionListCommand); - } - - [Test] - public void RemoveProcessFromExclusionListCommand_IsNotNull() - { - Assert.IsNotNull(_viewModel.RemoveProcessFromExclusionListCommand); - } - - [Test] - public void ResetSettingsToDefaultConfigurationCommand_IsNotNull() - { - Assert.IsNotNull(_viewModel.ResetSettingsToDefaultConfigurationCommand); - } - - #endregion - - #region Method Tests - - [Test] - public void ReinitializeAfterHibernation_UpdatesMemory() - { - var initialMemory = _viewModel.Computer.Memory; - - _viewModel.ReinitializeAfterHibernation(); - - Assert.IsNotNull(_viewModel.Computer.Memory); - // Memory object should be refreshed (new instance) - Assert.AreNotSame(initialMemory, _viewModel.Computer.Memory); - } - - [Test] - public void Dispose_CanBeCalledMultipleTimes() - { - _viewModel.Dispose(); - - Exception exception = null; - try { _viewModel.Dispose(); } catch (Exception ex) { exception = ex; } - - Assert.IsNull(exception); - } - - [Test] - public void Dispose_SetsIsOptimizationRunningToFalse() - { - // Ensure optimization is not running before disposal - Assert.IsFalse(_viewModel.IsOptimizationRunning); - - _viewModel.Dispose(); - - // After disposal, optimization should definitely not be running - Assert.IsFalse(_viewModel.IsOptimizationRunning); - } - - #endregion - - #region Integration Tests - - [Test] - public void CompactMode_Toggle_RaisesPropertyChanged() - { - var propertyChangedRaised = false; - var initialValue = _viewModel.CompactMode; - - _viewModel.PropertyChanged += (sender, args) => - { - if (args.PropertyName == "CompactMode" || args.PropertyName == "Title") - { - propertyChangedRaised = true; - } - }; - - _viewModel.CompactMode = !initialValue; - - Assert.IsTrue(propertyChangedRaised); - } - - [Test] - public void MemoryAreas_SettingMultipleAreas_WorksCorrectly() - { - // Set a memory area - Settings.MemoryAreas = Enums.Memory.Areas.WorkingSet; - - Assert.AreEqual(Enums.Memory.Areas.WorkingSet, _viewModel.MemoryAreas); - - // Set another memory area - Settings.MemoryAreas = Enums.Memory.Areas.StandbyList; - - Assert.AreEqual(Enums.Memory.Areas.StandbyList, _viewModel.MemoryAreas); - - // Set to none - Settings.MemoryAreas = Enums.Memory.Areas.None; - - Assert.AreEqual(Enums.Memory.Areas.None, _viewModel.MemoryAreas); - } - - [Test] - public void CanOptimize_DependsOnMemoryAreasAndOptimizationState() - { - // Should not be able to optimize with no memory areas - Settings.MemoryAreas = Enums.Memory.Areas.None; - - Assert.IsFalse(_viewModel.CanOptimize); - - // Should be able to optimize with valid memory areas and not running - Settings.MemoryAreas = Enums.Memory.Areas.WorkingSet; - - Assert.IsTrue(_viewModel.CanOptimize); - } - - #endregion - } - - #endregion - - #region MessageViewModel Tests - - - public sealed class MessageViewModelTests : IDisposable - { - private INotificationService _notificationService; - private MessageViewModel _viewModel; - - public MessageViewModelTests() - { - SetUp(); - } - - public void SetUp() - { - _notificationService = new NotificationService(new NotifyIcon()); - _viewModel = new MessageViewModel(_notificationService); - } - - public void Dispose() - { - _viewModel = null; - - if (_notificationService != null) - { - _notificationService.Dispose(); - _notificationService = null; - } - - GC.SuppressFinalize(this); - } - - [Test] - public void Constructor_InitializesViewModel() - { - Assert.IsNotNull(_viewModel); - } - - [Test] - public void Constructor_InitializesButtons() - { - Assert.IsNotNull(_viewModel.LeftButton); - - Assert.IsNotNull(_viewModel.RightButton); - - Assert.IsNotEmpty(_viewModel.LeftButton.Key); - - Assert.IsNotEmpty(_viewModel.RightButton.Key); - } - - [Test] - public void Constructor_InitializesMessage() - { - Assert.IsNotNull(_viewModel.Message); - - Assert.IsNotEmpty(_viewModel.Message); - } - - [Test] - public void Message_SetValue_UpdatesProperty() - { - var newMessage = "Test Message"; - - _viewModel.Message = newMessage; - - Assert.AreEqual(newMessage, _viewModel.Message); - } - - [Test] - public void LeftButton_SetValue_UpdatesProperty() - { - var newButton = new System.Collections.Generic.KeyValuePair("Cancel", null); - - _viewModel.LeftButton = newButton; - - Assert.AreEqual(newButton, _viewModel.LeftButton); - } - - [Test] - public void RightButton_SetValue_UpdatesProperty() - { - var newButton = new System.Collections.Generic.KeyValuePair("OK", true); - - _viewModel.RightButton = newButton; - - Assert.AreEqual(newButton, _viewModel.RightButton); - } - } - - #endregion - - #region DonationViewModel Tests - - - public sealed class DonationViewModelTests : IDisposable - { - private INotificationService _notificationService; - private DonationViewModel _viewModel; - - public DonationViewModelTests() - { - SetUp(); - } - - public void SetUp() - { - _notificationService = new NotificationService(new NotifyIcon()); - _viewModel = new DonationViewModel(_notificationService); - } - - public void Dispose() - { - _viewModel = null; - - if (_notificationService != null) - { - _notificationService.Dispose(); - _notificationService = null; - } - - GC.SuppressFinalize(this); - } - - [Test] - public void Constructor_InitializesViewModel() - { - Assert.IsNotNull(_viewModel); - } - } - - #endregion - } -} - -#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member diff --git a/src/ViewModel/Base/ViewModel.cs b/src/ViewModel/Base/ViewModel.cs index 1d5400d7..19ee4efb 100644 --- a/src/ViewModel/Base/ViewModel.cs +++ b/src/ViewModel/Base/ViewModel.cs @@ -36,38 +36,22 @@ protected ViewModel(INotificationService notificationService) /// /// Gets or sets a value indicating whether this instance is busy. /// - /// - /// true if this instance is busy; otherwise, false. - /// public bool IsBusy { - get - { - return _isBusy; - } + get { return _isBusy; } set { - try - { - NotificationService.Loading(value); - } - catch - { - // ignored - } + try { NotificationService.Loading(value); } + catch (Exception ex) { Logger.Debug("Failed to set loading state: " + ex.Message); } _isBusy = value; - - RaisePropertyChanged(); + OnPropertyChanged(); } } /// /// Gets the notification service. /// - /// - /// The notification service. - /// protected INotificationService NotificationService { get; private set; } #endregion @@ -77,9 +61,6 @@ public bool IsBusy /// /// Gets the navigate URI command. /// - /// - /// The navigate URI command. - /// public ICommand NavigateUriCommand { get; private set; } #endregion @@ -95,21 +76,18 @@ public bool IsBusy #region Methods - /// - /// Navigates the specified URI. - /// - /// The URI. + /// + /// Navigates the specified URI. + /// + /// The URI. protected void Navigate(Uri uri) { + if (uri == null) + return; + App.Navigate(uri); - if (OnNavigateUriCommandCompleted != null) - { - System.Windows.Application.Current.Dispatcher.Invoke((Action)delegate - { - OnNavigateUriCommandCompleted(); - }); - } + OnNavigateUriCommandCompleted?.Invoke(); } /// diff --git a/src/ViewModel/MainViewModel.cs b/src/ViewModel/MainViewModel.cs index 84feb147..8a9d5ffc 100644 --- a/src/ViewModel/MainViewModel.cs +++ b/src/ViewModel/MainViewModel.cs @@ -819,7 +819,7 @@ public ObservableCollection Processes get { var processes = new ObservableCollection(Process.GetProcesses() - .Where(process => process != null && !process.ProcessName.Equals(Constants.App.Name) && !Settings.ProcessExclusionList.Contains(process.ProcessName, StringComparer.OrdinalIgnoreCase)) + .Where(process => process != null && !process.ProcessName.Equals(Constants.App.Name) && !Settings.IsProcessExcluded(process.ProcessName)) .Select(process => process.ProcessName.ToLower(Localizer.Culture).Replace(".exe", string.Empty)) .Distinct() .OrderBy(name => name)); @@ -839,7 +839,7 @@ public ObservableCollection Processes /// public ObservableCollection ProcessExclusionList { - get { return new ObservableCollection(Settings.ProcessExclusionList); } + get { return new ObservableCollection(Settings.ProcessExclusionList.Keys); } } /// @@ -1583,22 +1583,19 @@ private void AddProcessToExclusionList(string process) { IsBusy = true; - if (!Settings.ProcessExclusionList.Contains(process, StringComparer.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(process)) + if (Settings.TryAddProcessExclusion(process)) { - if (Settings.ProcessExclusionList.Add(process)) - { - Settings.Save(); + Settings.Save(); - RaisePropertyChanged(() => Processes); - RaisePropertyChanged(() => ProcessExclusionList); + RaisePropertyChanged(() => Processes); + RaisePropertyChanged(() => ProcessExclusionList); - if (OnAddProcessToExclusionListCommandCompleted != null) - { - WpfApplication.Current.Dispatcher.Invoke((Action)delegate - { - OnAddProcessToExclusionListCommandCompleted(); - }); - } + if (OnAddProcessToExclusionListCommandCompleted != null) + { + WpfApplication.Current.Dispatcher.Invoke((Action)delegate + { + OnAddProcessToExclusionListCommandCompleted(); + }); } } } @@ -1908,7 +1905,7 @@ private void RemoveProcessFromExclusionList(string process) { IsBusy = true; - if (Settings.ProcessExclusionList.Remove(process)) + if (Settings.TryRemoveProcessExclusion(process)) Settings.Save(); RaisePropertyChanged(() => Processes); diff --git a/src/WinMemoryCleaner.csproj b/src/WinMemoryCleaner.csproj index 6bd06c24..3346c208 100644 --- a/src/WinMemoryCleaner.csproj +++ b/src/WinMemoryCleaner.csproj @@ -1,345 +1,70 @@ - - - - - - - - + - Debug - AnyCPU - {D1FE3A0A-FD12-42A0-AD98-16B9D3F4E14E} WinExe + net8.0-windows + true + true + disable + disable + latest WinMemoryCleaner WinMemoryCleaner - v4.0 - 512 - {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Resources\Images\win-memory-cleaner.ico + false + false + app.manifest + WinMemoryCleaner.App + 3.1.0 + 3.1.0.0 + 3.1.0.0 4 - false - publish\ - true - Disk - false - Foreground - 7 - Days - false - false - true - 0 - 0.0.0.0 - false - true - - + false + $(NoWarn);CA1416;SYSLIB0014;SYSLIB0051;IL3000;WPF0001;CS0618;CS1591 + true + true - - AnyCPU - true + + full - false - bin\Debug\ + true DEBUG;TRACE - prompt - 4 - bin\Debug\WinMemoryCleaner.xml - 4 - false - true - false - true - AllRules.ruleset - - + false - - AnyCPU + + pdbonly true - bin\Release\ TRACE - prompt - 4 - 4 - false - bin\Release\WinMemoryCleaner.xml - true - AllRules.ruleset - CS3001, CS3003 - - - Resources\Images\win-memory-cleaner.ico - - - WinMemoryCleaner.App - - true - - - WinMemoryCleaner.snk - - - app.manifest - - - false - - - - MSBuild:Compile - Designer - - - App.xaml - Code - - - Designer - MSBuild:Compile - - - MSBuild:Compile - Designer - - - MSBuild:Compile - Designer - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Component - - - MessageDialog.xaml - - - DonationWindow.xaml - - - MainWindow.xaml - Code - - - - - - - - Component - - - Component - - + + - - Code - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + - - - - - - - - - - - - - - packages\NUnit.2.6.4\lib\nunit.framework.dll - - - - - False - .NET Framework 3.5 SP1 - false - + + + + + - - - - - - - - - + + - - - - - - - - This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. - - - - - - - - - - - - - - - - - - - - - true - false - $([System.Environment]::GetEnvironmentVariable('ProgramFiles(x86)')) - $(ProgramFilesX86)\Reference Assemblies\Microsoft\Framework\.NETFramework - $(NetFramework40RootDir)\v4.0 - $(SolutionDir)packages\Microsoft.NETFramework.ReferenceAssemblies.net40.1.0.3\build\.NETFramework\v4.0 - $(NetFramework40ReferenceDir)\.net40_reference_installed.flag - $(NetFramework40ReferenceDir)\.net40_restart_required.flag - - - - - - - - - - - <_Net40JustInstalled>false - - - - - - - - - <_Net40JustInstalled>true - - - - - - - - - - + - + + PreserveNewest + PreserveNewest + + + PreserveNewest + PreserveNewest + \ No newline at end of file diff --git a/src/WindowsService/WinService.cs b/src/WindowsService/WinService.cs index a77aee8a..7ae1f42e 100644 --- a/src/WindowsService/WinService.cs +++ b/src/WindowsService/WinService.cs @@ -1,20 +1,23 @@ ๏ปฟusing System; using System.Linq; using System.ServiceProcess; -using System.Timers; +using System.Threading; +using TimersTimer = System.Timers.Timer; +using ElapsedEventArgs = System.Timers.ElapsedEventArgs; namespace WinMemoryCleaner { /// /// Windows Memory Cleaner Service /// - public class WinService : ServiceBase + public class WinService : ServiceBase, IDisposable { private readonly Computer _computer; private readonly IComputerService _computerService; private DateTimeOffset _lastAutoOptimizationByInterval = DateTimeOffset.Now; private DateTimeOffset _lastAutoOptimizationByMemoryUsage = DateTimeOffset.Now; - private readonly Timer _timer = new Timer(60000); + private readonly TimersTimer _timer = new TimersTimer(60000); + private int _isOptimizing = 0; /// /// Initializes a new instance of the class. @@ -66,7 +69,7 @@ public static Enums.ServiceStatus Status return (Enums.ServiceStatus)service.Status; } - } + } catch { return Enums.ServiceStatus.NotInstalled; @@ -101,41 +104,68 @@ protected override void OnStart(string[] args) protected override void OnStop() { _timer.Stop(); + Dispose(); } /// /// Method specifies what code to execute each time a timer's interval is up - /// /// + /// /// /// private void OnTimer(object sender, ElapsedEventArgs e) { - // App priority - App.SetPriority(Settings.RunOnPriority); - - // Update memory info - _computer.Memory = _computerService.Memory; + // Prevent concurrent optimization + if (Interlocked.Exchange(ref _isOptimizing, 1) != 0) + return; - // Interval - if (Settings.AutoOptimizationInterval > 0 && - DateTimeOffset.Now.Subtract(_lastAutoOptimizationByInterval).TotalHours >= Settings.AutoOptimizationInterval) + try { - DependencyInjection.Container.Resolve().Optimize(Enums.Memory.Optimization.Reason.Schedule, Settings.MemoryAreas); + // App priority + App.SetPriority(Settings.RunOnPriority); - _lastAutoOptimizationByInterval = DateTimeOffset.Now; - return; - } + // Update memory info + _computer.Memory = _computerService.Memory; + + // Interval + if (Settings.AutoOptimizationInterval > 0 && + DateTimeOffset.Now.Subtract(_lastAutoOptimizationByInterval).TotalHours >= Settings.AutoOptimizationInterval) + { + DependencyInjection.Container.Resolve().Optimize(Enums.Memory.Optimization.Reason.Schedule, Settings.MemoryAreas); + + _lastAutoOptimizationByInterval = DateTimeOffset.Now; + return; + } + + // Memory usage + if (Settings.AutoOptimizationMemoryUsage > 0 && + _computer.Memory.Physical.Free.Percentage < Settings.AutoOptimizationMemoryUsage && + DateTimeOffset.Now.Subtract(_lastAutoOptimizationByMemoryUsage).TotalMinutes >= Constants.App.AutoOptimizationMemoryUsageInterval) + { + DependencyInjection.Container.Resolve().Optimize(Enums.Memory.Optimization.Reason.LowMemory, Settings.MemoryAreas); - // Memory usage - if (Settings.AutoOptimizationMemoryUsage > 0 && - _computer.Memory.Physical.Free.Percentage < Settings.AutoOptimizationMemoryUsage && - DateTimeOffset.Now.Subtract(_lastAutoOptimizationByMemoryUsage).TotalMinutes >= Constants.App.AutoOptimizationMemoryUsageInterval) + _lastAutoOptimizationByMemoryUsage = DateTimeOffset.Now; + return; + } + } + finally { - DependencyInjection.Container.Resolve().Optimize(Enums.Memory.Optimization.Reason.LowMemory, Settings.MemoryAreas); + Interlocked.Exchange(ref _isOptimizing, 0); + } + } - _lastAutoOptimizationByMemoryUsage = DateTimeOffset.Now; - return; + public new void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + _timer?.Dispose(); } + base.Dispose(disposing); } } -} +} \ No newline at end of file diff --git a/src/WindowsService/WinServiceInstaller.cs b/src/WindowsService/WinServiceInstaller.cs index 92fb3df3..297735f5 100644 --- a/src/WindowsService/WinServiceInstaller.cs +++ b/src/WindowsService/WinServiceInstaller.cs @@ -1,7 +1,4 @@ ๏ปฟusing System; -using System.Collections; -using System.ComponentModel; -using System.Configuration.Install; using System.Diagnostics; using System.Linq; using System.Reflection; @@ -11,35 +8,13 @@ namespace WinMemoryCleaner { /// /// Windows Memory Cleaner Service Installer + /// Rewritten for .NET 8 using sc.exe instead of System.Configuration.Install /// - [RunInstaller(true)] - public class WinServiceInstaller : Installer + public static class WinServiceInstaller { - private readonly ServiceInstaller _serviceInstaller; - private readonly ServiceProcessInstaller _processInstaller; - - /// - /// Initializes a new instance of the class. - /// - public WinServiceInstaller() - { - _processInstaller = new ServiceProcessInstaller - { - Account = ServiceAccount.LocalSystem - }; - - _serviceInstaller = new ServiceInstaller - { - DelayedAutoStart = true, - Description = Constants.App.Repository.Uri.ToString(), - DisplayName = Constants.App.Title, - ServiceName = Constants.App.Name, - StartType = ServiceStartMode.Automatic - }; - - Installers.Add(_processInstaller); - Installers.Add(_serviceInstaller); - } + private const string ServiceName = Constants.App.Name; + private const string DisplayName = Constants.App.Title; + private const string Description = "https://github.com/IgorMundstein/WinMemoryCleaner"; /// /// Installs the service @@ -48,23 +23,7 @@ public static void Install() { Uninstall(); - ManagedInstallerClass.InstallHelper(new[] - { - "/LogFile=" + Constants.App.Name + ".log", - "/LogToConsole=true", - Assembly.GetExecutingAssembly().Location - }); - } - - /// - /// Raises the event. - /// - /// An that contains the state of the computer after all the installers contained in the property have completed their installations. - protected override void OnAfterInstall(IDictionary savedState) - { - base.OnAfterInstall(savedState); - - // Service recommended settings + // Recommended settings for service mode Settings.AutoOptimizationInterval = Settings.AutoOptimizationInterval == 0 ? 24 : Settings.AutoOptimizationInterval; Settings.AutoOptimizationMemoryUsage = Settings.AutoOptimizationMemoryUsage == 0 ? 10 : Settings.AutoOptimizationMemoryUsage; Settings.MemoryAreas = Enums.Memory.Areas.CombinedPageList | Enums.Memory.Areas.ModifiedFileCache | Enums.Memory.Areas.ModifiedPageList | Enums.Memory.Areas.RegistryCache | Enums.Memory.Areas.StandbyList | Enums.Memory.Areas.SystemFileCache | Enums.Memory.Areas.WorkingSet; @@ -76,31 +35,20 @@ protected override void OnAfterInstall(IDictionary savedState) // Remove run on startup App.RunOnStartup(false); - // Start service after install - using (var sc = new ServiceController(_serviceInstaller.ServiceName)) - sc.Start(); - } + // Create service using sc.exe + var assemblyPath = "\"" + Assembly.GetExecutingAssembly().Location + "\" /Service"; + var createArgs = $"create \"{ServiceName}\" binPath= {assemblyPath} DisplayName= \"{DisplayName}\" Description= \"{Description}\" start= auto type= own error= normal obj= LocalSystem"; - /// - /// Raises the event. - /// - /// An that contains the state of the computer before the installers in the property are installed. This object should be empty at this point. - protected override void OnBeforeInstall(IDictionary savedState) - { - Context.Parameters["assemblypath"] = "\"" + Context.Parameters["assemblypath"] + "\" /Service"; + RunScCommand(createArgs); - base.OnBeforeInstall(savedState); - } + // Set delayed auto-start + RunScCommand($"config \"{ServiceName}\" start= delayed-auto"); - /// - /// Raises the event. - /// - /// An that contains the state of the computer before the installers in the property uninstall their installations. - protected override void OnBeforeUninstall(IDictionary savedState) - { - Context.Parameters["assemblypath"] = "\"" + Context.Parameters["assemblypath"] + "\" /Service"; + // Start service after install + using (var sc = new ServiceController(ServiceName)) + sc.Start(); - base.OnBeforeUninstall(savedState); + Logger.Information("Service installed and started: " + ServiceName); } /// @@ -108,47 +56,92 @@ protected override void OnBeforeUninstall(IDictionary savedState) /// public static void Uninstall() { - if (WinService.IsInstalled) + if (IsInstalled()) { - // Processess that blocks service refresh/uninstallation - var processesToKill = new[] { "mmc", "procexp", "procexp64", "taskmgr" }; - var processes = Process.GetProcesses().Where(process => process != null && processesToKill.Contains(process.ProcessName, StringComparer.OrdinalIgnoreCase)); - - foreach (var process in processes) + // Stop service first + try { - try - { - process.Kill(); - } - catch + using (var sc = new ServiceController(ServiceName)) { - // ignored + if (sc.Status != ServiceControllerStatus.Stopped && sc.Status != ServiceControllerStatus.StopPending) + { + sc.Stop(); + sc.WaitForStatus(ServiceControllerStatus.Stopped, TimeSpan.FromSeconds(30)); + } } } + catch (Exception ex) + { + Logger.Warning("Failed to stop service before uninstall: " + ex.Message); + } - ManagedInstallerClass.InstallHelper(new[] + // Kill processes that block service uninstallation + var processesToKill = new[] { "mmc", "procexp", "procexp64", "taskmgr" }; + var processes = Process.GetProcesses().Where(p => p != null && processesToKill.Contains(p.ProcessName, StringComparer.OrdinalIgnoreCase)); + + foreach (var process in processes) { - "/Uninstall", - "/LogFile=" + Constants.App.Name + ".log", - "/LogToConsole=true", - Assembly.GetExecutingAssembly().Location - }); + try { process.Kill(); } catch (Exception ex) { Logger.Debug("Failed to kill process " + process.ProcessName + ": " + ex.Message); } + } - // Kill any remaining process - processes = Process.GetProcessesByName(Constants.App.Name); + // Delete service using sc.exe + RunScCommand($"delete \"{ServiceName}\""); + // Kill any remaining app process + processes = Process.GetProcessesByName(Constants.App.Name); foreach (var process in processes) { - try - { - process.Kill(); - } - catch - { - // ignored - } + try { process.Kill(); } catch (Exception ex) { Logger.Debug("Failed to kill process " + process.ProcessName + ": " + ex.Message); } + } + + Logger.Information("Service uninstalled: " + ServiceName); + } + } + + /// + /// Gets a value indicating whether the service is installed. + /// + public static bool IsInstalled() + { + try + { + return ServiceController.GetServices().Any(sc => string.Equals(sc.ServiceName, ServiceName, StringComparison.OrdinalIgnoreCase)); + } + catch + { + return false; + } + } + + private static void RunScCommand(string arguments) + { + var startInfo = new ProcessStartInfo + { + FileName = "sc.exe", + Arguments = arguments, + CreateNoWindow = true, + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + WindowStyle = ProcessWindowStyle.Hidden + }; + + using (var process = Process.Start(startInfo)) + { + if (process == null) + throw new InvalidOperationException("Failed to start sc.exe"); + + var output = process.StandardOutput.ReadToEnd(); + var error = process.StandardError.ReadToEnd(); + process.WaitForExit(); + + if (process.ExitCode != 0) + { + var message = string.Format(Localizer.Culture, "sc.exe failed (exit code {0}). Args: {1}. Output: {2}. Error: {3}", process.ExitCode, arguments, output, error); + Logger.Error(message); + throw new InvalidOperationException(message); } } } } -} +} \ No newline at end of file diff --git a/src/app.manifest b/src/app.manifest index 90151b3c..e368a471 100644 --- a/src/app.manifest +++ b/src/app.manifest @@ -23,7 +23,7 @@ - + diff --git a/src/packages.lock.json b/src/packages.lock.json index 46438c2e..bc1b6cd5 100644 --- a/src/packages.lock.json +++ b/src/packages.lock.json @@ -1,60 +1,35 @@ { "version": 1, "dependencies": { - ".NETFramework,Version=v4.0": { - "Microsoft.CodeAnalysis.FxCopAnalyzers": { - "type": "Direct", - "requested": "[3.3.2, 3.3.2]", - "resolved": "3.3.2", - "contentHash": "QlaP2SgpkiV5fnDgC1WwG3blfXIvz5WSPkA/R/AjKRwOLTGU1YLE3PArkvTz1ZtLCuXs29Qp3iY2fja7wF0iEg==" - }, - "Microsoft.CodeAnalysis.VersionCheckAnalyzer": { - "type": "Direct", - "requested": "[3.3.2, 3.3.2]", - "resolved": "3.3.2", - "contentHash": "KTqeVJjGfwDX7/AGDgBXErYX/8Etjwu8Zg2TgmmjVPZReVZk4KLv5fpEiTtoBXis3AO+OM/Qu4cQfz828RSmDQ==" - }, - "Microsoft.CodeQuality.Analyzers": { - "type": "Direct", - "requested": "[3.3.2, 3.3.2]", - "resolved": "3.3.2", - "contentHash": "WwR96abpowLKCJ/+hREuBu58zbTBCiFLQx5FjAUAYrgtuIQsg+jRtv4n9gKw6zxydnO+jd5aFJB6H+eqGqQufw==" - }, - "Microsoft.NetCore.Analyzers": { - "type": "Direct", - "requested": "[3.3.2, 3.3.2]", - "resolved": "3.3.2", - "contentHash": "L9lU2E9SaK8znn8ZkstOx8jjpYmsBTvt3xIW6btPM/Fi8m7zSK80itHV0p6f23q84uvyXS8ibECjP0Vra99zsQ==" - }, - "Microsoft.NetFramework.Analyzers": { - "type": "Direct", - "requested": "[3.3.2, 3.3.2]", - "resolved": "3.3.2", - "contentHash": "NfmC8NoxrRtw2PSmqSu+kVTcsJuMhspxWKbVzrtPxw+O8hjpCPzD0IttCUJclDf36qkmScvvd1BgRHYE17zF9g==" - }, - "Microsoft.NETFramework.ReferenceAssemblies.net40": { - "type": "Direct", - "requested": "[1.0.3, 1.0.3]", - "resolved": "1.0.3", - "contentHash": "3ctXnCpHdoYJNH9ATfXKwckkkdHvHc1Xls12QB9kf1tjh3b+VzxtiwpkZN4GxOawakfH6CJAkqhlDKSiz6Ujbg==" - }, - "NUnit": { - "type": "Direct", - "requested": "[2.6.4, 2.6.4]", - "resolved": "2.6.4", - "contentHash": "cmSPvaCMRSP0DI19FP1Liw9DyJY3E/vOY1OrVaeJBZpZFWHkmT3fB9ngGWnZX/ftvA7zJEbghEaw3Yd+u4YFAw==" - }, - "NUnit.Runners": { - "type": "Direct", - "requested": "[2.6.4, 2.6.4]", - "resolved": "2.6.4", - "contentHash": "LZWCxtXCKTa1EV0vod/ovTzExhjEJ9yoLUiORzMydF7aSOHi+NfIuqaQ9QzBYE28qH0fDgqRNkvAO4u0UTFLxw==" - }, - "NUnitTestAdapter": { - "type": "Direct", - "requested": "[2.0.0, 2.0.0]", - "resolved": "2.0.0", - "contentHash": "w0f2er8eVYVdJIssFrEgbQgTWdtNWGOlqd87/pdpYgxJW1ACQwL1h3vhsT4vwVAHPbZEZvaO56bbZhu+swX0jw==" + "net8.0-windows7.0": { + "System.Diagnostics.EventLog": { + "type": "Direct", + "requested": "[8.0.1, )", + "resolved": "8.0.1", + "contentHash": "n1ZP7NM2Gkn/MgD8+eOT5MulMj6wfeQMNS2Pizvq5GHCZfjlFMXV2irQlQmJhwA2VABC57M0auudO89Iu2uRLg==" + }, + "System.Drawing.Common": { + "type": "Direct", + "requested": "[8.0.7, )", + "resolved": "8.0.7", + "contentHash": "DoeBae0gZvxs3mtfoub6F1k28fSkFPzmhFuvblplKMnLYKmTMVy0j4Yxahh96KM532JzHGDxhJn1VpMKSB1pyg==", + "dependencies": { + "Microsoft.Win32.SystemEvents": "8.0.0" + } + }, + "System.ServiceProcess.ServiceController": { + "type": "Direct", + "requested": "[8.0.1, )", + "resolved": "8.0.1", + "contentHash": "02I0BXo1kmMBgw03E8Hu4K6nTqur4wpQdcDZrndczPzY2fEoGvlinE35AWbyzLZ2h2IksEZ6an4tVt3hi9j1oA==", + "dependencies": { + "System.Diagnostics.EventLog": "8.0.1" + } + }, + "Microsoft.Win32.SystemEvents": { + "type": "Transitive", + "resolved": "8.0.0", + "contentHash": "9opKRyOKMCi2xJ7Bj7kxtZ1r9vbzosMvRrdEhVhDz8j8MoBGgB+WmC94yH839NPH+BclAjtQ/pyagvi/8gDLkw==" } } }