Question

我在C＃中编写一个随机值生成器，这个泛型函数应该返回值Type Bool，Int64，Int32，Double取决于在类型传递。所以，我可以将System.Type作为方法参数传递，但是如何定义返回类型？

例如

GetRandomValueByType(TypeCode.Boolean)＆lt; ---返回布尔值 GetRandomValueByType(TypeCode.Double)＆lt; ---返回Double GetRandomValueByType(TypeCode.Int32)＆lt; ---返回Int32

依此类推。

谢谢！

--------------------------- EDIT ------------------- -------------

这是我使用的代码：

if (ta.IsPrimitive || Type.GetTypeCode(ta) == TypeCode.String)
{
    Random rnd = new Random();
    var buffer = new byte[sizeof(Int64)];
    rnd.NextBytes(buffer);
    switch (Type.GetTypeCode(ta))
    {
        case TypeCode.Boolean:
            oArr[ctr] = (rnd.Next(100) % 2 == 0);
            break;
        case TypeCode.Byte:
            oArr[ctr] = buffer[0];
            break;
        case TypeCode.SByte:
            oArr[ctr] = (sbyte)buffer[0];
            break;
        case TypeCode.Char:
            oArr[ctr] = Convert.ToInt32(Math.Floor(26 * rnd.NextDouble() + 65));
            break;
        case TypeCode.Decimal:
            oArr[ctr] = NextDecimal(rnd);
            break;
        case TypeCode.Double:
            oArr[ctr] = rnd.NextDouble() * rnd.Next(Int32.MaxValue);
            break;
        case TypeCode.Single:
            var buf = new byte[sizeof(Single)];
            rnd.NextBytes(buf);
            oArr[ctr] = BitConverter.ToSingle(buffer, 0);
            break;
        case TypeCode.Int32:
            oArr[ctr] = rnd.Next(Int32.MinValue, Int32.MaxValue);
            break;
        case TypeCode.UInt32:
            oArr[ctr] = rnd.Next(Int32.MaxValue) + (rnd.Next(100) % 2) * rnd.Next(Int32.MaxValue);
            break;
        case TypeCode.Int64:
            oArr[ctr] = BitConverter.ToInt64(buffer, 0);
            break;
        case TypeCode.UInt64:
            oArr[ctr] = BitConverter.ToUInt64(buffer, 0);
            break;
        case TypeCode.Int16:
            oArr[ctr] = rnd.Next(Int16.MaxValue);
            break;
        case TypeCode.UInt16:
            oArr[ctr] = rnd.Next(Int16.MaxValue) + (rnd.Next(100) % 2) * rnd.Next(Int16.MaxValue);
            break;
        case TypeCode.String:
            oArr[ctr] = RandomString(rnd.Next(100));
            break;
        default:
            oArr[ctr] = 0;
            break;
    }
}
else
{
    oArr[ctr] = getInstance(dllFile, ta.Name);
}

Answer 1

泛型可能在这里很方便 - 你可以做类似的事情：

T GetRandomValueByType<T>() where T : IConvertible
{
   // Compute random...
   return Convert.ChangeType(randomValue, typeof(T));
}

然后通过以下方式调用：

double value = GetRandomValueByType<double>();

但是，这并非完全安全（并非使用System.Type），因为您仍然可以传递实现IConvertible但不合适的类型。

鉴于您的评论，我建议您制作单独的方法：

bool GetRandomBoolean() { // ...
double GetRandomDouble() { // ...
int GetRandomInt() { // ...

如果您已经打开类型并进行特定实现，这将提供一种更清晰，更安全的方式来处理它。通过使用单独的方法，可以消除传递错误类型的可能性，并简化API。

Answer 2

您需要将这些方法设为通用：

T GetRandomValueByType<T>()
{
    ...
}

GetRandomValueByType<Boolean>();
GetRandomValueByType<Double>();
GetRandomValueByType<Int32>();

Answer 3

您是一个通用实现：

    public class Generic
    {
      public static T GetRandomValueByType<T>(T parameter)
      {
        switch(typeof(T))
        {
            case System.Int32:
                Random r = new Random();
                return (T)r.Next();
            case System.Guid:
                return (T)Guid.NewGuid();
            // other cases here...
}
      }
    }

并使用以下内容：

var value = Generic.GetRandomValueByType<bool>();

您也可以使用Random类提供一些随机值作为样本。

返回函数中传递的Type的值

3 个答案: