public void GenerateBaseMembers()
{
Log.Write("Base members...");
var assemblyReferencesDataFolder = Path.Combine(
this.SolutionGenerator.SolutionDestinationFolder,
this.AssemblyName,
Constants.ReferencesFileName);
Directory.CreateDirectory(assemblyReferencesDataFolder);
lock (this.BaseMembers)
{
var lines = new List <string>(this.BaseMembers.Count);
foreach (var kvp in this.BaseMembers.OrderBy(b => SymbolIdService.GetId(b.Key)))
{
var fromMemberId = SymbolIdService.GetId(kvp.Key);
var line =
fromMemberId + ";" +
SymbolIdService.GetAssemblyId(kvp.Value.ContainingAssembly) + ";" +
SymbolIdService.GetId(kvp.Value);
lines.Add(line);
// just make sure the references file for this symbol exists, so that even if symbols
// that aren't referenced anywhere get a reference file with a base member link if there
// is a base member for the symbol
var referencesFile = Path.Combine(assemblyReferencesDataFolder, fromMemberId + ".txt");
File.AppendAllText(referencesFile, "");
}
var fileName = Path.Combine(ProjectDestinationFolder, Constants.BaseMembersFileName + ".txt");
File.WriteAllLines(fileName, lines);
}
}
private static string GetAssemblyFromSymbol(ISymbol symbol)
{
ITypeSymbol type = (ITypeSymbol)GetTypeFromSymbol(symbol);
string metadataName = type.MetadataName;
if (type.ContainingNamespace != null)
{
var namespaceName = type.ContainingNamespace.ToDisplayString(QualifiedNameOnlyFormat);
if (!string.IsNullOrEmpty(namespaceName))
{
metadataName = namespaceName + "." + metadataName;
}
}
var forwardedTo = symbol.ContainingAssembly.ResolveForwardedType(metadataName);
if (forwardedTo != null)
{
symbol = forwardedTo;
}
var assembly = SymbolIdService.GetAssemblyId(symbol.ContainingAssembly);
return(assembly);
}
public HtmlElementInfo GenerateHyperlink(
ISymbol symbol,
string symbolId,
SyntaxTree syntaxTree,
out string assemblyName)
{
string href = null;
assemblyName = SymbolIdService.GetAssemblyId(GetAssemblyFromSymbol(symbol));
// if it's in a different assembly, use the URL to a redirecting file for that assembly
if (assemblyName != Document.Project.AssemblyName)
{
href = GetAbsoluteLink(symbolId, assemblyName);
}
else // it's in the same assembly, we can just use the direct path without redirects
{
string referencedSymbolDestinationFilePath = null;
if (symbol.Locations.Length > 1)
{
referencedSymbolDestinationFilePath = Path.Combine(
SolutionDestinationFolder,
assemblyName,
Constants.PartialResolvingFileName,
symbolId);
}
else
{
var referenceRelativeFilePath = Paths.GetRelativePathInProject(syntaxTree, Document.Project);
referencedSymbolDestinationFilePath = Path.Combine(projectGenerator.ProjectDestinationFolder, referenceRelativeFilePath);
}
href = Paths.MakeRelativeToFile(referencedSymbolDestinationFilePath, documentDestinationFilePath) + ".html";
if (referencedSymbolDestinationFilePath + ".html" == documentDestinationFilePath)
{
href = "";
}
else
{
href = href.Replace('\\', '/');
}
href = href + "#" + symbolId;
}
return(new HtmlElementInfo
{
Name = "a",
Attributes =
{
{ "href", href },
}
});
}
private string GetProjectDestinationPath(Project project, string solutionDestinationPath)
{
var assemblyName = project.AssemblyName;
if (assemblyName == "<Error>")
{
return(null);
}
AssemblyName = SymbolIdService.GetAssemblyId(assemblyName);
string subfolder = Path.Combine(solutionDestinationPath, AssemblyName);
return(subfolder);
}
public static IEnumerable <string> GetReferencePaths(IAssemblySymbol assemblySymbol)
{
foreach (var referenceIdentity in GetReferences(assemblySymbol))
{
var resolved = Resolve(referenceIdentity.Name);
if (!string.IsNullOrEmpty(resolved))
{
yield return(resolved);
}
else
{
Log.Message(SymbolIdService.GetAssemblyId(assemblySymbol) + " references an assembly that cannot be resolved: " + referenceIdentity.Name);
}
}
}
private string GetAssemblyFromSymbol(ISymbol symbol)
{
ITypeSymbol type = (ITypeSymbol)GetTypeFromSymbol(symbol);
string metadataName = type.MetadataName;
if (type.ContainingNamespace != null)
{
var namespaceName = type.ContainingNamespace.ToDisplayString(QualifiedNameOnlyFormat);
if (!string.IsNullOrEmpty(namespaceName))
{
metadataName = namespaceName + "." + metadataName;
}
}
var forwardedTo = symbol.ContainingAssembly.ResolveForwardedType(metadataName);
if (forwardedTo != null)
{
symbol = forwardedTo;
}
type = (ITypeSymbol)GetTypeFromSymbol(symbol);
var forwardKey = ValueTuple.Create(type.ContainingAssembly.Name, (type?.OriginalDefinition ?? type).GetDocumentationCommentId());
string forwardedToAssembly;
if (projectGenerator.SolutionGenerator.TypeForwards.TryGetValue(forwardKey, out forwardedToAssembly))
{
lock (projectGenerator.ForwardedReferenceAssemblies)
{
projectGenerator.ForwardedReferenceAssemblies.Add(
type.ContainingAssembly.Name + "->" + forwardedToAssembly);
}
return(forwardedToAssembly);
}
var assembly = SymbolIdService.GetAssemblyId(symbol.ContainingAssembly);
return(assembly);
}
