morrisjdev/FileContextCore

View on GitHub
FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs

Summary

Maintainability
A
0 mins
Test Coverage

File FileContextLinqOperatorProvider.cs has 342 lines of code (exceeds 250 allowed). Consider refactoring.
Wontfix

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Microsoft.EntityFrameworkCore.Utilities;
Severity: Minor
Found in FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs - About 4 hrs to fix

    Similar blocks of code found in 8 locations. Consider refactoring.
    Wontfix

                MaxWithoutSelectorMethods = new Dictionary<Type, MethodInfo>
                {
                    { typeof(decimal), getSumOrAverageWithoutSelector<decimal>(nameof(Queryable.Max)) },
                    { typeof(long), getSumOrAverageWithoutSelector<long>(nameof(Queryable.Max)) },
                    { typeof(int), getSumOrAverageWithoutSelector<int>(nameof(Queryable.Max)) },
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 268..280
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 282..294
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 310..322
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 324..336
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 338..350
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 352..364
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 366..378

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 305.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 8 locations. Consider refactoring.
    Wontfix

                MinWithSelectorMethods = new Dictionary<Type, MethodInfo>
                {
                    { typeof(decimal), getSumOrAverageWithSelector<decimal>(nameof(Queryable.Min)) },
                    { typeof(long), getSumOrAverageWithSelector<long>(nameof(Queryable.Min)) },
                    { typeof(int), getSumOrAverageWithSelector<int>(nameof(Queryable.Min)) },
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 268..280
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 282..294
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 296..308
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 310..322
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 324..336
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 352..364
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 366..378

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 305.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 8 locations. Consider refactoring.
    Wontfix

                SumWithoutSelectorMethods = new Dictionary<Type, MethodInfo>
                {
                    { typeof(decimal), getSumOrAverageWithoutSelector<decimal>(nameof(Queryable.Sum)) },
                    { typeof(long), getSumOrAverageWithoutSelector<long>(nameof(Queryable.Sum)) },
                    { typeof(int), getSumOrAverageWithoutSelector<int>(nameof(Queryable.Sum)) },
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 268..280
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 282..294
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 296..308
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 310..322
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 324..336
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 338..350
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 366..378

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 305.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 8 locations. Consider refactoring.
    Wontfix

                AverageWithoutSelectorMethods = new Dictionary<Type, MethodInfo>
                {
                    { typeof(decimal), getSumOrAverageWithoutSelector<decimal>(nameof(Queryable.Average)) },
                    { typeof(long), getSumOrAverageWithoutSelector<long>(nameof(Queryable.Average)) },
                    { typeof(int), getSumOrAverageWithoutSelector<int>(nameof(Queryable.Average)) },
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 282..294
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 296..308
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 310..322
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 324..336
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 338..350
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 352..364
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 366..378

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 305.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 8 locations. Consider refactoring.
    Wontfix

                MinWithoutSelectorMethods = new Dictionary<Type, MethodInfo>
                {
                    { typeof(decimal), getSumOrAverageWithoutSelector<decimal>(nameof(Queryable.Min)) },
                    { typeof(long), getSumOrAverageWithoutSelector<long>(nameof(Queryable.Min)) },
                    { typeof(int), getSumOrAverageWithoutSelector<int>(nameof(Queryable.Min)) },
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 268..280
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 282..294
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 296..308
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 310..322
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 338..350
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 352..364
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 366..378

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 305.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 8 locations. Consider refactoring.
    Wontfix

                AverageWithSelectorMethods = new Dictionary<Type, MethodInfo>
                {
                    { typeof(decimal), getSumOrAverageWithSelector<decimal>(nameof(Queryable.Average)) },
                    { typeof(long), getSumOrAverageWithSelector<long>(nameof(Queryable.Average)) },
                    { typeof(int), getSumOrAverageWithSelector<int>(nameof(Queryable.Average)) },
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 268..280
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 296..308
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 310..322
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 324..336
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 338..350
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 352..364
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 366..378

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 305.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 8 locations. Consider refactoring.
    Wontfix

                MaxWithSelectorMethods = new Dictionary<Type, MethodInfo>
                {
                    { typeof(decimal), getSumOrAverageWithSelector<decimal>(nameof(Queryable.Max)) },
                    { typeof(long), getSumOrAverageWithSelector<long>(nameof(Queryable.Max)) },
                    { typeof(int), getSumOrAverageWithSelector<int>(nameof(Queryable.Max)) },
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 268..280
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 282..294
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 296..308
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 324..336
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 338..350
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 352..364
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 366..378

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 305.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 8 locations. Consider refactoring.
    Wontfix

                SumWithSelectorMethods = new Dictionary<Type, MethodInfo>
                {
                    { typeof(decimal), getSumOrAverageWithSelector<decimal>(nameof(Queryable.Sum)) },
                    { typeof(long), getSumOrAverageWithSelector<long>(nameof(Queryable.Sum)) },
                    { typeof(int), getSumOrAverageWithSelector<int>(nameof(Queryable.Sum)) },
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 268..280
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 282..294
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 296..308
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 310..322
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 324..336
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 338..350
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 352..364

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 305.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Wontfix

                MaxWithSelector = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Max) && mi.IsGenericMethod && mi.GetGenericArguments().Length == 2 && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 166..167

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 97.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Wontfix

                MinWithSelector = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Min) && mi.IsGenericMethod && mi.GetGenericArguments().Length == 2 && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 170..171

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 97.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Wontfix

                    mi => mi.Name == nameof(Enumerable.GroupBy) && mi.GetParameters().Length == 3 && IsFunc(mi.GetParameters()[1].ParameterType) && IsFunc(mi.GetParameters()[2].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 247..247

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 84.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Wontfix

                    mi => mi.Name == nameof(Enumerable.GroupBy) && mi.GetParameters().Length == 4 && IsFunc(mi.GetParameters()[1].ParameterType) && IsFunc(mi.GetParameters()[2].ParameterType) && IsFunc(mi.GetParameters()[3].ParameterType, 3));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 245..245

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 84.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                FirstWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.First) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                SkipWhile = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.SkipWhile) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                TakeWhile = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.TakeWhile) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                SelectManyWithoutCollectionSelector = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.SelectMany) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                AnyWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Any) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                ThenBy = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.ThenBy) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                Select = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Select) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                SingleOrDefaultWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.SingleOrDefault) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                LastOrDefaultWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.LastOrDefault) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                LongCountWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.LongCount) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                SingleWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Single) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                GroupByWithKeySelector = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.GroupBy) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                CountWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Count) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                FirstOrDefaultWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.FirstOrDefault) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                Where = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Where) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                LastWithPredicate = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Last) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                OrderByDescending = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.OrderByDescending) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                OrderBy = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.OrderBy) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                All = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.All) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                ThenByDescending = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.ThenByDescending) && mi.GetParameters().Length == 2 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 237..238
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 21 locations. Consider refactoring.
    Wontfix

                SelectManyWithCollectionSelector = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.SelectMany) && mi.GetParameters().Length == 3 && IsFunc(mi.GetParameters()[1].ParameterType));
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 140..141
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 144..145
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 160..161
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 164..165
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 181..182
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 185..186
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 189..190
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 193..194
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 197..198
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 201..202
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 208..209
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 210..211
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 216..217
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 218..219
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 220..221
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 222..223
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 224..225
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 226..227
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 239..240
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 242..243

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 76.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Wontfix

                MinWithoutSelector = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Min) && mi.IsGenericMethod && mi.GetGenericArguments().Length == 1 && mi.GetParameters().Length == 1);
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 172..173

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 71.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Wontfix

                MaxWithoutSelector = enumerableMethods.Single(
                    mi => mi.Name == nameof(Enumerable.Max) && mi.IsGenericMethod && mi.GetGenericArguments().Length == 1 && mi.GetParameters().Length == 1);
    FileContextCore/Query/Internal/FileContextLinqOperatorProvider.cs on lines 168..169

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 71.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    There are no issues that match your filters.

    Category
    Status