È possibile fornire a C# intellisense di Visual Studio un suggerimento per visualizzare prima un certo overload di metodi?

Question

Ho due metodi che sono sovraccarichi di ogni altra

public class Car 
{ 
    public int GetPrice(string vinNumber) 
    { 
     string make = Database.GetMake(vinNumber); // expensive operation 
     string model = Database.GetModel(vinNumber); // expensive operation 
     int year = Database.GetYear(vinNumber); // expensive operation 

     return this.GetPrice(make, model, year); 
    } 

    public int GetPrice(string make, string model, int year) 
    { 
     // Calculate value and return 
    } 
} 

nel mio esempio, il GetPrice (marca, modello, anno) di sovraccarico è a buon mercato per l'esecuzione, ma il metodo GetPrice (vinNumber) è costoso. Il problema è che il metodo costoso ha il minor numero di parametri e compare prima nell'intelligenza C#.

Entrambi i metodi sono validi, ma desidero incoraggiare le persone a chiamare il metodo economico. Ma le persone tendono a non guardare attraverso tutti i sovraccarichi di Intellisense prima di scegliere un metodo per chiamare, e quello costoso viene chiamato troppo spesso nella base di codice della mia azienda.

C'è un modo per dire a Visual Studio di dare "priorità intellisense" a un metodo particolare in modo che venga visualizzato per primo?

Answer 1

Non penso.

A meno che non si scriva un plug-in intellisense (come Resharper) e l'hijack di default intellisense e si crei un programma per gli utenti che assegnano la priorità.

Answer 2

Quello che succede è questo:

• Mentre digitate il membro o evidenziare nella lista, il singolo di sovraccarico che si vede è quello elencato per primo nel codice.
• Dopo aver accettato il membro e sono all'interno delle parentesi, l'ordine sembra essere basato sul numero di parametri, dal più piccolo al più.

Che cosa si potrebbe prendere in considerazione facendo è, invece di sovraccarichi, nominare i membri stessi all'inizio e diverse alla fine (GetMake vs GetMakeSlow, ma ovviamente qualcosa di meglio) in modo da presentarsi insieme in Intellisense, ma è comunicato che dovresti usare.

Altrimenti, rendili veri sovraccarichi ma utilizza la documentazione XML per mettere un avviso chiaro su quello lento.

Answer 3

unica soluzione che posso offrire è commenti, ma ciò non significa che l'utente pagherà attenzione a loro:

/// <summary> 
    /// This method should be used as a last resort... 
    /// </summary> 
    /// <param name="vinNumber"></param> 
    /// <returns></returns> 
    public int GetPrice(string vinNumber) 
    { 
     ... 
    } 

    /// <summary> 
    /// This is the preferred method... 
    /// </summary> 
    /// <param name="make"></param> 
    /// <param name="model"></param> 
    /// <param name="year"></param> 
    /// <returns></returns> 
    public int GetPrice(string make, string model, int year) 
    { 
     ... 
    } 

Edit: Ho provato questo un non faceva alcuna differenza:

class Class1 
{ 
    public static void Method(int value1) { } 
    public static void Method(int value1, int value2) { } 
    public static void Method(int value1, int value2, int value3) { } 
} 

class Class2 
{ 
    public static void Method(int value1, int value2, int value3) { } 
    public static void Method(int value1, int value2) { } 
    public static void Method(int value1) { } 
} 

Answer 4

1. Il tag di riepilogo nei commenti XML viene visualizzato in Intellisense.

2. È possibile decorare il metodo con il tag Obsoleto, che genera anche un avviso o un errore in base alle impostazioni.

   [System.Obsolete("use GetPrice(make, model, year)")]