CSharpTypeAnalyzer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using CSharpMemberAnalyzerLibrary;

namespace CSharpTypeAnalyzerLibrary
{
    public class TypeInfo
    {
        public string Name { get; set; }
        public string Namespace { get; set; }
        public string TypeKeyword { get; set; }
        public string Text { get; set; }
        public List<MemberInfo> Members { get; set; } = new List<MemberInfo>();

    }

    public class DependencyInfo
{
    public string From { get; set; }
    public string To { get; set; }
    public string Type { get; set; }
}

    public class CSharpTypeAnalyzer
    {
        private List<TypeInfo> _types;

        public CSharpTypeAnalyzer()
        {
            _types = new List<TypeInfo>();
        }

        public void Reset()
        {
            _types.Clear();
        }

        public void AnalyzeFiles(IReadOnlyDictionary<string, string> fileContents)
        {
            foreach (var file in fileContents)
            {
                AnalyzeFile(file.Value);
            }
        }

        private void AnalyzeFile(string content)
        {
            var tree = CSharpSyntaxTree.ParseText(content);
            var root = tree.GetCompilationUnitRoot();

            var typeDeclarations = root.DescendantNodes().OfType<TypeDeclarationSyntax>();

            foreach (var typeDeclaration in typeDeclarations)
            {
                var typeInfo = new TypeInfo
                {
                    Name = typeDeclaration.Identifier.Text,
                    Namespace = GetNamespace(typeDeclaration),
                    TypeKeyword = GetTypeKeyword(typeDeclaration),
                    Text = typeDeclaration.ToString()
                };

                _types.Add(typeInfo);
            }

            // Handle enum declarations separately
            var enumDeclarations = root.DescendantNodes().OfType<EnumDeclarationSyntax>();
            foreach (var enumDeclaration in enumDeclarations)
            {
                var typeInfo = new TypeInfo
                {
                    Name = enumDeclaration.Identifier.Text,
                    Namespace = GetNamespace(enumDeclaration),
                    TypeKeyword = "enum",
                    Text = enumDeclaration.ToString()
                };

                _types.Add(typeInfo);
            }

            // Handle delegate declarations
            var delegateDeclarations = root.DescendantNodes().OfType<DelegateDeclarationSyntax>();
            foreach (var delegateDeclaration in delegateDeclarations)
            {
                var typeInfo = new TypeInfo
                {
                    Name = delegateDeclaration.Identifier.Text,
                    Namespace = GetNamespace(delegateDeclaration),
                    TypeKeyword = "delegate",
                    Text = delegateDeclaration.ToString()
                };

                _types.Add(typeInfo);
            }
        }

        private string GetNamespace(SyntaxNode node)
        {
            var namespaceDeclaration = node.Ancestors().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();
            return namespaceDeclaration?.Name.ToString() ?? "Global Namespace";
        }

        private string GetTypeKeyword(TypeDeclarationSyntax typeDeclaration)
        {
            if (typeDeclaration is ClassDeclarationSyntax) return "class";
            if (typeDeclaration is InterfaceDeclarationSyntax) return "interface";
            if (typeDeclaration is StructDeclarationSyntax) return "struct";
            if (typeDeclaration is RecordDeclarationSyntax recordDeclaration)
            {
                return recordDeclaration.ClassOrStructKeyword.Text == "struct" ? "record struct" : "record";
            }
            return "unknown";
        }

        public IReadOnlyList<TypeInfo> GetTypes()
        {
            return _types.AsReadOnly();
        }
    }
}