Update June 22, 2026: The IOSP Analyzer is now available for the following platforms and languages:
- JetBrains Rider, C#
- JetBrains ReSharper, C#
- Roslyn Analyzer (Visual Studio Code), C#
- JetBrains Idea, Java
- JetBrains PyCharm, Python
The installation and configuration described below is the same for all JetBrains IDEs.
——————-
I have been around for a long time Roslyn Analyzer for detecting IOSP violations. On the one hand I have updated it, on the other hand there is now also a Plugin for Rider.
The integration in Rider has numerous advantages. Above all, it is now much easier to configure the analyzer. After installing the plugin, there is a settings page in Rider. The following settings can be made on this page:
- Metric - This can be used to determine how serious the IOSP violation must be to display it as a warning.
- Exclude test methods - A simple checkbox can now be used to exclude test methods from the analysis.
- Ignore Namespaces – You can create a list of namespaces whose methods will be ignored in the analysis. A distinction is made between namespaces in the
- Production Code vs.
- Test code
There are therefore two options available for tests: either exclude tests entirely from the analysis, or specify the namespaces that should be ignored. For tests, these include at least the namespaces of the test and mock frameworks being used
In addition, you can use Settings – Editor – Inspection Settings – Inspection Severity – C# – IOSP Violation It can be determined whether the injuries are Error, Warning, Suggestion or Hint should be displayed.
The plugin is available via the JetBrains Marketplace. The installation is done as follows:
- In your IDE, go to Settings - Plugins
- Select above Marketplace
- Search for IOSP
- Go right to Install
Rider, Idea, PyCharm, etc., will then flag violations of the Integration Operation Segregation Principle (IOSP).
By default, injuries are classified as Warning displayed. This means that the method name is highlighted in color.
In the illustration, you can see that the name of the method, in this case „Start“, is highlighted in color. In addition, a tooltip is displayed with the mouse pointer, indicating which parts have been evaluated as an integration or operation.
The metric = 2 indicates that it is a manageable violation that can be ignored if necessary. The integration part predominates here. Only the expression 30*1000 must be assigned to an operation. Below is the source text:
public void Start(Action<IAsyncEnumerable> onUpdate) {
new TimerProvider().ExecutePeriodic(30*1000, () => {
var symbols = _favoritenProvider.FavoritenLaden();
var securities = _kursProvider.KurseErmitteln(symbols);
onUpdate(securities);
});
}
The problem could be solved by changing the expression 30*1000 into a constant.
Conclusion
For me, the IOSP is the most important Clean Code principle for achieving readable and testable code. The IOSP Analyzer flags all places in the code where this principle is violated. This allows me to take targeted refactoring measures to improve code quality.
English 
German