---
title: "Introduire une méthode étrangère"
type: "refactoring-technique"
slug: "introduce-foreign-method"
url: "http://localhost:3000/fr/introduce-foreign-method.md"
category: "Moving Features between Objects"
description: "Problème : une classe utilitaire ne contient pas la méthode dont vous avez besoin et vous ne pouvez pas l'y ajouter. Solution : ajoutez la méthode à une classe cliente et passez-lui un objet de la classe utilitaire en argument."
languages: ["java", "csharp", "php", "python", "typescript"]
---
# Introduire une méthode étrangère

> Problème : une classe utilitaire ne contient pas la méthode dont vous avez besoin et vous ne pouvez pas l'y ajouter. Solution : ajoutez la méthode à une classe cliente et passez-lui un objet de la classe utilitaire en argument.

## Problem

Une classe utilitaire ne contient pas la méthode dont vous avez besoin et vous ne pouvez pas l'y ajouter.

## Solution

Ajoutez la méthode à une classe cliente et passez-lui un objet de la classe utilitaire en argument.

## Why Refactor

Vous avez du code qui utilise les données et les méthodes d'une certaine classe. Vous réalisez que ce code aurait meilleure allure et fonctionnerait bien mieux à l'intérieur d'une nouvelle méthode de la classe. Mais vous ne pouvez pas ajouter la méthode à la classe parce que, par exemple, la classe se trouve dans une bibliothèque tierce.

Ce refactoring offre un grand bénéfice lorsque le code que vous voulez déplacer dans la méthode est répété à plusieurs endroits différents de votre programme.

Puisque vous passez un objet de la classe utilitaire aux paramètres de la nouvelle méthode, vous avez accès à tous ses champs. À l'intérieur de la méthode, vous pouvez faire pratiquement tout ce que vous voulez, comme si la méthode faisait partie de la classe utilitaire.

## Benefits

* Supprime la duplication de code. Si votre code est répété à plusieurs endroits, vous pouvez remplacer ces fragments de code par un appel de méthode. Cela vaut mieux que la duplication, même en tenant compte du fait que la méthode étrangère se trouve à un emplacement non optimal.

## How to Refactor

1. Créez une nouvelle méthode dans la classe cliente.
2. Dans cette méthode, créez un paramètre auquel l'objet de la classe utilitaire sera passé. Si cet objet peut être obtenu depuis la classe cliente, vous n'avez pas besoin de créer un tel paramètre.
3. Extrayez les fragments de code concernés vers cette méthode et remplacez-les par des appels de méthode.
4. Veillez à laisser l'étiquette _Méthode étrangère_ dans les commentaires de la méthode, accompagnée du conseil de placer cette méthode dans une classe utilitaire si cela devient possible plus tard. Cela permettra à ceux qui maintiendront le logiciel à l'avenir de comprendre plus facilement pourquoi cette méthode se trouve dans cette classe en particulier.
## Relations

**Similar techniques**

- [Introduire une extension locale](/fr/introduce-local-extension.md)

**Eliminates smells**

- [Classe de bibliothèque incomplète](/fr/smells/incomplete-library-class.md)

## Code Examples

### java

```java
// Before
class Report {
  // ...
  void sendReport() {
    Date nextDay = new Date(previousEnd.getYear(),
      previousEnd.getMonth(), previousEnd.getDate() + 1);
    // ...
  }
}

// After
class Report {
  // ...
  void sendReport() {
    Date newStart = nextDay(previousEnd);
    // ...
  }
  private static Date nextDay(Date arg) {
    return new Date(arg.getYear(), arg.getMonth(), arg.getDate() + 1);
  }
}
```

### csharp

```csharp
// Before
class Report 
{
  // ...
  void SendReport() 
  {
    DateTime nextDay = previousEnd.AddDays(1);
    // ...
  }
}

// After
class Report 
{
  // ...
  void SendReport() 
  {
    DateTime nextDay = NextDay(previousEnd);
    // ...
  }
  private static DateTime NextDay(DateTime date) 
  {
    return date.AddDays(1);
  }
}
```

### php

```php
// Before
class Report {
  // ...
  public function sendReport() {
    $previousDate = clone $this->previousDate;
    $paymentDate = $previousDate->modify("+7 days");
    // ...
  }
}

// After
class Report {
  // ...
  public function sendReport() {
    $paymentDate = self::nextWeek($this->previousDate);
    // ...
  }
  /**
   * Méthode étrangère. Devrait se trouver dans Date.
   */
  private static function nextWeek(DateTime $arg) {
    $previousDate = clone $arg;
    return $previousDate->modify("+7 days");
  }
}
```

### python

```python
// Before
class Report:
    # ...
    def sendReport(self):
        nextDay = Date(self.previousEnd.getYear(),
            self.previousEnd.getMonth(), self.previousEnd.getDate() + 1)
        # ...

// After
class Report:
    # ...
    def sendReport(self):
        newStart = self._nextDay(self.previousEnd)
        # ...
        
    def _nextDay(self, arg):
        return Date(arg.getYear(), arg.getMonth(), arg.getDate() + 1)
```

### typescript

```typescript
// Before
class Report {
  // ...
  sendReport(): void {
    let nextDay: Date = new Date(previousEnd.getYear(),
      previousEnd.getMonth(), previousEnd.getDate() + 1);
    // ...
  }
}

// After
class Report {
  // ...
  sendReport() {
    let newStart: Date = nextDay(previousEnd);
    // ...
  }
  private static nextDay(arg: Date): Date {
    return new Date(arg.getFullYear(), arg.getMonth(), arg.getDate() + 1);
  }
}
```