Niestandardowe ostrzeżenia kompilatora

Kiedy używasz ObsoleteAtribute w .Net daje ci ostrzeżenia kompilatora, informujące cię, że obiekt / metoda / właściwość jest przestarzała i należy użyć czegoś innego. Obecnie pracuję nad projektem, który wymaga wielu zmian w kodzie byłych pracowników. Chcę napisać atrybut niestandardowy, którego mogę użyć do oznaczania metod lub właściwości, które będą generować ostrzeżenia kompilatora, które będą wyświetlać wiadomości, które piszę. Coś takiego

[MyAttribute("This code sux and should be looked at")]
public void DoEverything()
{
}

<MyAttribute("This code sux and should be looked at")>
Public Sub DoEverything()
End Sub

Chcę, aby to wygenerowało ostrzeżenie kompilatora, które mówi: „Ten kod sux i należy mu się przyjrzeć”. Wiem, jak utworzyć atrybut niestandardowy, pytanie brzmi, jak spowodować, aby generował ostrzeżenia kompilatora w Visual Studio.

Aktualizacja

Jest to teraz możliwe dzięki Roslyn (Visual Studio 2015). Można budować na analizator kodu do sprawdzenia atrybutu niestandardowego

Nie wierzę, że to możliwe. ObsoleteAttribute jest traktowany specjalnie przez kompilator i jest zdefiniowany w standardzie C #. Dlaczego do diabła nie można zaakceptować ObsoleteAttribute? Wydaje mi się, że jest to właśnie sytuacja, do której został zaprojektowany, i zapewnia dokładnie to, czego potrzebujesz!

Należy również pamiętać, że program Visual Studio odbiera ostrzeżenia generowane przez ObsoleteAttribute również w locie, co jest bardzo przydatne.

Nie chcę być pomocny, po prostu zastanawiasz się, dlaczego nie chcesz go używać ...

Niestety ObsoleteAttribute jest zapieczętowany (prawdopodobnie częściowo z powodu specjalnego traktowania), dlatego nie możesz podklasować swojego własnego atrybutu z tego.

Ze standardu C #: -

Atrybut Przestarzałe służy do oznaczania typów i elementów członkowskich typów, które nie powinny już być używane.

Jeśli program używa typu lub elementu członkowskiego, który jest ozdobiony atrybutem przestarzałym, kompilator wyświetla ostrzeżenie lub błąd. W szczególności kompilator generuje ostrzeżenie, jeśli nie podano parametru błędu lub jeśli podano parametr błędu i ma wartość false. Kompilator zgłasza błąd, jeśli parametr błędu jest określony i ma wartość true.

Czy to nie podsumowuje twoich potrzeb? ... nie zamierzasz zrobić nic lepszego niż to, nie sądzę.

Warto spróbować.

Nie możesz rozszerzyć Obsolete, ponieważ jest ostateczny, ale może możesz stworzyć własny atrybut i oznaczyć tę klasę jako przestarzałą w następujący sposób:

[Obsolete("Should be refactored")]
public class MustRefactor: System.Attribute{}

Gdy oznaczysz metody atrybutem „MustRefactor”, pojawią się ostrzeżenia dotyczące kompilacji. Generuje ostrzeżenie o czasie kompilacji, ale komunikat o błędzie wygląda śmiesznie, powinieneś to zobaczyć i wybrać. To jest bardzo bliskie temu, co chciałeś osiągnąć.

UPDATE: Za pomocą tego kodu generuje ostrzeżenie (niezbyt ładne, ale nie sądzę, aby było coś lepszego).

public class User
{
    private String userName;

    [TooManyArgs] // Will show warning: Try removing some arguments
    public User(String userName)
    {
        this.userName = userName;   
    }

    public String UserName
    {
        get { return userName; }
    }
    [MustRefactor] // will show warning: Refactor is needed Here
    public override string ToString()
    {
        return "User: " + userName;
    }
}
[Obsolete("Refactor is needed Here")]
public class MustRefactor : System.Attribute
{

}
[Obsolete("Try removing some arguments")]
public class TooManyArgs : System.Attribute
{

}

W niektórych kompilatorach możesz użyć #warning, aby wygenerować ostrzeżenie:

#warning "Do not use ABC, which is deprecated. Use XYZ instead."

W kompilatorach firmy Microsoft zazwyczaj można użyć pragmy komunikatu:

#pragma message ( "text" )

Wspomniałeś o .Net, ale nie sprecyzowałeś, czy programujesz w C / C ++ czy C #. Jeśli programujesz w C #, powinieneś wiedzieć, że C # obsługuje format #warning .

Obecnie jesteśmy w trakcie wielu refaktoryzacji, podczas których nie mogliśmy od razu wszystkiego naprawić. Po prostu używamy polecenia #warning preproc, w którym musimy cofnąć się i spojrzeć na kod. Pojawia się w danych wyjściowych kompilatora. Nie sądzę, aby można było przypisać to do metody, ale można by było umieścić je tylko wewnątrz metody, a nadal łatwo jest znaleźć.

public void DoEverything() {
   #warning "This code sucks"
}

W VS 2008 (+ sp1) # ostrzeżenia nie wyświetlają się poprawnie na liście błędów po Clean Soultion & Rebuild Solution, nie wszystkie z nich. Niektóre ostrzeżenia są wyświetlane na liście błędów dopiero po otwarciu określonego pliku klasy. Więc byłem zmuszony użyć atrybutu niestandardowego:

[Obsolete("Mapping ToDo")]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property)]
public class MappingToDo : System.Attribute
{
    public string Comment = "";

    public MappingToDo(string comment)
    {
        Comment = comment;
    }

    public MappingToDo()
    {}
}

Więc kiedy oflaguję nim jakiś kod

[MappingToDo("Some comment")]
public class MembershipHour : Entity
{
    // .....
}

Generuje takie ostrzeżenia:

Namespace.MappingToDo jest przestarzałe: „Mapping ToDo”.

Nie mogę zmienić treści ostrzeżenia, nie wyświetla się „Jakiś komentarz”. Lista błędów. Ale przeskoczy na właściwe miejsce w pliku. Jeśli więc chcesz zmieniać takie komunikaty ostrzegawcze, utwórz różne atrybuty.

To, co próbujesz zrobić, jest nadużyciem atrybutów. Zamiast tego użyj listy zadań programu Visual Studio. Możesz wpisać komentarz do swojego kodu w następujący sposób:

//TODO:  This code sux and should be looked at
public class SuckyClass(){
  //TODO:  Do something really sucky here!
}

Następnie otwórz Widok / Lista zadań z menu. Lista zadań ma dwie kategorie, zadania użytkownika i komentarze. Przełącz się na Komentarze, a zobaczysz wszystkie swoje // Todo: 's. Dwukrotne kliknięcie TODO spowoduje przejście do komentarza w kodzie.

Glin

Myślę, że nie możesz. O ile wiem, obsługa ObsoleteAttribute jest zasadniczo zakodowana na stałe w kompilatorze C #; nie możesz zrobić niczego podobnego bezpośrednio.

To, co możesz zrobić, to użyć zadania MSBuild (lub zdarzenia po kompilacji), które wykonuje niestandardowe narzędzie dla właśnie skompilowanego zestawu. Narzędzie niestandardowe będzie odzwierciedlać wszystkie typy / metody w zestawie i zużywa niestandardowy atrybut, w którym to momencie może drukować do domyślnego lub błędu TextWriters System.Console.

Patrząc na źródło ObsoleteAttribute , nie wygląda na to, że robi coś specjalnego, aby wygenerować ostrzeżenie kompilatora, więc chciałbym iść z @ technophile i powiedzieć, że jest na stałe zakodowany w kompilatorze. Czy jest jakiś powód, dla którego nie chcesz używać ObsoleteAttribute do generowania komunikatów ostrzegawczych?

Istnieje kilka komentarzy, które sugerują wstawienie ostrzeżeń lub pragmatów. Przestarzałe działa w zupełnie inny sposób! Oznaczając przestarzałą funkcję biblioteki L, przestarzały komunikat pojawia się, gdy program wywołuje funkcję, nawet jeśli programu wywołującego nie ma w bibliotece L. Ostrzeżenie powoduje wyświetlenie komunikatu TYLKO, gdy L jest kompilowane.

Oto implementacja Roslyn, dzięki czemu możesz tworzyć własne atrybuty, które w locie wyświetlają ostrzeżenia lub błędy.

Utworzyłem atrybut Type Called, IdeMessagektóry będzie atrybutem generującym ostrzeżenia:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
public class IDEMessageAttribute : Attribute
{
    public string Message;

    public IDEMessageAttribute(string message);
}

Aby to zrobić, musisz najpierw zainstalować Roslyn SDK i uruchomić nowy projekt VSIX z analizatorem. Pominąłem niektóre mniej istotne fragmenty, takie jak wiadomości, możesz dowiedzieć się, jak to zrobić. W swoim analizatorze robisz to

public override void Initialize(AnalysisContext context)
{
    context.RegisterSyntaxNodeAction(AnalyzerInvocation, SyntaxKind.InvocationExpression);
}

private static void AnalyzerInvocation(SyntaxNodeAnalysisContext context)
{
    var invocation = (InvocationExpressionSyntax)context.Node;

    var methodDeclaration = (context.SemanticModel.GetSymbolInfo(invocation, context.CancellationToken).Symbol as IMethodSymbol);

    //There are several reason why this may be null e.g invoking a delegate
    if (null == methodDeclaration)
    {
        return;
    }

    var methodAttributes = methodDeclaration.GetAttributes();
    var attributeData = methodAttributes.FirstOrDefault(attr => IsIDEMessageAttribute(context.SemanticModel, attr, typeof(IDEMessageAttribute)));
    if(null == attributeData)
    {
        return;
    }

    var message = GetMessage(attributeData); 
    var diagnostic = Diagnostic.Create(Rule, invocation.GetLocation(), methodDeclaration.Name, message);
    context.ReportDiagnostic(diagnostic);
}

static bool IsIDEMessageAttribute(SemanticModel semanticModel, AttributeData attribute, Type desiredAttributeType)
{
    var desiredTypeNamedSymbol = semanticModel.Compilation.GetTypeByMetadataName(desiredAttributeType.FullName);

    var result = attribute.AttributeClass.Equals(desiredTypeNamedSymbol);
    return result;
}

static string GetMessage(AttributeData attribute)
{
    if (attribute.ConstructorArguments.Length < 1)
    {
        return "This method is obsolete";
    }

    return (attribute.ConstructorArguments[0].Value as string);
}

W tym przypadku nie ma CodeFixProvider, możesz go usunąć z rozwiązania.