Question

想法如下：我希望有机会来反映项目的价值。项目可以是bool，int，double。每种类型都应该实现它自己的“逆转”逻辑。

逻辑就是这样：

    public interface IInterface<T>
{
    T Reverse(T value);
}

我知道对于泛型，所有类必须从常见派生而来，所以我创建了一个名为IInterface的接口：

Reverse(1); //int - expect to return -1
Reverse(true); // bool - expect to return false

现在在我的代码中，我想像那样运行：

package com.nust.QuizApplication.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.nust.QuizApplication.dao.UserDAO;
import com.nust.QuizApplication.model.User;

@Controller
@RequestMapping(value = "/users")
public class UserController {
    @Autowired
    private UserDAO userDao;


    @RequestMapping(value = "/signup" ,method = RequestMethod.GET, consumes = "application/json" )
    @ResponseBody
    public int create(@RequestBody User user) {
        int id = userDao.signupUser(user);
        if(id>0)
            return id;
        else
            return 0;
    }


    @RequestMapping(value = "/signin",method = RequestMethod.GET, consumes = "application/json" )
    @ResponseBody
    public boolean signinUser(@RequestBody User user) {
        boolean check = userDao.signinUser(user);
        if(check==true)
            return true;
        else
            return false;
    }

}

我被困住了，不知道怎么做到这一点。

Answer 1

有些东西告诉我，为了实现这样的方法而包装所有原始类型并不是一个好主意，从长远来看，你将面临不必要的复杂性。你为什么不用extension methods？例如：

KeyError

Answer 2

public interface IInterface<T>
{
    T Reverse(T value);
}

public class Integers : IInterface<int>
{
    public int Reverse(int value)
    {
        return -value;
    }
}

public class Bools : IInterface<bool>
{
    public bool Reverse(bool value)
    {
        return !value;
    }
}
class Program
{
    static void Main(string[] args)
    {
        Integers i = new Integers();
        Bools b = new Bools();

        Console.WriteLine(i.Reverse(5));
        Console.WriteLine(b.Reverse(true));
    }
}

选项编号2：

public class ReverseClass
{
    const string INT_TYPE = "System.Int32";
    const string BOOL_TYPE = "System.Boolean";

    public Object Reverse(Object value)
    {
        string type = value.GetType().ToString();

        switch(type)
        {
            case INT_TYPE:
                return -(Int32)value;
            case BOOL_TYPE:
                return !(bool)value;
        }
        return null;
    }
}

class Program
{
    static void Main(string[] args)
    {
        ReverseClass x = new ReverseClass();

        Console.WriteLine(x.Reverse(5));
        Console.WriteLine(x.Reverse(true));
    }
}

Answer 3

首先，我必须说你的方法违背了使用接口和泛型类型的目的。你使用的是通用类型的接口，但是对反向机制进行硬编码，它并没有真正帮助你，也可能在方法或扩展中对它们进行硬编码（如@mjwills建议）。

无论如何，我仍然会帮助你解决这个问题，你的方法可能是一种学习方法。

你的IInterface<T>很好，但实现它的类不是。他们必须指定使用的类型，如下所示：

public interface IInterface<T>
{
    T Reverse(T value);
}

public class Integers : IInterface<int>
{
    public int Reverse(int value)
    {
        return -value;
    }
}

public class Bools : IInterface<bool>
{
    public bool Reverse(bool value)
    {
        return !value;
    }
}

为了使用它，你必须创建每个类的实例并使用它们各自的Reverse方法，如下所示：

var integers = new Integers();
Console.WriteLine(integers.Reverse(1)); // -1

var bools = new Bools();
Console.WriteLine(bools.Reverse(true)); // False

Answer 4

嗯，我认为对此你的解决方案有点不合适：

我不想在integers.Reverse()上打电话，但要做更多＆＃34;泛型＆＃34;像：x.Reverse(1); x.Reverse(false);这可能吗？ x可以是任何...... 但我想避免ExtensionMethods方式。

c＃泛型类型的调用方法

4 个答案: