Question

我对c＃很陌生，而且我正在练习多态。我想要做的是让设备成为3种类型之一（操纵杆，鼠标或键盘）。我认为最好的方法是使用类和虚拟。这里的布局有问题吗？

namespace HID
{
    public class HIDControl
    {
.
.
.
    class agnosticDevice
    {
        private Joystick jDevice;
        private Mouse jMouse;
        private Keyboard jKeyboard;
        public string type;

        public virtual void device()// no way to return different types?
        {
            //if type is mouse return jMouse...ect?
        }
    }
.
.
.
    }
}

只是不明白如何做到这一点或者我可能已经离开了。有人可以帮忙吗？

进一步的信息，我在这里使用DX，也许有这方面的规定，但我没有看到如何。基本上在我的HIDControl类中，我设置了DX并根据用户输入创建了一个设备。此输入可能稍后更改，我需要更改我的设备。大多数设备大多使用相同的功能。事实上，一切都可以被视为操纵杆。虽然对于某些高级功能我需要更改类型。我知道我可以做类级多态，但是这么多类都是多余的。

另一个直接的解决方案是在我的班级中制作3个设备，但如果我这样做，我需要3个if语句用于每次使用，这只是丑陋。

[更新代码以评论意见和建议]

我想我在这里越来越近了，但是当我创建我的设备时，它并没有正确地继承成员。这是我到目前为止所拥有的

public abstract class AgnosticDevice
    {
        public abstract void SomeDeviceOperation();
    }

    public class vJoystick : AgnosticDevice, Joystick
    {
        public vJoystick( DirectInput di, Guid g){}
        public override void SomeDeviceOperation()
        {
            /* Joystick operation */
        }
    }

    public class vMouse : AgnosticDevice, Mouse
    {
        public vMouse( DirectInput di ){}
        public override void SomeDeviceOperation()
        {
            /* Mouse operation */
        }
    }

    public class vKeyboard : AgnosticDevice, Keyboard
    {
        public vKeyboard( DirectInput di , Guid g){}
        public override void SomeDeviceOperation()
        {
            /* Keyboard operation */
        }
    }

    public class DeviceFactory
    {
        public static AgnosticDevice Create( string type, DirectInput di, Guid g )
        {
            if ( type == "Mouse" )
            {
                return new vMouse( di);
            }
            if ( type == "Joystick" )
            {
                return new vJoystick( di, g);
            }
            if ( type == "Keyboard" )
            {
                return new vKeyboard( di, g);
            }
            return new vJoystick( di, g );//defult
        }
    }

然后我做

AgnosticDevice device = (vJoystick)DeviceFactory.Create( type, directInput, deviceGuid );

但是设备。（某些DX功能）不可用。

Answer 1

这里需要的是一个界面。定义这些不同输入设备之间的通用功能的东西。然后，您可以让这些类中的每一个都实现该接口，以便在他们需要的任何特定庄园中执行这些不同的操作。

Answer 2

这可能会给你一个想法：

创建一个接口或一个抽象类，并定义将在所有＆＃34;设备之间共享的功能＆＃34;：

public abstract class AgnosticDevice
{
    // methods ...
    public virtual void DoStuff()
    {
        // something
    }
}

然后将其用于更具体的设备：

public class Joystick : AgnosticDevice
{
    // perhaps overwrite DoStuff here ...
}

public class Mouse : AgnosticDevice
{

}

以下是如何使用它（这基本上是多态性）：

public class DeviceFactory
{
    public static AgnosticDevice Create(string someInput)
    {
        if (someInput == "something")
        {
            return new Mouse();
        }
        return new Joystick();
    }
}

如果您想指定每个不可知设备必须的行为，您最好创建一个接口（它可以没有实现），例如：

public interface IPluggable
{
    void Disconnect();
}

然后在你的一个＆＃34;可插拔的＆＃34;中实现它。装置：

public class Joystick : IPluggable
{
    public void Disconnect()
    {
        // awesome
    }
}

从这里看你可以做魔术，如：

// I want you to pass me a pluggable device, I don't care if it's a Joystick or a Mouse
public static void DoWork(IPluggable pluggableDevice)
{
    try
    {
        // something will go wrong !
    }
    catch (Exception ex)
    {
        LogException(ex);

        // all pluggable devices can disconnect, I don't care what you've passed as an argument!
        pluggableDevice.Disconnect();
    }
}

您可以使用它：

public void Test()
{
    DoWork(new Joystick());
    DoWork(new Mouse());

    // you can do some tests by throwing in a fake device
    // to simulate behaviors that you expect
    DoWork(new FakeDevice());
}

Answer 3

你在做什么是构成，而不是多态。您可以通过一个抽象的Device类和三个特化来实现多态：

public abstract class Device
{
    public abstract void SomeDeviceOperation();
}

public class Joystick : Device
{
    public override void SomeDeviceOperation()
    {
        /* Joystick operation */
    }
}

public class Mouse : Device
{
    public override void SomeDeviceOperation()
    {
        /* Mouse operation */
    }
}

public class Keyboard : Device
{
    public override void SomeDeviceOperation()
    {
        /* Keyboard operation */
    }
}

然后，您可以将Device的任何类子类分配给Device类型的变量，参数，参数等。例如：

public void DoOperationOnDevice(Device d)
{
    d.SomeDeviceOperation();
}

Device d = new Joystick();
d.SomeDeviceOperation();
DoOperationOnDevice(new Keyboard());
d = new Mouse();

c＃中的多态覆盖引发的麻烦

3 个答案: