Como você diz ao Resharper que um parâmetro de método é uma string contendo uma classe CSS?

[Habilite o intellisense no atributo HTMLHelper para classes css]

Eu tenho este HTMLhelper:

public IHtmlString MyTextBoxFor<TModel, TProperty>(
    this HtmlHelper<TModel> html, 
    Expression<Func<TModel, TProperty>> propertyExpression, 
    string cssClass)
{
    // ...
}

Quero que o Resharper me dê o IntelliSense para classes CSS definidas em meu aplicativo ao passar o valor para o parâmetro "cssClass".

Existem alguns atributos de anotação de código que o Resharper reconhece, mas nenhum que pareça diretamente relacionado à marcação de um parâmetro de método como sendo classes CSS.

O mais próximo que consegui encontrar foi [HtmlAttributeValue (nome da string)] . Tentei aplicar ao parâmetro cssClass assim:

public IHtmlString MyTextBoxFor<TModel, TProperty>(
    this HtmlHelper<TModel> html, 
    Expression<Func<TModel, TProperty>> propertyExpression, 
    [HtmlAttributeValue("class")] string cssClass)
{
    // ...
}

Mas isso não funciona. Também seria muito bom se o Resharper reconhecesse a classe inserida e parasse de me incomodar sobre classes CSS desconhecidas em expressões do seletor jQuery (que operam na caixa de texto gerada pelo auxiliar acima).

Edit: Aqui está uma captura de tela do tipo de intellisense que está funcionando para o parâmetro "htmlAttributes" de um método de ação. Isso é feito usando a anotação [HtmlElementAttributes] no parâmetro.

Eu quero uma anotação semelhante que me permita colocar classes css em um parâmetro de string e ter o mesmo intellisense mostrando as classes css.

Use [ValueProvider]

Das anotações de código atualmente suportadas pelo Resharper 10, o melhor candidato seria usar este atributo. No link acima:

ValueProviderAttribute

Para um parâmetro que se espera seja um do conjunto limitado de valores. Especifique os campos de qual tipo deve ser usado como valores para este parâmetro.

Infelizmente, não descobri como funciona. Talvez haja erros na minha versão 9.2 do Resharper.

O que tentei até agora:

namespace ValueProviderSample
{
    public static class MyValuesContainer
    {
        public static readonly string[] Values = { "one", "two", "three" };
    }

    public class MyMethodContainer
    {
        public string MyMethod([ValueProvider("ValueProviderSample.MyValuesContainer.Values")]
                               string parameter)
        {
            return string.Empty;
        }
    }
}

Mesmo se você fizer isso funcionar, você ainda terá que preencher a lista de valores.

E, claro, você ainda pode desenvolver sua anotação / extensão de código para Resharper.

Por que não usar um objeto de tipo forte em vez de uma string?

Às vezes, em vez de usar stringe int, podemos usar classes com tipos mais fortes de nosso próprio projeto. Como parece que você controla seu código, você pode, em vez de usar stringcom um nome css nele, criar um novo tipo como CssClass.

Você só precisa adicionar como um evento pré-construído uma chamada para um gerador que analisa cada css no projeto e cria dinamicamente uma classe como esta:

public class CssClass
{
    public string Name { get; private set; }

    public static CssClass In = new CssClass("in");

    /// <summary>
    /// Initialise une nouvelle instance de la classe <see cref="T:System.Object"/>.
    /// </summary>
    private CssClass(string name)
    {
        Name = name;
    }
}

e então sua amostra ficará assim:

public class MySample
{
    public IHtmlString MyTextBoxFor<TModel, TProperty>(
        this HtmlHelper<TModel> html,
        Expression<Func<TModel, TProperty>> propertyExpression,
        CssClass cssClass)
    {
        // ...
    }

    public void Usage()
    {
        MyTextBoxFor(html, expression, CssClass.In);
    }
}