C# 在.NET Framework中是否有什么东西可以检查某个值是否适合某个类型？

我需要确定

十进制值是否适合某个类型（目标类型在运行时被检测到），如果不适合，则将其截断为最大值或最小值，以便通过网络发送

我希望避免使用带有类型的大切换语句，我认为在.NET Framework中可能已经有了一些东西。
此操作在信号处理中有一个名称：

这里有一个完全无用的

小数限制器，它基于一个以

x => x <= min ? min : x >= max ? max : (T)x;

我甚至包括了一个扩展方法

使用示例：

int i1 = decimal.MaxValue.Clip<int>();
int i2 = decimal.MinValue.Clip<int>();
int i3 = 5.5M.Clip<int>();
int i4 = -5.5M.Clip<int>();
byte i5 =(-5.5M).Clip<byte>();
//char i6 = decimal.MaxValue.Clip<char>();
float i7 = decimal.MaxValue.Clip<float>();
double i8 = decimal.MaxValue.Clip<double>();
decimal i9 = decimal.MaxValue.Clip<decimal>();

int i1=decimal.MaxValue.Clip（）；
int i2=decimal.MinValue.Clip（）；
int i3=5.5M.夹子（）；
int i4=-5.5M.Clip（）；
字节i5=（-5.5M）.Clip（）；
//char i6=decimal.MaxValue.Clip（）；
float i7=decimal.MaxValue.Clip（）；
double i8=decimal.MaxValue.Clip（）；
decimal i9=decimal.MaxValue.Clip（）；

啊。。。表达式树只为使用的每个类型

T

生成一次，然后由于泛型类型和静态成员的工作而被缓存

---

此时不支持

char

、

IntPtr

、

UIntPtr

。

这将是我的解决方案

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            decimal value = 123456.789M;

            Console.WriteLine(ConvertOrMinMax<Byte>(value));
            Console.WriteLine(ConvertOrMinMax<Int16>(value));
            Console.WriteLine(ConvertOrMinMax<Int32>(value));
            Console.WriteLine(ConvertOrMinMax<Int64>(value));
            Console.WriteLine(ConvertOrMinMax<Decimal>(value));
            Console.WriteLine(ConvertOrMinMax<Double>(value));
            Console.WriteLine(ConvertOrMinMax<float>(value));

            Console.Read();
        }

        static T ConvertOrMinMax<T>(decimal v)
        {
            var myType = typeof(T);

            if(myType == typeof(double) || myType == typeof(float))
                return (T)Convert.ChangeType(v, myType);

            decimal min = (decimal)Convert.ChangeType(myType.GetField("MinValue").GetValue(null), typeof(decimal));

            if (v < min)
                return (T)Convert.ChangeType(min, myType);

            decimal max = (decimal)Convert.ChangeType(myType.GetField("MaxValue").GetValue(null), typeof(decimal)); ;

            if (v > max)
                return (T)Convert.ChangeType(max, myType);

            return (T)Convert.ChangeType(v, myType);
        }
    }
}

使用系统；
命名空间控制台应用程序1
{
班级计划
{
静态void Main（字符串[]参数）
{
十进制值=123456.789M；
Console.WriteLine（ConvertOrMinMax（value））；
Console.WriteLine（ConvertOrMinMax（value））；
Console.WriteLine（ConvertOrMinMax（value））；
Console.WriteLine（ConvertOrMinMax（value））；
Console.WriteLine（ConvertOrMinMax（value））；
Console.WriteLine（ConvertOrMinMax（value））；
Console.WriteLine（ConvertOrMinMax（value））；
Console.Read（）；
}
静态T转换器最大值（十进制v）
{
var myType=typeof（T）；
如果（myType==typeof（double）| | myType==typeof（float））
return（T）Convert.ChangeType（v，myType）；
decimal min=（decimal）Convert.ChangeType（myType.GetField（“MinValue”）.GetValue（null），typeof（decimal））；
如果（v最大值）
return（T）Convert.ChangeType（max，myType）；
return（T）Convert.ChangeType（v，myType）；
}
}
}

首先，您如何获得该值？是用其他类型还是文本？@IgnacioSolerGarcia怎么样？我想避免用类型转换句子，我想可能在.Net框架中已经有了一些东西。大开关类型是一条路要走。我可以制作一个完全不可读的

表达式

树生成器，如果您需要，它将吐出动态代码来检查您的值。。。保证是派对的生命周期。为什么要将值12345.6789放入（例如）一个字节中？那个坏值的值是多少？或者你想把那个大值分成多个字节，然后在最后重建它？@YuvalItzchakov我想是。。。但也许作为动词，当它是自愿的时候，夹紧比夹紧要好。这根线安全吗？如果不是，就让它成为线程安全的：）@Fredou唯一的非线程安全时刻可能是初始化（静态构造函数），但clr保证它是线程安全的。因此，它是线程安全的，因为你可以有一些东西。Mmmh某人可以拥有一个

struct MyNum{public static MyNum MinValue=0；public static MyNum MaxValue=0；}

，然后在另一个线程中连续写入

MinValue

。。。这不是线程安全的：-）

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            decimal value = 123456.789M;

            Console.WriteLine(ConvertOrMinMax<Byte>(value));
            Console.WriteLine(ConvertOrMinMax<Int16>(value));
            Console.WriteLine(ConvertOrMinMax<Int32>(value));
            Console.WriteLine(ConvertOrMinMax<Int64>(value));
            Console.WriteLine(ConvertOrMinMax<Decimal>(value));
            Console.WriteLine(ConvertOrMinMax<Double>(value));
            Console.WriteLine(ConvertOrMinMax<float>(value));

            Console.Read();
        }

        static T ConvertOrMinMax<T>(decimal v)
        {
            var myType = typeof(T);

            if(myType == typeof(double) || myType == typeof(float))
                return (T)Convert.ChangeType(v, myType);

            decimal min = (decimal)Convert.ChangeType(myType.GetField("MinValue").GetValue(null), typeof(decimal));

            if (v < min)
                return (T)Convert.ChangeType(min, myType);

            decimal max = (decimal)Convert.ChangeType(myType.GetField("MaxValue").GetValue(null), typeof(decimal)); ;

            if (v > max)
                return (T)Convert.ChangeType(max, myType);

            return (T)Convert.ChangeType(v, myType);
        }
    }
}