如何获得在Roslyn的类中使用的整个类型？ （所有嵌套/内部类型递归）

Question

Please consider this sample:

public class Person
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public float Age { get; set; }
    public List<Address> Addresses { get; set; }
    public IEnumerable<Job> Jobs { get; set; }
    public IInterface MyInterface { get; set; }
}

public class Address
{
    public string City { get; set; }
    public string[] Phones { get; set; }
    public MyEnum E1  { get; set; }
}

public class Job
{
    public Dictionary<decimal, Address> A1 { get; set; }
    public Collection<DateTime> Date { get; set; }
    public Tuple<double, BigInteger> A2 { get; set; }
}

public enum MyEnum
{
   En1,
   En2
}

As you see, I want to get all inner classes/structs/types of Person so the result is :

Person.GetInnerTypes():

Guid
float
string
IInterface
Address
string[]
MyEnum
Job
List<Address>
IEnumerable<Job>
Dictionary<decimal, Address>
decimal
Collection<DateTime>
DateTime
Tuple<double, BigInteger>
double
BigInteger

The types are collected from everywhere (properties, arguments,...)

Is it possible to find whole types (recursively) by Roslyn? Does anyone have an idea?

EDIT:

Why do I need this?

The problem comes from creating a code generator, if you see the Bogus library you should define rules for every type at first then create the main rule for Person class so I need to know all types for a class to create a code generator for generating test data! (generate a working class)

EDIT 2:

Answer 1

That's a very broad answer. If you are interested in the properteis only - just use this question. Find your class' DeclarationSyntax, then find all DescendantNodes of PropertyDeclarationSyntax type. PropertyDeclarationSyntax will give you access to types, and you will go into recursion (don't forget about loops). This should be enough for a prototype.

Even on this step you should be careful with

1. Nested classes. Types used there will be included into your list too.
2. Generics. Sometime there are limitations like Type where T : ISomeInterface. Also, nested Generics.
3. Partial classes
4. Is Func < T1, T2> the same with Func< T2, T1> for you?

After all, there are questions about your problem itself.

1. Do you need parents of used types?
2. Do you care about properties only, or methods\\fields\\events etc are valuable also?
3. Should you think about properties inherited from the parents?
4. If you care about methods - should you think about parameters types?
5. If you care about methods - should you think about variables defined inside?

Edit1. Maybe reflection is enough for your task?

static void Main(string[] args)
    {
        var properties = typeof(DemoPerson).GetProperties();
        foreach(var property in properties)
        {
            Console.WriteLine($"Property: {property.Name}\tType: {property.PropertyType}");
        }

        Console.ReadLine();
    }

    public class DemoPerson
    {
        public Guid Id { get; set; }
        public string Name { get; set; }            
        public List<DemoAddress> Addresses { get; set; }            
    }

    public class DemoAddress
    {
        public string City { get; set; }            
    }

With output

Property: Id Type: System.Guid

Property: Name Type: System.String

Property: Addresses Type: System.Collections.Generic.List`1[DemoInnerTypes.Program+DemoAddress]