/// <summary>
/// Gets a fully formed using statement expanding any abbreviated statement beginning with using and ending with a semicolon.
/// </summary>
/// <param name="directive">
/// The directive to use.
/// </param>
/// <returns>
/// The qualified using statement.
/// </returns>
internal static string GetFullyQualifiedStatement(this IUsingDirective directive)
{
if (directive is IUsingAliasDirective)
{
IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective;
return(string.Format("using {0} = {1};", aliasDirective.AliasName, directive.GetFullyQualifiedNamespace()));
}
IUsingNamespaceDirective namespaceDirective = directive as IUsingNamespaceDirective;
return(namespaceDirective != null?string.Format("using {0};", directive.GetFullyQualifiedNamespace()) : directive.GetText());
}
/// <summary>
/// Compares the IUsingDirectives provided.
/// </summary>
/// <param name="usingDirectiveA">
/// The first Using Directive.
/// </param>
/// <param name="usingDirectiveB">
/// The second Using Directive.
/// </param>
/// <returns>
/// An integer indicating the comparison.
/// </returns>
public int Compare(IUsingDirective usingDirectiveA, IUsingDirective usingDirectiveB)
{
bool usingDirectiveAIsAlias = usingDirectiveA is IUsingAliasDirective;
bool usingDirectiveBIsAlias = usingDirectiveB is IUsingAliasDirective;
if (usingDirectiveAIsAlias && !usingDirectiveBIsAlias)
{
return(1);
}
if (!usingDirectiveAIsAlias && usingDirectiveBIsAlias)
{
return(-1);
}
if (usingDirectiveAIsAlias)
{
IUsingAliasDirective usingAliasDirectiveA = usingDirectiveA as IUsingAliasDirective;
IUsingAliasDirective usingAliasDirectiveB = usingDirectiveB as IUsingAliasDirective;
if (usingAliasDirectiveA != null)
{
if (usingAliasDirectiveB != null)
{
return(string.Compare(usingAliasDirectiveA.AliasName, usingAliasDirectiveB.AliasName, StringComparison.OrdinalIgnoreCase));
}
}
}
string usingNamespaceDirectiveAQualifiedNamespace = usingDirectiveA.GetFullyQualifiedNamespace();
string usingNamespaceDirectiveBQualifiedNamespace = usingDirectiveB.GetFullyQualifiedNamespace();
bool usingNamespaceDirectiveATextStartsWithSystem = usingNamespaceDirectiveAQualifiedNamespace.StartsWith("System");
bool usingNamespaceDirectiveBTextStartsWithSystem = usingNamespaceDirectiveBQualifiedNamespace.StartsWith("System");
if (usingNamespaceDirectiveATextStartsWithSystem && !usingNamespaceDirectiveBTextStartsWithSystem)
{
return(-1);
}
if (!usingNamespaceDirectiveATextStartsWithSystem && usingNamespaceDirectiveBTextStartsWithSystem)
{
return(1);
}
return(string.Compare(
usingNamespaceDirectiveAQualifiedNamespace.SubstringBefore(';'),
usingNamespaceDirectiveBQualifiedNamespace.SubstringBefore(';'),
StringComparison.OrdinalIgnoreCase));
}
private static void ProcessImports(
IList <IUsingDirective> newImportsList,
AlphabeticalUsingsStyle organiseUsingsFormatOption,
ExpandUsingsStyle expandUsingsFormatOption,
ICSharpTypeAndNamespaceHolderDeclaration declaration)
{
if (newImportsList == null || newImportsList.Count == 0)
{
return;
}
List <IUsingDirective> arrayList = new List <IUsingDirective>();
arrayList.AddRange(newImportsList);
if (organiseUsingsFormatOption == AlphabeticalUsingsStyle.Alphabetical)
{
arrayList.Sort(new UsingStatementSorter());
}
foreach (IUsingDirective directive in arrayList)
{
IUsingDirective newUsingDirective;
if (expandUsingsFormatOption == ExpandUsingsStyle.FullyQualify)
{
if (directive is IUsingAliasDirective)
{
IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective;
newUsingDirective =
CSharpElementFactory.GetInstance(declaration.GetPsiModule())
.CreateUsingDirective(aliasDirective.AliasName + " = " + directive.GetFullyQualifiedNamespace());
IUsingAliasDirective n = newUsingDirective as IUsingAliasDirective;
n.SetImportedSymbolName(aliasDirective.ImportedSymbolName);
}
else
{
newUsingDirective = CSharpElementFactory.GetInstance(declaration.GetPsiModule()).CreateUsingDirective(directive.GetFullyQualifiedNamespace());
}
}
else
{
newUsingDirective = directive.CopyWithResolve();
}
declaration.RemoveImport(directive);
declaration.AddImportBefore(newUsingDirective, null);
}
}
/// <summary>
/// Gets the full namespace for the Using directive with any aliases expanded.
/// </summary>
/// <param name="directive">
/// The directive to use.
/// </param>
/// <returns>
/// The fully qualified namespace.
/// </returns>
internal static string GetFullyQualifiedNamespace(this IUsingDirective directive)
{
if (directive is IUsingAliasDirective)
{
IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective;
INamespace aliasedNamespace = aliasDirective.DeclaredElement.GetAliasedNamespace();
string returnValue = aliasedNamespace == null ? aliasDirective.ImportedSymbolName.QualifiedName : aliasedNamespace.QualifiedName;
return(returnValue);
}
IUsingNamespaceDirective namespaceDirective = directive as IUsingNamespaceDirective;
return(namespaceDirective.ImportedNamespace == null ? namespaceDirective.ImportedSymbolName.QualifiedName : namespaceDirective.ImportedNamespace.QualifiedName);
}
/// <summary>
/// Gets the full namespace for the Using directive with any aliases expanded.
/// </summary>
/// <param name="directive">
/// The directive to use.
/// </param>
/// <returns>
/// The fully qualified namespace.
/// </returns>
internal static string GetFullyQualifiedNamespace(this IUsingDirective directive)
{
if (directive is IUsingAliasDirective)
{
IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective;
DeclaredElementInstance <IDeclaredElement> declaredElementInstance = aliasDirective.DeclaredElement.GetAliasedSymbol();
INamespace aliasedNamespace = declaredElementInstance == null ? null : declaredElementInstance.Element as INamespace;
string returnValue = aliasedNamespace == null ? aliasDirective.ImportedSymbolName.QualifiedName : aliasedNamespace.QualifiedName;
return(returnValue);
}
return(directive.ImportedSymbolName.QualifiedName);
}
private static void ProcessImports(
IList <IUsingDirective> originalImportsList,
bool organiseUsings,
bool expandUsings,
ICSharpTypeAndNamespaceHolderDeclaration declaration)
{
if (originalImportsList == null || originalImportsList.Count == 0)
{
return;
}
List <IUsingDirective> sortedImportsList = new List <IUsingDirective>();
sortedImportsList.AddRange(originalImportsList);
if (organiseUsings)
{
sortedImportsList.Sort(new UsingStatementSorter());
}
bool alreadySorted = true;
bool alreadyExpanded = true;
for (int i = 0; i < originalImportsList.Count; i++)
{
if (originalImportsList[i] != sortedImportsList[i])
{
alreadySorted = false;
break;
}
IUsingAliasDirective aliasDirective = originalImportsList[i] as IUsingAliasDirective;
if (aliasDirective != null)
{
if (aliasDirective.ImportedSymbolName.GetText() != aliasDirective.GetFullyQualifiedNamespace())
{
alreadyExpanded = false;
break;
}
}
}
if (alreadySorted && alreadyExpanded)
{
return;
}
foreach (IUsingDirective directive in sortedImportsList)
{
IUsingDirective newUsingDirective;
if (expandUsings)
{
if (directive is IUsingAliasDirective)
{
IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective;
newUsingDirective =
CSharpElementFactory.GetInstance(declaration.GetPsiModule())
.CreateUsingDirective(aliasDirective.AliasName + " = " + directive.GetFullyQualifiedNamespace());
IUsingAliasDirective n = newUsingDirective as IUsingAliasDirective;
n.SetImportedSymbolName(aliasDirective.ImportedSymbolName);
}
else
{
newUsingDirective = CSharpElementFactory.GetInstance(declaration.GetPsiModule()).CreateUsingDirective(directive.GetFullyQualifiedNamespace());
}
}
else
{
newUsingDirective = directive.CopyWithResolve();
}
declaration.RemoveImport(directive);
declaration.AddImportBefore(newUsingDirective, null);
}
}
