Find all types reachable from a given type

[dennis-yemelyanov]

I have some object graph that needs to be serialized, and I need to find all types that may participate in this serialization (so I can do some analysis on these types). For example, for a given Order class

public class Order
{
  public Customer Customer { get; set; }

  public List<OrderItem> Items { get; set; }

  public Dictionary<int, OrderDetail> Details { get; set; }
}

I want to find types like Customer, OrderItem and OrderDetail (for simplicity let's say all these classes are sealed, I don't have to find types that derive from them).

I know one approach is to use a SymbolVisitor, but it looks like I need to write quite some code in this case, and I'm also not sure if things like generic type arguments will be handled automatically or I need to have this processing logic in my code.

Are there any other potentially better or high level approaches to do this?

Roslyn seems to have a lot of useful classes like SymbolFinder (not sure if it can be used for this scenario actually), but it's a bit difficult for me to discover all available options. So I want to make sure I don't end up reinventing the wheel if I miss some really good option

[CyrusNajmabadi]

You should use SymbolFinder along with whatever logic you think encodes the semantics you need here.

[dennis-yemelyanov]

Thank you @CyrusNajmabadi ! I noticed SymbolFinder has a FindReferences method, which seems to search in the opposite direction (references pointing to current class). So to find outgoing references, would FindDeclarations be the right method to use?

[CyrusNajmabadi]

You can just look directly at the symbol model (the INamedTypeSymbols, IPropertySymbols, etc), utilizing whatever logic you want for your domain problem here.

[dennis-yemelyanov]

I see. So do I understand correctly that I would need to write the following logic myself?

• If the property type is an array, extract the array type from INamedTypeSymbol
• If the property type is a generic type, extract all of its generic type arguments
  etc.

I could definitely do that myself (and was even planning to), but was curious if there is already something I can call like SomeUtility.GetReachableTypes(INamedTypeSymbol symbol). Just like SymbolFinder provides a utility method to find all incoming references, but I need the same to find outgoing references instead.

But it sounds like there is no such built-in method for this task, is that correct understanding?

[dennis-yemelyanov]

Well I was able to cook something using SymbolVisitor, which seems to do exactly what I wanted. Actually looks pretty simple and only needs special handling for array (although in a much nicer way than I originally thought it would be):

class ReferenceVisitor : SymbolVisitor
{
    public HashSet<INamedTypeSymbol> NamedTypeSymbols { get; } = new(SymbolEqualityComparer.Default);

    public override void VisitField(IFieldSymbol symbol)
    {
        symbol.Type.Accept(this);
    }

    public override void VisitProperty(IPropertySymbol symbol)
    {
        symbol.Type.Accept(this);
    }

    public override void VisitArrayType(IArrayTypeSymbol symbol)
    {
        symbol.ElementType.Accept(this);
    }

    public override void VisitNamedType(INamedTypeSymbol symbol)
    {
        if (!NamedTypeSymbols.Add(symbol))
        {
            return;
        }

        foreach (var memberSymbol in symbol.GetMembers())
        {
            memberSymbol.Accept(this);
        }
    }
}