SmartCodeComplexityDetector 1.0.0

Smart Code Complexity Detector for .NET

⚡ Built with Roslyn for seamless integration in Visual Studio
💡 No config required — works out of the box
🧠 Helps you code smarter, faster, and cleaner

🚀 Features

✅ Time Complexity Estimation (O(1), O(n), O(n²), etc.)
✅ Space Complexity Estimation
⚠️ Anti-pattern Detection (e.g., nested loops, inefficient LINQ)
💬 Inline Suggestions powered by Roslyn
🧪 Test Coverage Warnings (optional)
🖥️ Optional: Visual Studio Extension for enhanced popup UI (Coming Soon)

📦 Installation

dotnet add package SmartCodeComplexityDetector

🎯 Quick Start

Just write your code as usual. The analyzer will analyze your methods as you type and show diagnostics:

public void PrintDuplicates(int[] nums)
{
    for (int i = 0; i < nums.Length; i++)
        for (int j = i + 1; j < nums.Length; j++)
            if (nums[i] == nums[j])
                Console.WriteLine(nums[i]);
}

Tooltip will show:

Time Complexity: O(n²)
Space Complexity: O(1)
Suggestion: Consider using HashSet for better performance

📖 Usage Examples

Basic Analysis

using SmartCodeComplexityDetector.Core;

string sourceCode = @"
public class Example
{
    public void PrintDuplicates(int[] nums)
    {
        for (int i = 0; i < nums.Length; i++)
            for (int j = i + 1; j < nums.Length; j++)
                if (nums[i] == nums[j])
                    Console.WriteLine(nums[i]);
    }
}";

// Analyze a specific method
var result = SmartCodeComplexityDetector.AnalyzeMethod(sourceCode, "PrintDuplicates");
Console.WriteLine(SmartCodeComplexityDetector.FormatResult(result));

Quick Analysis

// Get just the complexity notations
var (timeComplexity, spaceComplexity) = SmartCodeComplexityDetector.QuickAnalysis(sourceCode, "PrintDuplicates");
Console.WriteLine($"Time: {timeComplexity}, Space: {spaceComplexity}");

Analyze All Methods

// Analyze all methods in a file
var allResults = SmartCodeComplexityDetector.AnalyzeAllMethods(sourceCode);
foreach (var (methodName, result) in allResults)
{
    Console.WriteLine($"Method: {methodName}");
    Console.WriteLine(SmartCodeComplexityDetector.FormatResult(result));
    Console.WriteLine();
}

🔍 What It Detects

Time Complexity Analysis

• O(1): Constant time operations
• O(n): Linear operations (single loops, LINQ)
• O(n²): Quadratic operations (nested loops)
• O(n³): Cubic operations (deeply nested loops)
• O(log n): Logarithmic operations
• O(n log n): Linearithmic operations

Space Complexity Analysis

• O(1): Constant space usage
• O(n): Linear space usage (arrays, lists)
• O(n²): Quadratic space usage

Anti-pattern Detection

• ⚠️ Nested loops that could be optimized with HashSet/Dictionary
• ⚠️ Inefficient LINQ operations (multiple Where clauses, unnecessary ToList())
• ⚠️ String concatenation in loops (should use StringBuilder)
• ⚠️ Unnecessary allocations (List without capacity, arrays without size)

Optimization Suggestions

• 💡 Use HashSet for O(1) lookups instead of nested loops
• 💡 Combine multiple Where clauses into a single Where
• 💡 Use StringBuilder for string concatenation in loops
• 💡 Specify initial capacity for List<T> creation
• 💡 Use Any() instead of Count() > 0

🛠️ Advanced Usage

Custom Analysis

// You can also use the underlying services directly
using SmartCodeComplexityDetector.Services;
using SmartCodeComplexityDetector.Interfaces;

var antiPatternDetector = new AntiPatternDetector();
var complexityAnalyzer = new ComplexityAnalyzer(antiPatternDetector);

// Analyze with more control
var result = complexityAnalyzer.AnalyzeMethod(sourceCode, "MethodName");

Integration with Build Tools

<ItemGroup>
  <PackageReference Include="SmartCodeComplexityDetector" Version="1.0.0" />
</ItemGroup>

🎨 Output Examples

Simple Method

public int Sum(int[] numbers)
{
    int sum = 0;
    foreach (int num in numbers)
        sum += num;
    return sum;
}

Output:

Time Complexity: O(n)
Space Complexity: O(1)
Explanation: The method contains linear iterations (loops, LINQ operations) that process each element once. The method uses only a constant amount of additional memory.

Complex Method with Anti-patterns

public List<int> FindDuplicates(int[] nums)
{
    var result = new List<int>();
    for (int i = 0; i < nums.Length; i++)
    {
        for (int j = i + 1; j < nums.Length; j++)
        {
            if (nums[i] == nums[j])
                result.Add(nums[i]);
        }
    }
    return result;
}

Output:

Time Complexity: O(n²)
Space Complexity: O(n)
Explanation: The method contains nested loops, resulting in quadratic time complexity. The method allocates memory proportional to the input size (arrays, lists, etc.).

Suggestions:
• Consider using HashSet or Dictionary for O(1) lookups instead of nested loops
• Look for opportunities to use sorting + binary search for O(n log n) instead of O(n²)

Anti-patterns detected:
⚠️ Nested loops detected - consider using HashSet or Dictionary for O(1) lookups

🔧 Configuration

The package works out of the box with sensible defaults. No configuration required!

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Submit a pull request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🆘 Support

• 📧 Email: support@smartcomplexitydetector.com
• 🐛 Issues: GitHub Issues
• 📖 Documentation: Wiki

🚀 Roadmap

• Visual Studio Extension with real-time analysis
• Integration with CI/CD pipelines
• Custom complexity rules
• Performance benchmarking suggestions
• Memory usage analysis
• Async/await complexity analysis

Made with ❤️ for the .NET community