Benutzerdefinierte Compiler-Warnungen

Wenn Sie das ObsoleteAtribute in .Net verwenden, erhalten Sie Compiler-Warnungen, die Sie darüber informieren, dass das Objekt / die Methode / die Eigenschaft veraltet ist und etwas anderes verwendet werden sollte. Ich arbeite derzeit an einem Projekt, bei dem ein Code für ehemalige Mitarbeiter viel überarbeitet werden muss. Ich möchte ein benutzerdefiniertes Attribut schreiben, mit dem ich Methoden oder Eigenschaften markieren kann, die Compiler-Warnungen generieren, die von mir geschriebene Nachrichten enthalten. Etwas wie das

[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

Ich möchte, dass dies eine Compiler-Warnung generiert, die besagt: "Dieser Code ist sux und sollte betrachtet werden". Ich weiß, wie man ein benutzerdefiniertes Attribut erstellt. Die Frage ist, wie ich es veranlassen kann, Compiler-Warnungen in Visual Studio zu generieren.

Aktualisieren

Dies ist jetzt mit Roslyn (Visual Studio 2015) möglich. Sie können bauen einen Code Analyzer für ein benutzerdefiniertes Attribut zu überprüfen

Ich glaube nicht, dass es möglich ist. ObsoleteAttribute wird vom Compiler speziell behandelt und im C # -Standard definiert. Warum um alles in der Welt ist ObsoleteAttribute nicht akzeptabel? Es scheint mir, dass dies genau die Situation ist, für die es entwickelt wurde, und genau das erreicht, was Sie benötigen!

Beachten Sie auch, dass Visual Studio die von ObsoleteAttribute generierten Warnungen auch im laufenden Betrieb aufnimmt, was sehr nützlich ist.

Ich will nicht wenig hilfreich sein und mich nur fragen, warum Sie es nicht gerne benutzen ...

Leider ist ObsoleteAttribute versiegelt (wahrscheinlich teilweise aufgrund der Sonderbehandlung), daher können Sie Ihr eigenes Attribut nicht daraus unterordnen.

Aus dem C # -Standard: -

Das Attribut Veraltet wird verwendet, um Typen und Mitglieder von Typen zu markieren, die nicht mehr verwendet werden sollen.

Wenn ein Programm einen Typ oder ein Element verwendet, das mit dem Attribut "Veraltet" versehen ist, gibt der Compiler eine Warnung oder einen Fehler aus. Insbesondere gibt der Compiler eine Warnung aus, wenn kein Fehlerparameter angegeben ist oder wenn der Fehlerparameter angegeben ist und den Wert false hat. Der Compiler gibt einen Fehler aus, wenn der Fehlerparameter angegeben ist und den Wert true hat.

Fasst das nicht Ihre Bedürfnisse zusammen? ... Sie werden es nicht besser machen, denke ich nicht.

Das ist einen Versuch wert.

Sie können Obsolete nicht erweitern, da es endgültig ist, aber vielleicht können Sie Ihr eigenes Attribut erstellen und diese Klasse wie folgt als veraltet markieren:

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

Wenn Sie dann Ihre Methoden mit dem Attribut "MustRefactor" markieren, werden die Kompilierungswarnungen angezeigt. Es wird eine Warnung zur Kompilierungszeit generiert, aber die Fehlermeldung sieht lustig aus. Sie sollten sie selbst sehen und auswählen. Dies kommt dem sehr nahe, was Sie erreichen wollten.

UPDATE: Mit diesem Code wird eine Warnung generiert (nicht sehr schön, aber ich denke nicht, dass es etwas Besseres gibt).

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
{

}

In einigen Compilern können Sie #warning verwenden, um eine Warnung auszugeben:

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

In Microsoft-Compilern können Sie normalerweise das Nachrichtenpragma verwenden:

#pragma message ( "text" )

Sie haben .Net erwähnt, aber nicht angegeben, ob Sie mit C / C ++ oder C # programmieren. Wenn Sie in C # programmieren, sollten Sie wissen, dass C # das # warning-Format unterstützt .

Wir befinden uns derzeit mitten in einer Umgestaltung, bei der wir nicht alles sofort reparieren konnten. Wir verwenden nur den Befehl #warning preproc, wo wir zurückgehen und uns den Code ansehen müssen. Es wird in der Compiler-Ausgabe angezeigt. Ich glaube nicht, dass Sie es auf eine Methode setzen können, aber Sie könnten es einfach in die Methode einfügen, und es ist immer noch leicht zu finden.

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

In VS 2008 (+ sp1) werden #Warnungen in der Fehlerliste nach Clean Soultion & Rebuild Solution nicht richtig angezeigt, nicht alle. Einige Warnungen werden in der Fehlerliste erst angezeigt, nachdem ich eine bestimmte Klassendatei geöffnet habe. Also musste ich ein benutzerdefiniertes Attribut verwenden:

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

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

    public MappingToDo()
    {}
}

Also, wenn ich einen Code damit kennzeichne

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

Es werden Warnungen wie diese ausgegeben:

Namespace.MappingToDo ist veraltet: 'Mapping ToDo'.

Ich kann den Text der Warnung nicht ändern. 'Einige Kommentare' werden nicht angezeigt. Fehlerliste. Aber es wird an die richtige Stelle in der Datei springen. Wenn Sie solche Warnmeldungen ändern müssen, erstellen Sie verschiedene Attribute.

Was Sie versuchen, ist ein Missbrauch von Attributen. Verwenden Sie stattdessen die Visual Studio-Aufgabenliste. Sie können einen Kommentar wie folgt in Ihren Code eingeben:

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

Öffnen Sie dann Ansicht / Aufgabenliste aus dem Menü. Die Aufgabenliste enthält zwei Kategorien: Benutzeraufgaben und Kommentare. Wechseln Sie zu Kommentare und Sie sehen alle Ihre // Todo: 's dort. Ein Doppelklick auf ein TODO springt zum Kommentar in Ihrem Code.

Al

Ich glaube nicht, dass du kannst. Soweit ich weiß, ist die Unterstützung für ObsoleteAttribute im Wesentlichen im C # -Compiler fest codiert. Sie können nichts Ähnliches direkt tun.

Möglicherweise können Sie eine MSBuild-Task (oder ein Post-Build-Ereignis) verwenden, mit der ein benutzerdefiniertes Tool für die gerade kompilierte Assembly ausgeführt wird. Das benutzerdefinierte Tool spiegelt alle Typen / Methoden in der Assembly wider und verwendet Ihr benutzerdefiniertes Attribut. Zu diesem Zeitpunkt kann es in den Standard- oder FehlertextWriters von System.Console gedruckt werden.

Wenn man sich die Quelle für ObsoleteAttribute ansieht , sieht es nicht so aus, als würde es etwas Besonderes tun, um eine Compiler-Warnung zu generieren. Daher würde ich eher mit @ technophile arbeiten und sagen, dass es im Compiler fest codiert ist. Gibt es einen Grund, warum Sie ObsoleteAttribute nicht nur zum Generieren Ihrer Warnmeldungen verwenden möchten ?

Es gibt mehrere Kommentare, die darauf hinweisen, Warnungen oder Pragma einzufügen. Veraltet funktioniert ganz anders! Wenn eine Funktion einer Bibliothek L als veraltet markiert wird, wird die veraltete Nachricht ausgelöst, wenn ein Programm die Funktion aufruft, auch wenn sich das aufrufende Programm nicht in der Bibliothek L befindet. Warnung löst die Nachricht NUR aus, wenn L kompiliert wird.

Hier ist die Roslyn-Implementierung, mit der Sie Ihre eigenen Attribute erstellen können, die im laufenden Betrieb Warnungen oder Fehler ausgeben.

Ich habe einen Attributtyp namens Called erstellt, IdeMessageder das Attribut ist, das Warnungen generiert:

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

    public IDEMessageAttribute(string message);
}

Dazu müssen Sie zuerst das Roslyn SDK installieren und ein neues VSIX-Projekt mit Analyzer starten. Ich habe einige der weniger relevanten Teile wie die Nachrichten weggelassen. Sie können herausfinden, wie das geht. In Ihrem Analysegerät tun Sie dies

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);
}

Es gibt keinen CodeFixProvider dafür, den Sie aus der Lösung entfernen können.