《重构》：Extract Class and Inline Class

hey，gays lets go on to refator those sh!t .

i fork a rep, this the link

GitHub - TIMPICKLE/refator-code: 重构 - 改善既有代码的设计

all right, lets see the genel description.

提取类

对立：内联类 目的：将大类分成小类 场景：维护一个大量函数和数据的类

class Person{
  get officeAreaCode(){
    return this._officeAreaCode;
  }
  get officeNumber(){
    return this._officeNumber;
  }
}

class Person{
  constructor(telephoneNumber){
    this._telephoneNumber = telephoneNumber;
  }
  get officeAreaCode(){
    return this._telephoneNumber.areaCode;
  }
  get officeNumber(){
    return this._telephoneNumber.number;
  }
}
class TelephoneNumber{
  get areaCode(){
    return this._areaCode;
  }
  get number(){
    return this._number;
  }
}

内联类

对立：提炼类 目的：减少不必要的类 场景： 如果一个类不再承担足够的责任 重新分类两个类的不同职责

class Person{
  constructor(telephoneNumber){
    this._telephoneNumber = telephoneNumber;
  }
  get officeAreaCode(){
    return this._telephoneNumber.areaCode;
  }
  get officeNumber(){
    return this._telephoneNumber.number;
  }
}
class TelephoneNumber{
  get areaCode(){
    return this._areaCode;
  }
  get number(){
    return this._number;
  }
}

class Person{
  get officeAreaCode(){
    return this._officeAreaCode;
  }
  get officeNumber(){
    return this._officeNumber;
  }
}

我在阅读重构的时候，对内联类和提取类有一些疑问，他们看起来是对立的，那么在实际的代码中，我该如何选择呢？给我一些具体的例子？

在实际的代码中，选择内联类还是提取类取决于具体情况。下面是一些例子，可以帮助你更好地理解：

**内联类的例子**

如果一个类只有少量的属性和方法，而且这个类在整个代码中只被使用了一次，那么你可以考虑将这个类内联到使用它的地方。这样可以减少类的数量，使代码更加简洁。

例如，假设你有一个 `Person` 类和一个 `Address` 类，每个人都有一个地址。如果你只在 `Person` 类中使用了 `Address` 类一次，那么你可以将 `Address` 类内联到 `Person` 类中，使代码更加简洁。

**提取类的例子**

如果一个类的职责过于复杂，包含了多个不同的职责或功能，那么你可以考虑将这个类拆分成多个小的类。这样可以使代码更加清晰，并且每个类只需要关注自己的职责。

例如，假设你有一个 `Order` 类，这个类既包含了订单信息，又包含了订单处理的逻辑。如果你将订单处理逻辑提取成一个独立的类，比如 `OrderProcessor` 类，那么代码会更加清晰，并且每个类都只需要关注自己的职责。

希望这些例子可以帮助你更好地理解内联类和提取类的使用场景。

有代码实例吗？

当然，以下是一些具体的C#代码示例，以帮助您更好地理解内联类和提取类：

**内联类的示例：**

public class Person {
    public string Name { get; set; }
    public Address Address { get; set; }

    public void PrintAddress() {
        Console.WriteLine("Address: " + this.Address.ToString());
    }

    // other methods
}

public class Address {
    public string Street { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string ZipCode { get; set; }

    public override string ToString() {
        return $"{this.Street}, {this.City}, {this.State} {this.ZipCode}";
    }
}

在上面的代码中，`Person` 类只使用了一次 `Address` 属性，并且只有一个方法使用了这个属性。因此，我们可以将 `Address` 类内联到 `Person` 类中，使代码更加简洁：

public class Person {
    public string Name { get; set; }
    public string Street { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string ZipCode { get; set; }

    public void PrintAddress() {
        Console.WriteLine($"Address: {this.Street}, {this.City}, {this.State} {this.ZipCode}");
    }

    // other methods
}

**提取类的示例：**

public class Order {
    public int OrderId { get; set; }
    public string CustomerName { get; set; }
    public string CustomerAddress { get; set; }
    public List<OrderItem> Items { get; set; }

    public void ProcessOrder() {
        // process the order
    }

    // other methods
}

在上面的代码中，`Order` 类包含了订单信息和订单处理的逻辑。如果我们将订单处理逻辑提取成一个独立的类 `OrderProcessor`，那么代码会更加清晰，并且每个类都只需要关注自己的职责：

public class Order {
    public int OrderId { get; set; }
    public string CustomerName { get; set; }
    public string CustomerAddress { get; set; }
    public List<OrderItem> Items { get; set; }

    // other methods
}

public class OrderProcessor {
    public void ProcessOrder(Order order) {
        // process the order
    }
}

希望这些示例可以帮助您更好地理解内联类和提取类的使用场景。