c# - 带有方法指针的通用接口(interface)

Question

所以，首先我有我的命令属性界面

public interface ICommandProperty<T, U>
{
    Func<T> CreateCommand { get; set; }
    Func<T, U> ParseResponse { get; set; }
}

我的想法是我可以创建一个简单的解析器，它接受一个字符串并返回一个 IP 地址，例如。

这个接口(interface)然后在另一个接口(interface)中使用:

public interface IDeviceCommand
{

    Func<ICommandProperty<object, object>> SetCommand
    {
        get;
        set;
    }
    Func<ICommandProperty<object, object>> GetCommand
    {
        get;
        set;
    }
    string Name { get; set; }
}

我可能做错了，但这就是我的问题所在。目前我有用对象声明的通用接口(interface)，因为我想不出一种方法来通用地设置它们(由于各种原因，IDeviceCommand 不能通用)。

我的具体实现是这样的:

public class DeviceCommand:IDeviceCommand 
{
    public DeviceCommand(string name,Func<ICommandProperty<object,object>> Set,Func<ICommandProperty<object,object>> Get)
    {
        this.Name = name;
        this.SetCommand = Set;
        this.GetCommand = Get;
    }
    #region IDeviceCommand Members
    public string Name
    {
        get;
        set;
    }
    public object Value
    {
        get;
        set;
    }
    public Func<ICommandProperty<object, object>> SetCommand
    {
        get;
        set;
    }
    public Func<ICommandProperty<object, object>> GetCommand
    {
        get;
        set;
    }
    #endregion
}

我可以使 DeviceCommand 成为一个通用类，并在 SetCommand 和 GetCommand 上使用 T、U，但它不满足 IDeviceCommand 接口(interface)，因为 Func<ICommandProperty<T,U>> isn't Func<ICommandProperty<object,object>>

我应该在这里使用不同的方法吗？本质上，我正在尝试创建一个方法指针，我可以在实例化 DeviceCommand 时设置它。

Answer 1

您的问题似乎有点含糊，但这里有一些想法。首先是考虑使用方法而不是属性，这样它们就可以是通用的而不是类。不确定这是否适合您。您还可以考虑将“构建器”对象传递到您的设备命令中，而不是 func<> 本身。最后，这会让您的客户知道要请求什么并确保它正在使用具有正确 func<> 可用的对象。在这种情况下，也许像 IDeviceCommand.Create 和 .Parse 方法之类的方法对您有用。

最后，如果您一直在寻找获取字符串并返回 IP 的东西，则可能不需要泛型。甚至可以探索普通的老代表。

public interface ICommandProperty<T, U>
    {
        Func<T> CreateCommand { get; set; }
        Func<T, U> ParseResponse { get; set; }
    }

    public interface IDeviceCommand
    {

        void SetCreateCommand<T, U>(Func<ICommandProperty<T, U>> cmd);
        void SetParseCommand<T, U>(Func<ICommandProperty<T, U>> cmd);

        Func<ICommandProperty<T, U>> GetCreateCommand<T, U>();
        Func<ICommandProperty<T, U>> GetParseCommand<T, U>();

        void Create(object someKnownObject);
        T Parse<T>(object someKnownObject);

        string Name { get; set; }
    }

    public class DeviceCommand : IDeviceCommand
    {
        public DeviceCommand(IDeviceCommandBuilder builder)
        {
            builder.SetCommands(this);
        }


        public void SetCreateCommand<T, U>(Func<ICommandProperty<T, U>> cmd)
        {
            throw new NotImplementedException();
        }

        public void SetParseCommand<T, U>(Func<ICommandProperty<T, U>> cmd)
        {
            throw new NotImplementedException();
        }

        public Func<ICommandProperty<T, U>> GetCreateCommand<T, U>()
        {
            throw new NotImplementedException();
        }

        public Func<ICommandProperty<T, U>> GetParseCommand<T, U>()
        {
            throw new NotImplementedException();
        }

        public void Create(object someKnownObject)
        {
            throw new NotImplementedException();
        }

        public T Parse<T>(object someKnownObject)
        {
            throw new NotImplementedException();
        }

        public string Name
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }
    }

    public interface IDeviceCommandBuilder
    {
        void SetCommands(IDeviceCommand command);
    }

    public class DeviceCommandBuilder : IDeviceCommandBuilder
    {
        public void SetCommands(IDeviceCommand command)
        {
            command.SetCreateCommand<string,Uri>(.)
            ;
            command.SetParseCommand(.);
        }
    }