private void HandleInheritance(CSharpClassModel model, INamedTypeSymbol classSymbol)
{
if (classSymbol.BaseType != null && classSymbol.BaseType.ContainingAssembly.Name != "mscorlib")
{
model.BaseClass = classSymbol.BaseType.Name;
}
}
public TypeScriptClassModel ConvertClass(CSharpClassModel classModel)
{
return(new TypeScriptClassModel()
{
Name = classModel.Name,
BaseClass = classModel.BaseClass,
IsGeneric = classModel.IsGeneric,
TypeParameters = classModel.TypeParameters.Select(tp => new TypeScriptTypeParameterModel()
{
Name = tp.Name,
}).ToList(),
Imports = classModel.Dependencies.Select(d => new TypeScriptImportModel()
{
Name = d.Name,
FilePath = "",
DependencyKind = d.DependencyKind
}).ToList(),
Properties = classModel.Properties.Select(p => new TypeScriptPropertyModel()
{
Name = p.Name,
IsOptional = p.Type.IsNullable,
Type = typeConverter.ConvertType(p.Type)
}).ToList()
});
}
private void HandleDependencies(CSharpClassModel model, INamedTypeSymbol classSymbol)
{
var depService = new DependencyService();
var dependencies = depService.GetTypeDependencies(classSymbol);
foreach (var dep in dependencies)
{
model.Dependencies.Add(new CSharpDependencyModel()
{
Name = dep.Name,
Namespace = dep.ContainingNamespace.ToString(),
DependencyKind = dep.TypeKind == TypeKind.Class ? DependencyKind.Model : DependencyKind.Enum
});
}
}
private void HandleGenerics(CSharpClassModel model, INamedTypeSymbol classSymbol)
{
if (classSymbol.IsGenericType && !classSymbol.TypeParameters.IsDefaultOrEmpty)
{
model.IsGeneric = true;
foreach (var typeParameter in classSymbol.TypeParameters)
{
model.TypeParameters.Add(new CSharpTypeParameterModel()
{
Name = typeParameter.Name
});
}
}
}
public CSharpClassModel AnalyzeClassSymbol(INamedTypeSymbol classSymbol)
{
var classModel = new CSharpClassModel()
{
Name = classSymbol.Name
};
var members = classSymbol.GetMembers().ToList();
HandleInheritance(classModel, classSymbol);
HandleGenerics(classModel, classSymbol);
HandleDependencies(classModel, classSymbol);
var properties = members.Where(m => m.Kind == SymbolKind.Property).ToList();
foreach (var property in properties)
{
var propertySymbol = property as IPropertySymbol;
// for generic types we want to generate the interface instead of the specific, substituted property types
if (!propertySymbol.OriginalDefinition.Equals(propertySymbol))
{
propertySymbol = propertySymbol.OriginalDefinition;
}
var propertyModel = new CSharpPropertyModel()
{
Name = propertySymbol.Name,
Type = _typeAnalyzer.AnalyzeType(propertySymbol.Type)
};
classModel.Properties.Add(propertyModel);
}
return(classModel);
}
