Avisos do compilador personalizado

Ao usar o ObsoleteAtribute em .Net, ele fornece avisos do compilador informando que o objeto / método / propriedade está obsoleto e que algo mais deve ser usado. Atualmente estou trabalhando em um projeto que requer muita refatoração de um código de ex-funcionários. Quero escrever um atributo personalizado que posso usar para marcar métodos ou propriedades que irão gerar avisos do compilador que fornecem mensagens que escrevo. Algo assim

[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

Eu quero que isso gere um aviso do compilador que diz: "Este código sux e deve ser examinado". Eu sei como criar um atributo personalizado, a questão é como faço para gerar avisos do compilador no visual studio.

Atualizar

Agora isso é possível com Roslyn (Visual Studio 2015). Você pode construir um analisador de código para verificar se há um atributo personalizado

Não acredito que seja possível. ObsoleteAttribute é tratado de forma especial pelo compilador e é definido no padrão C #. Por que diabos o ObsoleteAttribute não é aceitável? Parece-me que essa é exatamente a situação para a qual foi projetada e atinge exatamente o que você precisa!

Observe também que o Visual Studio capta os avisos gerados pelo ObsoleteAttribute instantaneamente, o que é muito útil.

Não pretendo ser inútil, apenas me perguntando por que você não gosta de usá-lo ...

Infelizmente ObsoleteAttribute é lacrado (provavelmente em parte devido ao tratamento especial), portanto, você não pode criar subclasses de seu próprio atributo a partir dele.

Do padrão C #: -

O atributo Obsolete é usado para marcar tipos e membros de tipos que não devem mais ser usados.

Se um programa usar um tipo ou membro decorado com o atributo Obsolete, o compilador emitirá um aviso ou um erro. Especificamente, o compilador emite um aviso se nenhum parâmetro de erro for fornecido ou se o parâmetro de erro for fornecido e tiver o valor false. O compilador emitirá um erro se o parâmetro de erro for especificado e tiver o valor true.

Isso não resume as suas necessidades? ... Você não vai fazer melhor do que isso, eu não acho.

Vale a pena tentar.

Você não pode estender Obsolete, porque é final, mas talvez você possa criar seu próprio atributo e marcar essa classe como obsoleta assim:

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

Então, quando você marca seus métodos com o atributo "MustRefactor", os avisos de compilação serão exibidos. Ele gera um aviso em tempo de compilação, mas a mensagem de erro parece engraçada, você deve ver por si mesmo e escolher. Isso está muito próximo do que você queria alcançar.

ATUALIZAÇÃO: Com esse código gera um aviso (não muito legal, mas acho que não tem algo melhor).

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
{

}

Em alguns compiladores, você pode usar #warning para emitir um aviso:

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

Em compiladores Microsoft, você normalmente pode usar o pragma da mensagem:

#pragma message ( "text" )

Você mencionou .Net, mas não especificou se estava programando em C / C ++ ou C #. Se você estiver programando em C #, saiba que C # oferece suporte ao formato #warning .

No momento, estamos no meio de muita refatoração, onde não poderíamos consertar tudo imediatamente. Nós apenas usamos o comando #warning preproc onde precisamos voltar e olhar o código. Ele aparece na saída do compilador. Não acho que você pode colocá-lo em um método, mas você poderia colocá-lo apenas dentro do método e ainda é fácil de encontrar.

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

No VS 2008 (+ sp1) #warnings não são exibidos corretamente na lista de erros após a solução Clean Soultion & Rebuild, nem todos eles. Alguns avisos são mostrados na lista de erros somente depois que eu abrir um arquivo de classe particular. Então fui forçado a usar o atributo personalizado:

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

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

    public MappingToDo()
    {}
}

Então, quando sinalizo algum código com ele

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

Ele produz avisos como este:

Namespace.MappingToDo é obsoleto: 'Mapping ToDo'.

Não consigo alterar o texto do aviso, 'Algum comentário' não aparece na Lista de Erros. Mas ele irá pular para o lugar apropriado no arquivo. Portanto, se você precisar variar essas mensagens de aviso, crie vários atributos.

O que você está tentando fazer é mau uso dos atributos. Em vez disso, use a Lista de Tarefas do Visual Studio. Você pode inserir um comentário em seu código como este:

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

Em seguida, abra Exibir / Lista de Tarefas no menu. A lista de tarefas tem duas categorias, tarefas do usuário e comentários. Mude para Comentários e você verá todos os seus // Todo: lá. Clicar duas vezes em um TODO irá direcionar para o comentário em seu código.

Al

Eu não acho que você pode. Até onde eu sei, o suporte para ObsoleteAttribute é essencialmente codificado no compilador C #; você não pode fazer nada semelhante diretamente.

O que você pode fazer é usar uma tarefa MSBuild (ou um evento pós-compilação) que executa uma ferramenta personalizada no assembly recém-compilado. A ferramenta personalizada refletiria sobre todos os tipos / métodos na montagem e consumiria seu atributo personalizado, ponto em que poderia imprimir no TextWriters padrão ou de erro do System.Console.

Olhando para o código-fonte do ObsoleteAttribute , não parece que está fazendo nada de especial para gerar um aviso do compilador, então eu tenderia a ir com @ technophile e dizer que ele está embutido no compilador. Existe um motivo pelo qual você não deseja apenas usar ObsoleteAttribute para gerar suas mensagens de aviso?

Existem vários comentários que sugerem a inserção de advertências ou pragma. Obsolete funciona de uma maneira muito diferente! Marcando como obsoleta uma função de uma biblioteca L, a mensagem obsoleta surge quando um programa chama a função, mesmo se o programa chamador não estiver na biblioteca L. Aviso levanta a mensagem SOMENTE quando L é compilado.

Aqui está a implementação do Roslyn, para que você possa criar seus próprios atributos que fornecem avisos ou erros imediatamente.

Eu criei um atributo Type Called IdeMessageque será o atributo que gera avisos:

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

    public IDEMessageAttribute(string message);
}

Para fazer isso, você precisa instalar o Roslyn SDK primeiro e iniciar um novo projeto VSIX com analisador. Omiti algumas das partes menos relevantes, como as mensagens, você pode descobrir como fazer isso. Em seu analisador, você faz isso

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

Não há CodeFixProvider para isso, você pode removê-lo da solução.