C# 泛型类中的构造函数不明确/冲突

我有一个通用类：

public class BaseFieldValue<T>
{
    public BaseFieldValue()
    {
        //...
    }

    public BaseFieldValue(string value)
    {
        //...
    }

    public BaseFieldValue(T value)
    {
        //...
    }
}

公共类BaseFieldValue
{
公共BaseFieldValue（）
{
//...
}
公共BaseFieldValue（字符串值）
{
//...
}
公共基线值（T值）
{
//...
}
}

好的。除了

var myValue = new BaseFieldValue<string>("hello");

var myValue=新的BaseFieldValue（“hello”）；

---

哎呀。调用不需要的构造函数。有很多方法可以解决这个问题。最好的解决方案是什么？

我可能会将其中一个重载转换为工厂方法：

public static BaseFieldValue<T> Parse(string value){}

publicstaticbasefieldvalue解析（字符串值）{}

您可以执行以下操作：

public class BaseFieldValue<T>
{
    public struct Special
    {
        internal string m_value;
        public Special(string value)
        {
            m_value = value;
        }
    }

    public BaseFieldValue()
    {
        //...
    }

    public BaseFieldValue(Special value)
    {
        //...
    }

    public BaseFieldValue(T value)
    {
        //...
    }
}

公共类BaseFieldValue
{
公共结构专用
{
内部字符串m_值；
公共特殊（字符串值）
{
m_值=值；
}
}
公共BaseFieldValue（）
{
//...
}
公共基线值（特殊值）
{
//...
}
公共基线值（T值）
{
//...
}
}

---

。。。或者，您可以在特殊构造函数中添加一个额外的被忽略的布尔参数，以消除歧义。

这是一个令人讨厌的攻击，但可能不会比任何其他方法更糟糕：

public class BaseFieldValue<T>
{
    public BaseFieldValue()
    {
        // ...
    }

    public BaseFieldValue(StringWrapper value)
    {
        // ...
    }

    public BaseFieldValue(T value)
    {
        // ...
    }

    public class StringWrapper
    {
        private string _value;

        public static implicit operator string(StringWrapper sw)
        {
            return sw._value;
        }

        public static implicit operator StringWrapper(string s)
        {
            return new StringWrapper { _value = s };
        }
    }
}

公共类BaseFieldValue
{
公共BaseFieldValue（）
{
// ...
}
公共BaseFieldValue（StringWrapper值）
{
// ...
}
公共基线值（T值）
{
// ...
}
公共类StringWrapper
{
私有字符串_值；
公共静态隐式运算符字符串（StringWrapper sw）
{
返回sw.\u值；
}
公共静态隐式运算符StringWrapper（字符串s）
{
返回新的StringWrapper{u value=s}；
}
}
}

现在，您可以根据需要使用它：

// call the generic constructor
var myValue = new BaseFieldValue<string>("hello");

// call the string constructor
var myValue = new BaseFieldValue<int>("hello");

//调用泛型构造函数
var myValue=新的BaseFieldValue（“你好”）；
//调用字符串构造函数
var myValue=新的BaseFieldValue（“你好”）；

无法使类型约束符合我的要求，因此我的解决方法是删除不明确的构造函数，同时保留字符串的特殊情况：

public class BaseFieldValue<T>
{
    public BaseFieldValue()
    {
        //...
    } 

    public BaseFieldValue(T value) 
    {
        //however many things you need to test for here
        if (typeof(T) == typeof(string))
        {
            SpecialBaseFieldValue(value.ToString());
        }
        else
        {
            //everything else
        }
        //...
    }

    private void SpecialBaseFieldValue(string value)
    {
        //...
    }

}

公共类BaseFieldValue
{
公共BaseFieldValue（）
{
//...
} 
公共基线值（T值）
{
//不管你在这里需要测试多少东西
if（typeof（T）=typeof（string））
{
SpecialBaseFieldValue（value.ToString（））；
}
其他的
{
//其他一切
}
//...
}
私有void SpecialBaseFieldValue（字符串值）
{
//...
}
}

可能是您可以尝试以下方法：

var myValue = new BaseFieldValue<Object>("hello" as Object);  

var myValue=新的BaseFieldValue（“hello”作为对象）；

如果BaseFieldValue是一个数据库连接类，而字符串是连接字符串，该怎么办？@Yuriy在这种情况下，这仍然是可行的。@Rex，是的，但它与其他数据库连接类不同，只是试图保留模式。我与我们的开发团队一起测试了这一实现，他们发现它非常直观。干杯可能您可以尝试这样做：var myValue=newbasefieldvalue（“hello”作为对象）；但是当您使用

BaseFieldValue

，

BaseFieldValue

，

BaseFieldValue

，

BaseFieldValue

等的实例时，

typeof（T）

将永远不会等于

typeof（string）

。