双向适配器和可插拔适配器都可以访问这两个类，也可以更改需要更改的方法的行为。以下是我的代码:
双向适配器
public interface IAircraft
{
bool Airborne { get; }
void TakeOff();
int Height { get; }
}
// Target
public sealed class Aircraft : IAircraft
{
int height;
bool airborne;
public Aircraft()
{
height = 0;
airborne = false;
}
public void TakeOff()
{
Console.WriteLine("Aircraft engine takeoff");
airborne = true;
height = 200; // Meters
}
public bool Airborne
{
get { return airborne; }
}
public int Height
{
get { return height; }
}
}
// Adaptee interface
public interface ISeacraft
{
int Speed { get; }
void IncreaseRevs();
}
// Adaptee implementation
public class Seacraft : ISeacraft
{
int speed = 0;
public virtual void IncreaseRevs()
{
speed += 10;
Console.WriteLine("Seacraft engine increases revs to " + speed + " knots");
}
public int Speed
{
get { return speed; }
}
}
// Adapter
public class Seabird : Seacraft, IAircraft
{
int height = 0;
// A two-way adapter hides and routes the Target's methods
// Use Seacraft instructions to implement this one
public void TakeOff()
{
while (!Airborne)
IncreaseRevs();
}
// Routes this straight back to the Aircraft
public int Height
{
get { return height; }
}
// This method is common to both Target and Adaptee
public override void IncreaseRevs()
{
base.IncreaseRevs();
if (Speed > 40)
height += 100;
}
public bool Airborne
{
get { return height > 50; }
}
}
class Experiment_MakeSeaBirdFly
{
static void Main()
{
// No adapter
Console.WriteLine("Experiment 1: test the aircraft engine");
IAircraft aircraft = new Aircraft();
aircraft.TakeOff();
if (aircraft.Airborne) Console.WriteLine(
"The aircraft engine is fine, flying at "
+ aircraft.Height + "meters");
// Classic usage of an adapter
Console.WriteLine("\nExperiment 2: Use the engine in the Seabird");
IAircraft seabird = new Seabird();
seabird.TakeOff(); // And automatically increases speed
Console.WriteLine("The Seabird took off");
// Two-way adapter: using seacraft instructions on an IAircraft object
// (where they are not in the IAircraft interface)
Console.WriteLine("\nExperiment 3: Increase the speed of the Seabird:");
(seabird as ISeacraft).IncreaseRevs();
(seabird as ISeacraft).IncreaseRevs();
if (seabird.Airborne)
Console.WriteLine("Seabird flying at height " + seabird.Height +
" meters and speed " + (seabird as ISeacraft).Speed + " knots");
Console.WriteLine("Experiments successful; the Seabird flies!");
Console.Read();
}
}
可插拔模式
class Adaptee
{
public double Precise(double a, double b)
{
return a / b;
}
}
// New standard for requests
class Target
{
public string Estimate(int i)
{
return "Estimate is " + (int)Math.Round(i / 3.0);
}
}
// Implementing new requests via old
class Adapter : Adaptee
{
public Func<int, string> Request;
// Different constructors for the expected targets/adaptees
// Adapter-Adaptee
public Adapter(Adaptee adaptee)
{
// Set the delegate to the new standard
Request = x =>
{
return "Estimate based on precision is " +
(int)Math.Round(Precise(x, 3));
};
}
// Adapter-Target
public Adapter(Target target)
{
// Set the delegate to the existing standard
Request = target.Estimate;
}
}
class Client
{
static void Main()
{
Adapter adapter1 = new Adapter(new Adaptee());
Console.WriteLine(adapter1.Request(5));
Adapter adapter2 = new Adapter(new Target());
Console.WriteLine(adapter2.Request(5));
Console.Read();
}
}
在上面的两个代码示例中，我没有发现在模式的功能方面有什么不同。那么图案之间有什么区别呢？谁能帮我理解一下？我一直在引用这个 Design Pattern C# 3.0
更新 1
我无法理解这个引用中给出的例子，所以我更新了一个简单的代码，我想根据代码从场景中实现双向适配器
interface Ibike {
void Ride(int energy,int time);
}
class Bike : Ibike {
public void Ride(int energy,int time) {
Console.WriteLine("riding bike with calories of energy "+energy+" spend time "+time);
}
}
interface Imotorcycle {
void Ride(int fuel);
}
class Motorcycle : Imotorcycle {
public void Ride(int fuel) {
Console.WriteLine("riding motorbike with fuel "+fuel);
}
}
class Client {
static void Main() {
Ibike bike = new Bike();
Imotorcycle motorBike = new Motorcycle();
bike.Ride(50, 2);
motorBike.Ride(3);
Console.Read();
}
}
最佳答案
从 C# 3.0 Design Patterns 中提取的所有引号，恰好与您的问题相同。
对报价的大胆强调在我身上。
在双向适配器上:
在这种情况下，除了适应多个系统之间的通用功能之外，我们还讨论了使来自不同系统的两个(或更多)不同功能可用于同一适配器上的调用。在您的代码示例中:
//The adapter
IAircraft seabird = new Seabird( );
// This is a IAircraft method
seabird.TakeOff( );
//This is NOT a IAircraft method, but is made available through the adapter.
(seabird as ISeacraft).IncreaseRevs( );
现在，关于可插拔适配器:
所以这里我们有一个通用名称，任何系统的任何插入方法都可以通过该名称调用，但在给定时间只能使用一个。
我认为这两种方法都可以通过不同的方式或以不同的细节级别执行提供类似结果的操作，但这似乎不是模式的规则。
同样，使用您的示例:
Adapter adapter1 = new Adapter (new Adaptee( ));
//Here, it will call the Adaptee's abstracted method.
adapter1.Request(5);
//The only way to call the Target's method is to instantiate a new adapter with the target
Adapter adapter2 = new Adapter (new Target( ));
Console.WriteLine(adapter2.Request(5));
结论:
尽管所有适配器都有相同的目标，即通过 ITarget 为客户端提供 Adaptee，但每个适配器都为一组不同的问题提供了解决方案，无论是 双向适配器，使两个 Target 都可用于 Adaptee，反之亦然 或 Pluggable 以原子方式抽象 Target 和 Adaptee 的行为 。
希望这有助于消除两个适配器之间的差异。
更新 1. 有关双向的更多信息:
我可以通过您的示例告诉您，您没有了解双向适配器的用途。仅当您需要交替使用 Adaptee 和 Target 时才需要它，就像您将它们不同的功能合并到一个对象中一样。
如果它们都做同样的事情(即 Ride)，您最好改用可插拔适配器。
让我们以适合使用双向适配器的方式改进您的新示例。
interface IBike {
void Pedal();
}
class Bike : IBike {
public void Pedal() {
Console.WriteLine("Moving my vehicle with my body");
}
}
interface IMotorcycle {
void Accelerate();
}
class Motorcycle : IMotorcycle {
public virtual void Accelerate() {
Console.WriteLine("Moving my vehicle with a hydrocarbon fuel engine");
}
}
class ElectricBike : Motorcycle, IBike {
bool _isAccelerating = false;
public override void Accelerate() {
_isAccelerating = true;
Console.WriteLine("Moving my vehicle with a electric engine");
}
public void Pedal() {
if (!_isAccelerating)
Console.WriteLine("Moving my vehicle with my body");
else
Console.WriteLine("Occupying my body with senseless effort, for my vehicle is already moving");
}
}
class MovingMyVehicle {
static void Main() {
IMotorcycle motorBike = new Motorcycle();
//That is expected, as IMotorcycle can Accelerate.
motorBike.Accelerate();
IBike newBike = new ElectricBike();
//That too is expected, as IBike can Pedal.
newBike.Pedal();
//Now that´s something new, as IBike cannot Accelerate,
//but the the ElectricBike adapter can, as it implements both interfaces.
(newBike as IMotorcycle).Accelerate();
Console.Read();
}
}
关于c# - C#中的双向适配器模式和可插拔适配器模式有什么区别？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/40365488/