Fix ScottPlot WpfPlotGL FileNotFoundException in .NET 10.0

ScottPlot WpfPlotGL .NET 10.0 FileNotFoundException occurs when there’s a compatibility issue between OpenTK version 3.3.1.0 and .NET 10.0. This exception typically happens when loading the WpfPlotGL control, specifically in the SkiaSharp.Views.WPF.SKGLElement.OnPaint method. The primary solution involves targeting a compatible .NET version or updating to a newer ScottPlot release that supports .NET 10.0.

Contents

• Understanding the ScottPlot WpfPlotGL Compatibility Issue
• Root Causes of the FileNotFoundException
• Step-by-Step Solutions
• Alternative Approaches
• Best Practices for ScottPlot WPF Development
• Conclusion

Understanding the ScottPlot WpfPlotGL Compatibility Issue

The System.IO.FileNotFoundException you’re encountering with ScottPlot WpfPlotGL and .NET 10.0 is a well-documented compatibility issue. When working with ScottPlot version 5.1.57 on net10.0-windows, the application attempts to load OpenTK version 3.3.1.0, which may not be compatible with .NET 10.0. The error message “Could not load file or assembly ‘OpenTK, Version=3.3.1.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4’” indicates that the .NET runtime cannot find or load the required OpenTK assembly.

This issue specifically manifests during rendering operations, as indicated by your call stack showing the problem in SkiaSharp.Views.WPF.SKGLElement.OnPaint. The combination of ScottPlot.WPF 5.1.57 and OpenTK.GLWpfControl 4.3.3 creates version conflicts when targeting .NET 10.0, particularly on Windows 11 systems. Understanding this compatibility landscape is the first step toward resolving the issue.

Root Causes of the FileNotFoundException

Several factors contribute to this compatibility problem between ScottPlot WpfPlotGL and .NET 10.0:

Framework Version Mismatch

The primary issue stems from version mismatches between the target .NET framework and the dependencies. ScottPlot 5.1.57 was designed primarily for .NET 6.0 and earlier versions, which have different assembly loading behaviors compared to .NET 10.0. When you target .NET 10.0, the runtime attempts to load dependencies that may not have been compiled or tested against this newer framework version.

OpenTK Compatibility Issues

OpenTK version 3.3.1.0, which ScottPlot depends on, may not be fully compatible with .NET 10.0. The OpenTK library has its own versioning scheme and may require updates to work with newer .NET versions. Additionally, the Strong Name Key (PublicKeyToken) mismatch you’re seeing suggests that the expected version of OpenTK cannot be located by the assembly loader.

SkiaSharp Integration Challenges

The call stack indicates the issue occurs in SkiaSharp.Views.WPF.SKGLElement.OnPaint, suggesting that the problem extends beyond just OpenTK to include SkiaSharp integration. SkiaSharp, another critical dependency of ScottPlot, may also have compatibility issues with .NET 10.0 when used through OpenGL contexts provided by WPF.

Assembly Loading Strategy Changes

.NET 10.0, like other recent .NET versions, has evolved its assembly loading strategy. Changes in how dependencies are resolved and loaded can cause exceptions when older libraries expect different loading behaviors. This is particularly relevant when mixing libraries from different .NET eras.

Step-by-Step Solutions

Solution 1: Downgrade to Compatible .NET Version

The most straightforward solution is to modify your project to target a compatible .NET version instead of .NET 10.0. This approach is recommended by the official ScottPlot documentation.

Steps:

1. Right-click on your project in Visual Studio and select “Edit Project File”
2. Change the TargetFramework from <TargetFramework>net10.0-windows</TargetFramework> to <TargetFramework>net6.0-windows</TargetFramework>
3. Save the file and allow NuGet to restore packages
4. Rebuild your solution

This solution works because ScottPlot 5.1.57 was specifically designed and tested against .NET 6.0, which has better compatibility with the underlying OpenTK and SkiaSharp dependencies.

Solution 2: Update to ScottPlot 6.0

If you need to use .NET 10.0, consider upgrading to ScottPlot 6.0, which may have better .NET 10.0 support. Check the ScottPlot GitHub repository for the latest version information and compatibility notes.

Steps:

1. Update your ScottPlot.WPF package to the latest version (6.0 or higher)
2. Update OpenTK.GLWpfControl to a compatible version (check the package documentation)
3. Update SkiaSharp to the latest version compatible with .NET 10.0
4. Rebuild and test your application

Solution 3: Configure Assembly Binding Redirects

If you must use .NET 10.0 but can’t upgrade ScottPlot, you can configure assembly binding redirects to handle the OpenTK version mismatch.

Steps:

1. Add the following configuration to your app.config file:

<configuration>
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="OpenTK" 
                          publicKeyToken="bad199fe84eb3df4" 
                          culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-3.3.1.0" 
                         newVersion="4.3.3.0" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
</configuration>

2. Replace “4.3.3.0” with the actual version of OpenTK.GLWpfControl you have installed
3. Rebuild your solution

This solution redirects the assembly loader to use the newer version of OpenTK when the older version is requested.

Solution 4: Use Native AOT Compatibility Mode

For .NET 10.0 applications, you may need to adjust the Native AOT compatibility settings.

Steps:

1. In your project file, add or modify the following property:

<PropertyGroup>
  <PublishAot>false</PublishAot>
  <EnableTrimAnalyzer>false</EnableTrimAnalyzer>
</PropertyGroup>

2. Rebuild your solution

This prevents the Native AOT compiler from removing dependencies that ScottPlot requires at runtime.

Solution 5: Manually Install Required OpenTK Version

If binding redirects don’t work, you can manually install the specific OpenTK version that ScottPlot expects.

Steps:

1. Install the specific OpenTK version via NuGet:

Install-Package OpenTK -Version 3.3.1.0

2. If that version isn’t available, try installing OpenTK.GLWpfControl with the specific version:

Install-Package OpenTK.GLWpfControl -Version 4.3.3

3. Rebuild your solution

Alternative Approaches

Use ScottPlot FormsPlotGL Instead

If WpfPlotGL continues to cause issues, consider using ScottPlot’s FormsPlotGL control instead. This control may have better compatibility with your .NET 10.0 setup.

Implementation Steps:

1. Remove the WpfPlotGL reference from your project
2. Add a reference to ScottPlot.WinForms
3. Replace WpfPlotGL with FormsPlotGL in your XAML
4. Configure the control in your code-behind

Implement a Compatibility Layer

For more complex applications, you can implement a compatibility layer that handles the assembly loading issues:

public static class ScottPlotCompatibility
{
    public static void Initialize()
    {
        AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
        {
            var requestedAssembly = new AssemblyName(args.Name);
            
            if (requestedAssembly.Name == "OpenTK")
            {
                // Load the newer version of OpenTK
                return Assembly.LoadFrom("path/to/OpenTK.dll");
            }
            
            return null;
        };
    }
}

// Call this from your application startup
ScottPlotCompatibility.Initialize();

Use Docker for Isolation

If you’re experiencing consistent .NET 10.0 compatibility issues, consider running your application in a Docker container with a compatible .NET version:

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "YourApplication.dll"]

Best Practices for ScottPlot WPF Development

Version Alignment Strategy

When working with ScottPlot WPF, ensure all related packages are version-aligned:

1. Use the same major version of ScottPlot across all dependencies
2. Verify that OpenTK, SkiaSharp, and ScottPlot versions are compatible
3. Check the ScottPlot GitHub issues for known compatibility problems

Testing Across Framework Versions

Test your ScottPlot WPF applications across multiple .NET framework versions:

1. Create a test matrix with different .NET versions (6.0, 7.0, 8.0, etc.)
2. Verify that rendering works correctly in each environment
3. Pay special attention to OpenGL-related functionality

Dependency Management

Implement robust dependency management practices:

1. Use package managers like NuGet with version constraints
2. Regularly update dependencies to address compatibility issues
3. Consider using dependency injection for better control over ScottPlot initialization

Error Handling

Implement comprehensive error handling for ScottPlot WPF controls:

try
{
    var plot = new WpfPlotGL();
    plot.Render();
}
catch (FileNotFoundException ex)
{
    // Handle missing assembly errors
    Logger.LogError($"ScottPlot dependency not found: {ex.Message}");
    // Show user-friendly error message
}
catch (Exception ex)
{
    // Handle other rendering errors
    Logger.LogError($"ScottPlot rendering error: {ex.Message}");
}

Performance Considerations

Optimize ScottPlot WPF performance in your .NET 10.0 applications:

1. Limit the number of plot instances to reduce memory usage
2. Implement efficient data update strategies
3. Consider using hardware acceleration when available

Conclusion

The System.IO.FileNotFoundException when using ScottPlot WpfPlotGL with .NET 10.0 is primarily a compatibility issue between the library dependencies and the newer .NET framework. By targeting a compatible .NET version like .NET 6.0, updating to ScottPlot 6.0, or configuring proper assembly binding redirects, you can resolve this exception and ensure your WPF plotting applications function correctly. Always check the latest ScottPlot documentation and GitHub issues for the most current compatibility information, as the ScottPlot team continues to improve .NET 10.0 support with each release.

Sources

• ScottPlot GitHub Issue: An exception occurred when using WpfPlotGL
• ScottPlot GitHub Issue: SP5: Remove OpenTK
• ScottPlot dependencies - ScottPlot FAQ
• ScottPlot GitHub Issue: ScottPlot5: WPF sandbox throws exception due to OpenTK version
• FileNotFoundException Class (System.IO) - Microsoft Docs
• ScottPlot.WPF NuGet Package