Skip to main content

Les-methodes

Méthodes​

Nommage​

Les noms de méthodes doivent résumer ce que fait la méthode. Ils doivent être précis, courts et représentatifs de l'opération en termes de synchronisation.

Verbes​

Les noms de méthodes doivent contenir des verbes pour représenter l'action qu'ils effectuent.

✅ A faire​
public List<Student> GetStudents()
{
    ...
}
❌ À ne pas faire​
public List<Student> Students()
{
    ...
}

Asynchronisme async/await​

Les méthodes asynchrones doivent être suffixées par le terme Async, comme les méthodes renvoyant Task ou ValueTask en général.

✅ A faire​
public async ValueTask<List<Student>> GetStudentsAsync()
{
    ...
}
❌ A ne pas faire​
public async ValueTask<List<Student>> GetStudents()
{
    ...
}

Paramètres d'entrée​

Les paramètres d'entrée doivent indiquer explicitement à quelle propriété d'un objet ils seront affectés, ou seront utilisés pour une action telle qu'une recherche.

✅ A faire​
public async ValueTask<Student> GetStudentByNameAsync(string studentName)
{
    ...
}
❌ A ne pas faire​
public async ValueTask<Student> GetStudentByNameAsync(string text)
{
    ...
}

❌ A ne pas faire​
public async ValueTask<Student> GetStudentByNameAsync(string name)
{
    ...
}

Paramètres d'action​

Si votre méthode effectue une action avec un paramètre particulier, spécifiez-le.

✅ A faire​
public async ValueTask<Student> GetStudentByIdAsync(Guid studentId)
{
    ...
}
❌ À ne pas faire​
public async ValueTask<Student> GetStudentAsync(Guid studentId)
{
    ...
}

Passage de paramètres​

Lors de l'utilisation d'une méthode, si les alias des paramètres d'entrée correspondent aux variables passées en partie ou en totalité, vous n'avez pas à utiliser les alias, sinon vous devez spécifier vos valeurs avec des alias.

Supposons que vous ayez une méthode :

Student GetStudentByNameAsync(string studentName);
✅ A faire​
string studentName = "Todd";
Student student = await GetStudentByNameAsync(studentName);
✅ Aussi à faire​
Student student = await GetStudentByNameAsync(studentName: "Todd");
✅ Aussi à faire​
Student student = await GetStudentByNameAsync(toddName);
❌ À ne pas faire​
Student student = await GetStudentByNameAsync("Todd");
❌ À ne pas faire​
Student student = await GetStudentByNameAsync(todd);

Organisation​

En général, encapsulez plusieurs lignes de la même logique dans leur propre méthode et gardez votre méthode au niveau 0 de détails en tout temps.

Lignes simples/multiples​

Lignes simples​

Toute méthode qui ne contient qu'une seule ligne de code doit utiliser des flèches "flat".

✅ A faire​
public List<Student> GetStudents() => this.storageBroker.GetStudents();
❌ À ne pas faire​
public List<Student> Students()
{
    return this.storageBroker.GetStudents();
}

Si une méthode d'une seule ligne dépasse la longueur de 120 caractères, effectuez un saut de ligne après la flèche fat avec une tabulation supplémentaire pour la nouvelle ligne.

✅ A faire​
public async ValueTask<List<Student>> GetAllWashingtonSchoolsStudentsAsync() =>
    await this.storageBroker.GetStudentsAsync();
❌ A ne pas faire​
public async ValueTask<List<Student>> GetAllWashingtonSchoolsStudentsAsync() => await this.storageBroker.GetStudentsAsync();
Lignes multiples​

Si une méthode contient plusieurs lignes séparées ou connectées via un chaînage, elle doit avoir une portée. À moins que les paramètres ne passent à la ligne suivante, une méthode d'une seule ligne avec des paramètres multilignes est autorisée.

✅ A faire​
public Student AddStudent(Student student)
{
    ValidateStudent(student);

    return this.storageBroker.InsertStudent(student);
}
✅ Aussi, à faire​
public Student AddStudent(Student student)
{
    return this.storageBroker.InsertStudent(student)
        .WithLogging();
}
✅ Aussi à faire​
public Student AddStudent(
    Student student)
{
    return this.storageBroker.InsertStudent(student);
}
❌ À ne pas faire​
public Student AddStudent(Student student) =>
    this.storageBroker.InsertStudent(student)
        .WithLogging();
❌ Aussi, à ne pas faire​
public Student AddStudent(
    Student student) =>
        this.storageBroker.InsertStudent(student);

Retours​

Pour les méthodes multilignes, prenez une nouvelle ligne entre la logique de la méthode et la ligne de retour finale (le cas échéant).

✅ A faire​
public List<Student> GetStudents()
{
    StudentsClient studentsApiClient = InitializeStudentApiClient();

    return studentsApiClient.GetStudents();
}
❌ À ne pas faire​
public List<Student> GetStudents()
{
    StudentsClient studentsApiClient = InitializeStudentApiClient();
    return studentsApiClient.GetStudents();
}

Appels multiples​

Avec plusieurs appels de méthode, si les deux appels font moins de 120 caractères, ils peuvent s'empiler, sauf si l'appel final est un retour de méthode, sinon séparez-les par une nouvelle ligne.

✅ A faire​
public List<Student> GetStudents()
{
    StudentsClient studentsApiClient = InitializeStudentApiClient();
    List<Student> students = studentsApiClient.GetStudents();

    return students;
}
❌ À ne pas faire​
public List<Student> GetStudents()
{
    StudentsClient studentsApiClient = InitializeStudentApiClient();

    List<Student> students = studentsApiClient.GetStudents();

    return students;
}
✅ A faire​
public async ValueTask<List<Student>> GetStudentsAsync()
{
    StudentsClient washingtonSchoolsStudentsApiClient =
        await InitializeWashingtonSchoolsStudentsApiClientAsync();

    List<Student> students = studentsApiClient.GetStudents();

    return students;
}
❌ À ne pas faire​
public async ValueTask<List<Student>> GetStudentsAsync()
{
    StudentsClient washingtonSchoolsStudentsApiClient =
        await InitializeWashingtonSchoolsStudentsApiClientAsync();
    List<Student> students = studentsApiClient.GetStudents();

    return students;
}

Déclaration​

Une déclaration de méthode ne doit pas dépasser 120 caractères.

✅ A faire​
public async ValueTask<List<Student>> GetAllRegisteredWashgintonSchoolsStudentsAsync(
    StudentsQuery studentsQuery)
{
    ...
}
❌ À ne pas faire​
public async ValueTask<List<Student>> GetAllRegisteredWashgintonSchoolsStudentsAsync(StudentsQuery studentsQuery)
{
    ...
}

<br />

Paramètres multiples​

Si vous passez plusieurs paramètres et que la longueur de l'appel de méthode dépasse 120 caractères, vous devez effectuer un saut de ligne par paramètre, avec un paramètre sur chaque ligne.

#✅ A faire​

List&lt;Student&gt; redmondHighStudents = await QueryAllWashingtonStudentsByScoreAndSchoolAsync(
    MinimumScore: 130,
    SchoolName: "Redmond High");
❌ À ne pas faire​
List&lt;Student&gt; redmondHighStudents = await QueryAllWashingtonStudentsByScoreAndSchoolAsync(
    MinimumScore: 130,SchoolName: "Redmond High");

Chaînage (Enlaidissement/Embellissement)​

Certaines méthodes offrent des extensions pour appeler d'autres méthodes. Par exemple, vous pouvez appeler une méthode Select() après une méthode Where(). Et ainsi de suite jusqu'à ce qu'une requête complète soit terminée.

Nous suivrons un processus d'enlaidissement et d'embellissement. Nous enlaidissons notre code pour embellir notre vue d'une chaîne de méthodes. Voici quelques exemples :

✅ A faire​
    students.Where(student =&gt; student.Name is "Elbek")
        .Select(student =&gt; student.Name)
            .ToList();
❌ À ne pas faire​
    students
    .Where(student =&gt; student.Name is "Elbek")
    .Select(student =&gt; student.Name)
    .OrderBy(student =&gt; student.Name)
    .ToList();

La première approche impose de simplifier et de raccourcir le chaînage, car davantage d'appels continuent d'enlaidir le code comme ceci :

    students.SomeMethod(...)
        .SomeOtherMethod(...)
            .SomeOtherMethod(...)
                .SomeOtherMethod(...)
                    .SomeOtherMethod(...);

Le processus d'enlaidissement force la décomposition des chaînes en listes plus petites, puis leur traitement. La deuxième approche (aucune approche d'enlaidissement) peut nécessiter des ressources cognitives supplémentaires pour distinguer une nouvelle instruction d'une instruction existante comme suit :

    student
    .Where(student =&gt; student.Name is "Elbek")
    .Select(student =&gt; student.Name)
    .OrderBy(student =&gt; student.Name)
    .ToList();
    ProcessStudents(students);