Come si dice a Resharper che un parametro del metodo è una stringa contenente una classe CSS?

[Abilita intellisense sull'attributo HTMLHelper per le classi CSS]

Ho questo HTMLhelper:

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

Voglio che Resharper mi dia IntelliSense per le classi CSS definite nella mia applicazione quando si passa il valore per il parametro "cssClass".

Ci sono alcuni attributi di annotazione del codice che Resharper riconosce, ma nessuno che sembra direttamente correlato alla marcatura di un parametro del metodo come classi CSS.

Il più vicino che ho trovato è stato [HtmlAttributeValue (string name)] . Ho provato ad applicare al parametro cssClass in questo modo:

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

Ma non funziona. Sarebbe anche fantastico se Resharper riconoscesse la classe inserita e smettesse di infastidirmi sulle classi CSS sconosciute nelle espressioni del selettore jQuery (che operano sulla casella di testo generata dall'helper sopra).

Modifica: ecco uno screenshot del tipo di intellisense che funziona per il parametro "htmlAttributes" di un metodo di azione. Ciò si ottiene utilizzando l'annotazione [HtmlElementAttributes] sul parametro.

Voglio un'annotazione simile che mi consenta di inserire le classi CSS in un parametro stringa e visualizzare lo stesso intellisense che mostra le classi CSS.

Usa [ValueProvider]

Dalle annotazioni del codice attualmente supportate da Resharper 10, il miglior candidato utilizzerebbe questo attributo. Dal collegamento sopra:

ValueProviderAttribute

Per un parametro che dovrebbe essere uno dei set limitati di valori. Specificare i campi di quale tipo deve essere utilizzato come valori per questo parametro.

Sfortunatamente, non ho capito come funziona. Forse è difettoso nella mia versione 9.2 di Resharper.

Quello che ho provato finora:

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

Anche se lo fai funzionare, dovrai comunque popolare l'elenco Valori.

E, naturalmente, puoi ancora sviluppare l'annotazione / estensione del codice per Resharper.

Perché non usare un oggetto tipizzato forte invece di una stringa?

A volte invece di usare stringe int, potremmo usare classi con caratteri più forti di nostra progettazione. Dato che sembra che tu controlli il tuo codice, puoi invece di usarlo stringcon un nome CSS, puoi creare un nuovo tipo come CssClass.

Devi solo aggiungere come evento precostruito una chiamata a un generatore che analizza ogni CSS nel progetto e crea dinamicamente una classe come questa:

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 quindi il tuo campione avrà questo aspetto:

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