Object-Oriented Programming

一、导入

OOP（Object-Oriented Programming，面向对象编程）是一种编程范式，它使用“对象”来设计应用程序和计算机程序。

很多人在初次学习OOP时，可能会感到有些困惑，因为传统的编程范式，如过程式编程，其实已经足以完成自己设想中大多数编程任务了。

毕竟，数据结构和算法是编程的核心，代码所做的一切，不过是对数据进行一步步的输入、处理和输出。

但是显然，当代码量从几十行增加到几百行、几千行甚至更多时，程序的复杂度也会随之增加，这时候仅仅只靠过程式编程的思路就显得力不从心了，这一步和下一步的关系变得越来越难以把握，代码的可读性和可维护性也会大幅下降。

而面向对象最重要的功能便体现在管理代码的层面。

二、猪脚饭！牛肉面！小糕点！

中国是有 56 个民族，坐拥五千年的历史文化，拥有丰富的饮食文化。中国的饮食文化博大精深，地域差异明显，形成了八大菜系和众多地方特色美食。

对于同一家的门头（餐馆）、不同的员工，他们的职责（下面称作 interface(接口) ）不同。对于同一个员工、不同的餐馆，他们的工作方法（下面称作 method(方法) ）也不同

但是对人来说，做饭、端盘子、整理物品确是手拿把掐的事情，我们或许可以称之为技能（下面称作 implement(实现) interface(接口) ），同样是做饭、端盘子、整理物品，不同的员工又有不同的技能实现（下面称作 polymorphism(多态)）

三、基础实现

下面的一份代码是实现了一个简单的外卖服务系统，里面包含了餐馆(Restaurant)、员工(Employee)、骑手(DeliveryDriver)、客人(Customer)的概念。

/// Order.cs
namespace Food;

/// <summary>
/// 订单类，包含订单的基本信息，如起点、目的地和食物内容。
/// </summary>
public class Order
{
		public string Origin { get; init; }
		public string Destination { get; init; }
		public bool IsDelivered { get; set; } = false;
		public string FoodItem { get; init; }

		public Order(string origin, string destination, string foodItem)
		{
				Origin = origin;
				Destination = destination;
				FoodItem = foodItem;
		}
}

/// Restaurant.cs
using System;
namespace Food;

/// <summary>
/// 餐馆类，包含餐馆的基本信息，如名称、地址和菜单。
/// </summary>
public class Restaurant
{
		public string Name { get; init; }
		public List<string> Menu { get; set; } = new List<string>();
		public List<Employee> Employees { get; set; } = new List<Employee>();

		public Restaurant(string name, string address)
		{
				Name = name;
		}

		/// <summary>
		/// 创建订单的方法，检查菜单中是否包含所点的食物，如果包含，则返回订单对象；否则，提示食物不在菜单中。
		/// </summary>
		/// <param name="foodItem">所点的食物名称</param>
		/// <param name="customer">客人对象</param>
		public Order CreateOrder(string foodItem, Customer customer)
		{
				if (Menu.Contains(foodItem))
				{
						foreach (Employee employee in Employees)
						{
								if (employee.IsAvailable)
								{
										Console.WriteLine($"Employee {employee.Name} is preparing the order: {foodItem}");
										employee.IsAvailable = false;
										Order order = new Order(Name, customer.Address, foodItem);
										Console.WriteLine($"Order created by {employee.Name}: {foodItem} from {Name} to {customer.Name}");
										return order;
								}
						}
				}
				else
				{
						Console.WriteLine($"Sorry, {foodItem} is not available in the menu.");
						return null;
				}
		}
}

/// Employee.cs
namespace Food;

/// <summary>
/// 员工类，包含员工的基本信息，如姓名和技能。
/// </summary>
public class Employee
{
		public string Name { get; init; }
		public string Skill { get; init; }
		public bool IsAvailable { get; set; } = true;

		public Employee(string name, string skill)
		{
				Name = name;
				Skill = skill;
		}
}

/// DeliveryDriver.cs
using System;
namespace Food;

/// <summary>
/// 骑手类，包含骑手的基本信息，如姓名和订单列表。
/// </summary>
public class DeliveryDriver
{
		public string Name { get; init; }
		public List<Order> Orders { get; set; } = new List<Order>();

		public DeliveryDriver(string name)
		{
				Name = name;
		}

		public void AddOrder(Order order)
		{
				if (order is null)
				{
						Console.WriteLine("Cannot add a null order.");
						return;
				}
				Orders.Add(order);
		}

		/// <summary>
		/// 模拟骑手送餐的过程，遍历订单列表并打印送餐信息，送完后清空订单列表。
		/// </summary>
		public void DeliverOrders()
		{
				foreach (var order in Orders)
				{
						Console.WriteLine($"Delivering order {order.Origin} to {order.Destination} with food item {order.FoodItem}");
						order.IsDelivered = true;
				}
				Orders.Clear();
		}
}

/// Customer.cs
using System;
namespace Food;

/// <summary>
/// 客人类，包含客人的基本信息，如姓名和地址。
/// </summary>
public class Customer
{
		public string Name { get; init; }
		public string Address { get; init; }

		public Customer(string name, string address)
		{
				Name = name;
				Address = address;
		}

		public void ReceiveOrder(Order order)
		{
			  if (!order.IsDelivered)
				{
					Console.WriteLine($"Order from {order.Origin} to {order.Destination} with food item {order.FoodItem} has not been delivered yet.");
					return;
				}
				Console.WriteLine($"Customer {Name} received order from {order.Origin} with food item {order.FoodItem}");
		}
}

/// Program.cs
using Food;
using System;

/// <summary>
/// 主程序类，包含程序的入口点。
/// </summary>
class Program
{
		static void Main(string[] args)
		{
				// 创建餐馆对象
				Restaurant restaurant = new Restaurant("Delicious Food");

				// 创建员工对象
				Employee chef = new Employee("Alice", "Everything");

				// 创建骑手对象
				DeliveryDriver driver = new DeliveryDriver("Charlie");

				// 创建客人对象
				Customer customer = new Customer("David", "456 Elm St");

				// 添加菜单项
				restaurant._menu.Add("Pork Rice");
				restaurant._menu.Add("Beef Noodles");

				// 创建订单对象
				Order order1 = restaurant.CreateOrder("Pork Rice", customer);
				Order order2 = restaurant.CreateOrder("Beef Noodles", customer);

				// 骑手接收订单
				driver.AddOrder(order1);
				driver.AddOrder(order2);

				// 骑手送餐
				driver.DeliverOrders();

				// 客人接收订单
				customer.ReceiveOrder(order1);
				customer.ReceiveOrder(order2);
		}
}

在这里，我们通过最简单的对象来实现了一个外卖服务系统的基本功能。每个类都代表了系统中的一个实体，并且通过方法和属性来定义它们的行为和状态。

但是，随着系统的复杂度增加，我们可能需要引入更多的类和接口来管理不同的功能和行为，这就是面向对象编程的魅力所在。

例如，对于当前员工对象来说，一个员工只能拥有一个技能，但是出于资本家的善意，我们希望员工可以拥有多项技能，这样他们就可以在不同的岗位上工作。

最简单的实现就是在 Employee 类中添加一个技能列表，并在创建员工对象时指定其技能。然后，我们可以通过检查员工的技能列表来判断他们是否具备某项技能。

例如：

public class Employee
{
		public string Name { get; init; }
		public List<string> Skills { get; set; } = new List<string>();
		public bool IsAvailable { get; set; } = true;

		public Employee(string name, List<string> skills)
		{
				Name = name;
		}

		public bool HasSkill(string skill)
		{
				return Skills.Contains(skill);
		}
}

public class Restaurant
{
		// ... 其他属性和方法 ...

		/// <summary>
		/// 创建订单的方法，检查菜单中是否包含所点的食物，如果包含，返回订单对象；否则，提示食物不在菜单中。
		/// </summary>
		/// <param name="foodItem">所点的食物名称</param>
		/// <param name="cook">实现了 ICookable 接口的厨师对象</param>
		/// <param name="customer">客人对象</param>
		public Order CreateOrder(string foodItem, Customer customer)
		{
				if (_menu.Contains(foodItem))
				{
						foreach (Employee employee in _employees)
						{
								if (employee.IsAvailable && employee.HasSkill("Cooking"))
								{
										Console.WriteLine($"Employee {employee.Name} is preparing the order: {foodItem}");
										employee.IsAvailable = false;
										Order order = new Order(_address, customer._address, foodItem);
										Console.WriteLine($"Order created by {employee.Name}: {foodItem} from {_name} to {customer._name}");
										return order;
								}
						}
				}
				else
				{
						Console.WriteLine($"Sorry, {foodItem} is not available in the menu.");
						return null;
				}
		}
}

但是，这种实现方式不论是性能上，还是实现上都并不优雅（需要大量的判断以及搜索），也不符合面向对象编程的原则。我们可以通过引入接口（interface）来更好地管理员工的技能。

四、接口(interface)

例如，考虑到并不是每一个员工都会做饭，我们定义一个 ICookable 接口，表示具备做饭技能的员工。然后，我们可以让具备做饭技能的员工类实现这个接口。

/// ICookable.cs
namespace Food;

/// <summary>
/// ICookable 接口，表示具备做饭技能的员工。
/// </summary>
public interface ICookable
{
		void Cook(string foodItem);
}

/// Employee.cs
namespace Food;

/// <summary>
/// 普通员工类，表示普通员工
/// </summary>
public abstract class EmployeeBase
{
	public abstract string Name { get; init; }
	public abstract bool IsAvailable { get; set; }

	public Employee(string name)
	{
		Name = name;
	}
}

/// <summary>
/// 厨师类，表示具备做饭技能的员工
/// </summary>
public class Chef : EmployeeBase, ICookable
{
	public override string Name { get; init; }
	public override bool IsAvailable { get; set; } = true;

	public Chef(string name) : base(name)
	{
		Name = name;
	}
	public void Cook(string foodItem)
	{
		Console.WriteLine($"Cook {Name} is cooking {foodItem}");
	}
}

同时，对于 Restaurant.cs

/// <summary>
/// 餐馆类，包含餐馆的基本信息，如名称、地址和菜单。
/// </summary>
public class Restaurant
{
	public string Name { get; init; }
	public List<string> Menu { get; set; } = new List<string>();
	public List<EmployeeBase> Employees { get; set; } = new List<EmployeeBase>();

	public Restaurant(string name)
	{
		Name = name;
	}

	/// <summary>
	/// 创建订单的方法，检查菜单中是否包含所点的食物，如果包含，则调用厨师的 Cook 方法进行烹饪，并返回订单对象；否则，提示食物不在菜单中。
	/// </summary>
	/// <param name="foodItem">所点的食物名称</param>
	/// <param name="customer">客人对象</param>
	public Order CreateOrder(string foodItem, Customer customer)
	{
		if (Menu.Contains(foodItem))
		{
			var cook = from employee in Employees
								 where employee is ICookable && employee.IsAvailable
								 select employee as ICookable;
			if (cook == null)
			{
				Console.WriteLine("No available cook found.");
				return null;
			}
			cook.First().Cook(foodItem);
			Console.WriteLine($"Order created: {foodItem} from {Name} to {customer.Name}");
			return new Order(Name, customer.Address, foodItem);
		}
		else
		{
			Console.WriteLine($"Sorry, {foodItem} is not available in the menu.");
			return null;
		}
	}
}

同时，对于 Program.cs

/// Program.cs
using Food;
using System;

/// <summary>
/// 主程序类，包含程序的入口点。
/// </summary>
class Program
{
		static void Main(string[] args)
		{
				// 创建餐馆对象
				Restaurant restaurant = new Restaurant("Delicious Food");
				// 创建厨师对象
				Chef chef = new Chef("Alice");
				restaurant.Employees.Add(chef);

				// 创建骑手对象
				DeliveryDriver driver = new DeliveryDriver("Charlie");

				// 创建客人对象
				Customer customer = new Customer("David", "456 Elm St");

				// 添加菜单项
				restaurant.Menu.Add("Pork Rice");
				restaurant.Menu.Add("Beef Noodles");

				// 创建订单对象
				Order order1 = restaurant.CreateOrder("Pork Rice", customer);
				Order order2 = restaurant.CreateOrder("Beef Noodles", customer);

				// 骑手接收订单
				driver.Orders.Add(order1);
				driver.Orders.Add(order2);

				// 骑手送餐
				driver.DeliverOrders();

				// 客人接收订单
				customer.ReceiveOrder(order1);
				customer.ReceiveOrder(order2);
		}
}

就此，一个通过接口实现依赖反转的外卖程序完成了，如果一切正常的话，你应该会得到如下输出

Cook Alice is cooking Pork Rice
Order created: Pork Rice from Delicious Food to David
Cook Alice is cooking Beef Noodles
Order created: Beef Noodles from Delicious Food to David
Delivering order Delicious Food to 456 Elm St with food item Pork Rice
Delivering order Delicious Food to 456 Elm St with food item Beef Noodles
Customer David received order from Delicious Food with food item Pork Rice
Customer David received order from Delicious Food with food item Beef Noodles

五、其他员工

显然，只有厨师的餐厅还不够，而且，当前的餐厅也不够灵活，毕竟，餐厅的员工可能是厨师，也可能是服务员，也可能是清洁工。

让我们来定义更多接口，来表示不同的员工技能,以及多样的餐厅。

/// IWaitable.cs
namespace Food;

/// <summary>
/// IWaiter 接口，表示具备服务技能的员工。
/// </summary>
public interface IWaitable
{
		void Serve(string foodItem);
}

/// ICleanable.cs
namespace Food;

/// <summary>
/// ICleaner 接口，表示具备清洁技能的员工。
/// </summary>
public interface ICleanable
{
		void Clean();
}

/// Employee.cs
namespace Food;

// Chef and EmployeeBase classes remain the same

/// <summary>
/// 服务员类，表示具备服务技能的员工
/// </summary>
public class Waiter : EmployeeBase, IWaitable
{
	public override string Name { get; init; }
	public override bool IsAvailable { get; set; } = true;

	public Waiter(string name) : base(name)
	{
		Name = name;
	}

	public void Serve(string foodItem)
	{
		Console.WriteLine($"Waiter {Name} is serving {foodItem}");
	}
}

/// <summary>
/// 清洁工类，表示具备清洁技能的员工
/// </summary>
public class Cleaner : EmployeeBase, ICleanable
{
	public override string Name { get; init; }
	public override bool IsAvailable { get; set; } = true;

	public Cleaner(string name) : base(name)
	{
		Name = name;
	}

	public void Clean()
	{
		Console.WriteLine($"Cleaner {Name} is cleaning the restaurant");
	}
}

/// IDrinkable.cs
namespace Food;

/// <summary>
/// IDrinkable 接口, 表示具备提供饮品能力的接口。
/// </summary>
public interface IDrinkable
{
	/// <summary>
	/// 创建饮品订单的方法，检查菜单中是否包含所点的饮品，如果包含，则返回订单对象；否则，提示饮品不在菜单中。
	/// </summary>
	/// <param name="drinkItem">被点的饮品。</param>
	/// <param name="customer">下单的顾客。</param>
	void CreateDrinkOrder(string drinkItem, Customer customer);
}

/// IEatable.cs
namespace Food;

/// <summary>
/// IEatable 接口, 表示具备提供食物能力的接口。
/// </summary>
public interface IEatable
{
	/// <summary>
	/// 创建食物订单的方法，检查菜单中是否包含所点的食物，如果包含，则返回订单对象；否则，提示食物不在菜单中。
	/// </summary>
	/// <param name="foodItem">被点的食物。</param>
	/// <param name="customer">下单的顾客。</param>
	void CreateEatOrder(string foodItem, Customer customer);
}

/// Restaurant.cs
namespace Food;

/// <summary>
/// RestaurantBase 抽象类，表示餐馆的基本信息和行为。
/// </summary>
public abstract class RestaurantBase
{
	public abstract string Name { get; init; }
	public virtual List<string> FoodMenu { get; set; }
	public virtual List<string> DrinkMenu { get; set; }
	public abstract List<EmployeeBase> Employees { get; set; }

	public RestaurantBase(string name)
	{
		Name = name;
	}

	public abstract void CleanRestaurant();
}

/// <summary>
/// 食物餐馆类，表示提供食物的餐馆。
/// </summary>
public class FoodRestaurant : RestaurantBase, IEatable
{
	public override string Name { get; init; }
	public override List<string> FoodMenu { get; set; } = new List<string>();
	public override List<EmployeeBase> Employees { get; set; } = new List<EmployeeBase>();

	public FoodRestaurant(string name) : base(name)
	{
		Name = name;
	}

	public override void CleanRestaurant()
	{
		var cleaner = from employee in Employees
									where employee is ICleanable && employee.IsAvailable
									select employee as ICleanable;
		if (cleaner == null)
		{
			Console.WriteLine("No available cleaner found.");
			return;
		}
		cleaner.First().Clean();
		Console.WriteLine($"Restaurant {Name} has been cleaned.");
	}

	public Order CreateEatOrder(string foodItem, Customer customer)
	{
		if (FoodMenu.Contains(foodItem))
		{
			var cook = from employee in Employees
								 where employee is ICookable && employee.IsAvailable
								 select employee as ICookable;
			if (cook == null)
			{
				Console.WriteLine("No available cook found.");
				return null;
			}
			cook.First().Cook(foodItem);

			var waiter = from employee in Employees
									 where employee is IWaitable && employee.IsAvailable
									 select employee as IWaitable;
			if (waiter == null)
			{
				Console.WriteLine("No available waiter found.");
				return null;
			}
			waiter.First().Serve(foodItem);
			Console.WriteLine($"Order created: {foodItem} from {Name} to {customer.Name}");
			return new Order(Name, customer.Address, foodItem);
		}
		else
		{
			Console.WriteLine($"Sorry, {foodItem} is not available in the menu.");
			return null;
		}
	}
}

/// <summary>
/// 饮品餐馆类，表示提供饮品的餐馆。
/// </summary>
public class DrinkRestaurant : RestaurantBase, IDrinkable
{
	public override string Name { get; init; }
	public override List<string> DrinkMenu { get; set; } = new List<string>();
	public override List<EmployeeBase> Employees { get; set; } = new List<EmployeeBase>();

	public DrinkRestaurant(string name) : base(name)
	{
		Name = name;
	}

	public override void CleanRestaurant()
	{
		var cleaner = from employee in Employees
									where employee is ICleanable && employee.IsAvailable
									select employee as ICleanable;
		if (cleaner == null)
		{
			Console.WriteLine("No available cleaner found.");
			return;
		}
		cleaner.First().Clean();
		Console.WriteLine($"Restaurant {Name} has been cleaned.");
	}

	public Order CreateDrinkOrder(string drinkItem, Customer customer)
	{
		if (DrinkMenu.Contains(drinkItem))
		{
			var waiter = from employee in Employees
									 where employee is IWaitable && employee.IsAvailable
									 select employee as IWaitable;
			if (waiter == null)
			{
				Console.WriteLine("No available waiter found.");
				return null;
			}
			waiter.First().Serve(drinkItem);
			Console.WriteLine($"Order created: {drinkItem} from {Name} to {customer.Name}");
			return new Order(Name, customer.Address, drinkItem);
		}
		else
		{
			Console.WriteLine($"Sorry, {drinkItem} is not available in the menu.");
			return null;
		}
	}
}

这时，对于 Program.cs

/// <summary>
/// 主程序类，包含程序的入口点。
/// </summary>
class Program
{
	static void Main(string[] args)
	{
		// 创建食物餐馆、员工和顾客对象
		FoodRestaurant foodRestaurant = new FoodRestaurant("Food Paradise");
		foodRestaurant.FoodMenu.AddRange(new List<string> { "Burger", "Pizza", "Pasta" });
		foodRestaurant.Employees.Add(new Chef("John"));
		foodRestaurant.Employees.Add(new Waiter("Alice"));
		foodRestaurant.Employees.Add(new Cleaner("Bob"));

		// 创建饮品餐馆、员工和顾客对象
		DrinkRestaurant drinkRestaurant = new DrinkRestaurant("Drink Heaven");
		drinkRestaurant.DrinkMenu.AddRange(new List<string> { "Coke", "Juice", "Water" });
		drinkRestaurant.Employees.Add(new Waiter("Eve"));
		drinkRestaurant.Employees.Add(new Cleaner("Charlie"));

		// 创建骑手、顾客对象
		DeliveryDriver deliveryDriver = new DeliveryDriver("Mike");
		Customer customer = new Customer("David", "123 Main St");

		// 创建食物订单
		var foodOrder = foodRestaurant.CreateEatOrder("Pizza", customer);

		// 创建饮品订单
		var drinkOrder = drinkRestaurant.CreateDrinkOrder("Coke", customer);

		// 清洁餐馆
		foodRestaurant.CleanRestaurant();
		drinkRestaurant.CleanRestaurant();

		// 骑手送餐
		deliveryDriver.Orders.Add(foodOrder);
		deliveryDriver.Orders.Add(drinkOrder);
		deliveryDriver.DeliverOrders();

		// 顾客接收订单
		customer.ReceiveOrder(foodOrder);
		customer.ReceiveOrder(drinkOrder);
	}
}

一切正常（可能也存在代码error，大概率是因为我没有复制好代码，这时请参考第六节完整代码实现）的话，你应该会得到如下输出

Cook John is cooking Pizza
Waiter Alice is serving Pizza
Order created: Pizza from Food Paradise to David
Waiter Eve is serving Coke
Order created: Coke from Drink Heaven to David
Cleaner Bob is cleaning the restaurant
Restaurant Food Paradise has been cleaned.
Cleaner Charlie is cleaning the restaurant
Restaurant Drink Heaven has been cleaned.
Delivering order Food Paradise to 123 Main St with food item Pizza
Delivering order Drink Heaven to 123 Main St with food item Coke
Customer Food Paradise received order from 123 Main St with food item Pizza
Customer Drink Heaven received order from 123 Main St with food item Coke

六、完整代码实现（单文件）

using System;
using System.Collections.Generic;
using System.Linq;
namespace Food;

/// <summary>
/// IDrinkable 接口, 表示具备提供饮品能力的接口。
/// </summary>
public interface IDrinkable
{
	/// <summary>
	/// 创建饮品订单的方法，检查菜单中是否包含所点的饮品，如果包含，则返回订单对象；否则，提示饮品不在菜单中。
	/// </summary>
	/// <param name="drinkItem">被点的饮品。</param>
	/// <param name="customer">下单的顾客。</param>
	Order CreateDrinkOrder(string drinkItem, Customer customer);
}

/// <summary>
/// IEatable 接口, 表示具备提供食物能力的接口。
/// </summary>
public interface IEatable
{
	/// <summary>
	/// 创建食物订单的方法，检查菜单中是否包含所点的食物，如果包含，则返回订单对象；否则，提示食物不在菜单中。
	/// </summary>
	/// <param name="foodItem">被点的食物。</param>
	/// <param name="customer">下单的顾客。</param>
	Order CreateEatOrder(string foodItem, Customer customer);
}

/// <summary>
/// ICookable 接口，表示具备做饭技能的员工。
/// </summary>
public interface ICookable
{
	void Cook(string foodItem);
}

/// <summary>
/// IWaiter 接口，表示具备服务技能的员工。
/// </summary>
public interface IWaitable
{
	void Serve(string foodItem);
}

/// <summary>
/// ICleaner 接口，表示具备清洁技能的员工。
/// </summary>
public interface ICleanable
{
	void Clean();
}

/// <summary>
/// 订单类，包含订单的基本信息，如起点、目的地和食物内容。
/// </summary>
public class Order
{
	public string Origin { get; init; }
	public string Destination { get; init; }
	public bool IsDelivered { get; set; } = false;
	public string FoodItem { get; init; }

	public Order(string origin, string destination, string foodItem)
	{
		Origin = origin;
		Destination = destination;
		FoodItem = foodItem;
	}
}

/// <summary>
/// RestaurantBase 抽象类，表示餐馆的基本信息和行为。
/// </summary>
public abstract class RestaurantBase
{
	public abstract string Name { get; init; }
	public virtual List<string> FoodMenu { get; set; }
	public virtual List<string> DrinkMenu { get; set; }
	public abstract List<EmployeeBase> Employees { get; set; }

	public RestaurantBase(string name)
	{
		Name = name;
	}

	public abstract void CleanRestaurant();
}

/// <summary>
/// 食物餐馆类，表示提供食物的餐馆。
/// </summary>
public class FoodRestaurant : RestaurantBase, IEatable
{
	public override string Name { get; init; }
	public override List<string> FoodMenu { get; set; } = new List<string>();
	public override List<EmployeeBase> Employees { get; set; } = new List<EmployeeBase>();

	public FoodRestaurant(string name) : base(name)
	{
		Name = name;
	}

	public override void CleanRestaurant()
	{
		var cleaner = from employee in Employees
									where employee is ICleanable && employee.IsAvailable
									select employee as ICleanable;
		if (cleaner == null)
		{
			Console.WriteLine("No available cleaner found.");
			return;
		}
		cleaner.First().Clean();
		Console.WriteLine($"Restaurant {Name} has been cleaned.");
	}

	public Order CreateEatOrder(string foodItem, Customer customer)
	{
		if (FoodMenu.Contains(foodItem))
		{
			var cook = from employee in Employees
								 where employee is ICookable && employee.IsAvailable
								 select employee as ICookable;
			if (cook == null)
			{
				Console.WriteLine("No available cook found.");
				return null;
			}
			cook.First().Cook(foodItem);

			var waiter = from employee in Employees
									 where employee is IWaitable && employee.IsAvailable
									 select employee as IWaitable;
			if (waiter == null)
			{
				Console.WriteLine("No available waiter found.");
				return null;
			}
			waiter.First().Serve(foodItem);
			Console.WriteLine($"Order created: {foodItem} from {Name} to {customer.Name}");
			return new Order(Name, customer.Address, foodItem);
		}
		else
		{
			Console.WriteLine($"Sorry, {foodItem} is not available in the menu.");
			return null;
		}
	}
}

/// <summary>
/// 饮品餐馆类，表示提供饮品的餐馆。
/// </summary>
public class DrinkRestaurant : RestaurantBase, IDrinkable
{
	public override string Name { get; init; }
	public override List<string> DrinkMenu { get; set; } = new List<string>();
	public override List<EmployeeBase> Employees { get; set; } = new List<EmployeeBase>();

	public DrinkRestaurant(string name) : base(name)
	{
		Name = name;
	}

	public override void CleanRestaurant()
	{
		var cleaner = from employee in Employees
									where employee is ICleanable && employee.IsAvailable
									select employee as ICleanable;
		if (cleaner == null)
		{
			Console.WriteLine("No available cleaner found.");
			return;
		}
		cleaner.First().Clean();
		Console.WriteLine($"Restaurant {Name} has been cleaned.");
	}

	public Order CreateDrinkOrder(string drinkItem, Customer customer)
	{
		if (DrinkMenu.Contains(drinkItem))
		{
			var waiter = from employee in Employees
									 where employee is IWaitable && employee.IsAvailable
									 select employee as IWaitable;
			if (waiter == null)
			{
				Console.WriteLine("No available waiter found.");
				return null;
			}
			waiter.First().Serve(drinkItem);
			Console.WriteLine($"Order created: {drinkItem} from {Name} to {customer.Name}");
			return new Order(Name, customer.Address, drinkItem);
		}
		else
		{
			Console.WriteLine($"Sorry, {drinkItem} is not available in the menu.");
			return null;
		}
	}
}

/// <summary>
/// 普通员工类，表示普通员工
/// </summary>
public abstract class EmployeeBase
{
	public abstract string Name { get; init; }
	public abstract bool IsAvailable { get; set; }

	public EmployeeBase(string name)
	{
		Name = name;
	}
}

/// <summary>
/// 厨师类，表示具备做饭技能的员工
/// </summary>
public class Chef : EmployeeBase, ICookable
{
	public override string Name { get; init; }
	public override bool IsAvailable { get; set; } = true;

	public Chef(string name) : base(name)
	{
		Name = name;
	}
	public void Cook(string foodItem)
	{
		Console.WriteLine($"Cook {Name} is cooking {foodItem}");
	}
}

/// <summary>
/// 服务员类，表示具备服务技能的员工
/// </summary>
public class Waiter : EmployeeBase, IWaitable
{
	public override string Name { get; init; }
	public override bool IsAvailable { get; set; } = true;

	public Waiter(string name) : base(name)
	{
		Name = name;
	}

	public void Serve(string foodItem)
	{
		Console.WriteLine($"Waiter {Name} is serving {foodItem}");
	}
}

/// <summary>
/// 清洁工类，表示具备清洁技能的员工
/// </summary>
public class Cleaner : EmployeeBase, ICleanable
{
	public override string Name { get; init; }
	public override bool IsAvailable { get; set; } = true;

	public Cleaner(string name) : base(name)
	{
		Name = name;
	}

	public void Clean()
	{
		Console.WriteLine($"Cleaner {Name} is cleaning the restaurant");
	}
}

/// <summary>
/// 骑手类，包含骑手的基本信息，如姓名和订单列表。
/// </summary>
public class DeliveryDriver
{
	public string Name { get; init; }
	public List<Order> Orders { get; set; } = new List<Order>();

	public DeliveryDriver(string name)
	{
		Name = name;
	}

	/// <summary>
	/// 模拟骑手送餐的过程，遍历订单列表并打印送餐信息，送完后清空订单列表。
	/// </summary>
	public void DeliverOrders()
	{
		foreach (var order in Orders)
		{
			Console.WriteLine($"Delivering order {order.Origin} to {order.Destination} with food item {order.FoodItem}");
			order.IsDelivered = true;
		}
		Orders.Clear();
	}
}

/// <summary>
/// 客人类，包含客人的基本信息，如姓名和地址。
/// </summary>
public class Customer
{
	public string Name { get; init;	 }
	public string Address { get; init; }

	public Customer(string name, string address)
	{
		Name = name;
		Address = address;
	}

	public void ReceiveOrder(Order order)
	{
		if (!order.IsDelivered)
		{
			Console.WriteLine($"Order from {order.Origin} to {order.Destination} with food item {order.FoodItem} has not been delivered yet.");
			return;
		}
		Console.WriteLine($"Customer {order.Origin} received order from {order.Destination} with food item {order.FoodItem}");
	}
}

/// <summary>
/// 主程序类，包含程序的入口点。
/// </summary>
class Program
{
	static void Main(string[] args)
	{
		// 创建食物餐馆、员工和顾客对象
		FoodRestaurant foodRestaurant = new FoodRestaurant("Food Paradise");
		foodRestaurant.FoodMenu.AddRange(new List<string> { "Burger", "Pizza", "Pasta" });
		foodRestaurant.Employees.Add(new Chef("John"));
		foodRestaurant.Employees.Add(new Waiter("Alice"));
		foodRestaurant.Employees.Add(new Cleaner("Bob"));

		// 创建饮品餐馆、员工和顾客对象
		DrinkRestaurant drinkRestaurant = new DrinkRestaurant("Drink Heaven");
		drinkRestaurant.DrinkMenu.AddRange(new List<string> { "Coke", "Juice", "Water" });
		drinkRestaurant.Employees.Add(new Waiter("Eve"));
		drinkRestaurant.Employees.Add(new Cleaner("Charlie"));

		// 创建骑手、顾客对象
		DeliveryDriver deliveryDriver = new DeliveryDriver("Mike");
		Customer customer = new Customer("David", "123 Main St");

		// 创建食物订单
		var foodOrder = foodRestaurant.CreateEatOrder("Pizza", customer);

		// 创建饮品订单
		var drinkOrder = drinkRestaurant.CreateDrinkOrder("Coke", customer);

		// 清洁餐馆
		foodRestaurant.CleanRestaurant();
		drinkRestaurant.CleanRestaurant();

		// 骑手送餐
		deliveryDriver.Orders.Add(foodOrder);
		deliveryDriver.Orders.Add(drinkOrder);
		deliveryDriver.DeliverOrders();

		// 顾客接收订单
		customer.ReceiveOrder(foodOrder);
		customer.ReceiveOrder(drinkOrder);
	}
}