[英]Mapping a ulong to a long in C#?
我正在尝试将ulong映射为long(反之亦然),并将uint映射为int(反之亦然),如下所示-为了将值保存在具有签名类型的MS-SQL数据库中仅整数和biginteger。
我这样做是因为我必须检查(在数据库中)数字(uint,ulong)是否在uint / ulong范围(IPs-v4和v6)中的某个范围内;实际上ulong实际上是一个uint128,由两个乌龙)。
有没有比我在这里的代码更有效的方法来完成此操作:
public static ulong SignedLongToUnsignedLong(long signedLongValue)
{
ulong backConverted = 0;
// map ulong to long [ 9223372036854775808 = abs(long.MinValue) ]
if (signedLongValue < 0)
{
// Cannot take abs from MinValue
backConverted = (ulong)System.Math.Abs(signedLongValue - 1);
backConverted = 9223372036854775808 - backConverted - 1;
}
else
{
backConverted = (ulong)signedLongValue;
backConverted += 9223372036854775808;
}
return backConverted;
}
public static long UnsignedLongToSignedLong(ulong unsignedLongValue)
{
// map ulong to long [ 9223372036854775808 = abs(long.MinValue) ]
return (long) (unsignedLongValue - 9223372036854775808);
}
public static int UnsignedIntToSignedInt(uint unsignedIntValue)
{
// map uint to int [ 2147483648 = abs(long.MinValue) ]
return (int)(unsignedIntValue - 2147483648);
}
public static uint SignedIntToUnsignedInt(int signedIntValue)
{
uint backConverted = 0;
// map ulong to long [ 2147483648 = abs(long.MinValue) ]
if (signedIntValue < 0)
{
// Cannot take abs from MinValue
backConverted = (uint)System.Math.Abs(signedIntValue - 1);
backConverted = 2147483648 - backConverted - 1;
}
else
{
backConverted = (uint)signedIntValue;
backConverted += 2147483648;
}
return backConverted;
}
public static void TestLong()
{
long min_long = -9223372036854775808;
long max_long = 9223372036854775807;
ulong min_ulong = ulong.MinValue; // 0
ulong max_ulong = ulong.MaxValue; // 18446744073709551615 = (2^64)-1
long dbValueMin = UnsignedLongToSignedLong(min_ulong);
long dbValueMax = UnsignedLongToSignedLong(max_ulong);
ulong valueFromDbMin = SignedLongToUnsignedLong(dbValueMin);
ulong valueFromDbMax = SignedLongToUnsignedLong(dbValueMax);
System.Console.WriteLine(dbValueMin);
System.Console.WriteLine(dbValueMax);
System.Console.WriteLine(valueFromDbMin);
System.Console.WriteLine(valueFromDbMax);
}
public static void TestInt()
{
int min_int = -2147483648; // int.MinValue
int max_int = 2147483647; // int.MaxValue
uint min_uint= uint.MinValue; // 0
uint max_uint = uint.MaxValue; // 4294967295 = (2^32)-1
int dbValueMin = UnsignedIntToSignedInt(min_uint);
int dbValueMax = UnsignedIntToSignedInt(max_uint);
uint valueFromDbMin = SignedIntToUnsignedInt(dbValueMin);
uint valueFromDbMax = SignedIntToUnsignedInt(dbValueMax);
System.Console.WriteLine(dbValueMin);
System.Console.WriteLine(dbValueMax);
System.Console.WriteLine(valueFromDbMin);
System.Console.WriteLine(valueFromDbMax);
}
要从ulong
映射到long
,请long.MinValue
并添加long.MinValue
。 要从long
映射回ulong
,请减去long.MinValue
并进行long.MinValue
。 无论哪种情况,都应使用未经检查的上下文,以便忽略溢出条件。
public static long MapUlongToLong(ulong ulongValue)
{
return unchecked((long)ulongValue + long.MinValue);
}
public static ulong MapLongToUlong(long longValue)
{
return unchecked((ulong)(longValue - long.MinValue));
}
uint
和int
的逻辑完全相似。
死灵法师。
基于Tanner Swett的答案的通用答案:
private static class Number<T>
{
private static object GetConstValue(System.Type t, string propertyName)
{
System.Reflection.FieldInfo pi = t.GetField(propertyName, System.Reflection.BindingFlags.Static
| System.Reflection.BindingFlags.Public
| System.Reflection.BindingFlags.NonPublic
);
return pi.GetValue(null);
}
private static T GetMinValue<T>()
{
return (T)GetConstValue(typeof(T), "MinValue");
}
private static T GetMaxValue<T>()
{
return (T)GetConstValue(typeof(T), "MaxValue");
}
private static System.Func<T, T, T> CompileAdd<T>()
{
// Declare the parameters
System.Linq.Expressions.ParameterExpression paramA =
System.Linq.Expressions.Expression.Parameter(typeof(T), "a");
System.Linq.Expressions.ParameterExpression paramB =
System.Linq.Expressions.Expression.Parameter(typeof(T), "b");
// Add the parameters
System.Linq.Expressions.BinaryExpression body =
System.Linq.Expressions.Expression.Add(paramA, paramB);
// Compile it
System.Func<T, T, T> add =
System.Linq.Expressions.Expression.Lambda<System.Func<T, T, T>>
(body, paramA, paramB).Compile();
return add;
}
private static System.Func<T, T, T> CompileSubtract<T>()
{
// Declare the parameters
System.Linq.Expressions.ParameterExpression paramA =
System.Linq.Expressions.Expression.Parameter(typeof(T), "a");
System.Linq.Expressions.ParameterExpression paramB =
System.Linq.Expressions.Expression.Parameter(typeof(T), "b");
// Subtract the parameters
System.Linq.Expressions.BinaryExpression body =
System.Linq.Expressions.Expression.Subtract(paramA, paramB);
// Compile it
System.Func<T, T, T> subtract =
System.Linq.Expressions.Expression.Lambda<System.Func<T, T, T>>
(body, paramA, paramB).Compile();
return subtract;
}
public static T MinValue = GetMinValue<T>();
public static T MaxValue = GetMaxValue<T>();
public static System.Func<T, T, T> Add = CompileAdd<T>();
public static System.Func<T, T, T> Subtract = CompileSubtract<T>();
}
public static TSigned MapUnsignedToSigned<TUnsigned, TSigned>(TUnsigned ulongValue)
{
TSigned signed = default(TSigned);
unchecked
{
signed = Number<TSigned>.Add((TSigned)(dynamic)ulongValue, Number<TSigned>.MinValue);
}
return signed;
}
public static TUnsigned MapSignedToUnsigned<TSigned, TUnsigned>(TSigned longValue)
{
TUnsigned unsigned = default(TUnsigned);
unchecked
{
unsigned = (TUnsigned)(dynamic) Number<TSigned>
.Subtract(longValue, Number<TSigned>.MinValue);
}
return unsigned;
}
当量:
// return MapUnsignedToSigned<ulong, long>(ulongValue);
private static long MapULongToLong(ulong ulongValue)
{
return unchecked((long)ulongValue + long.MinValue);
}
// return MapSignedToUnsigned<long, ulong>(longValue);
private static ulong MapLongToUlong(long longValue)
{
return unchecked((ulong)(longValue - long.MinValue));
}
尽管坦纳·斯威特是正确的。 一个更好,更肮脏的解决方案是告诉.net将对ulong
访问映射到与long
相同的内存地址。 这将为您提供瞬时转换速度。
void Main()
{
var foo = new Foo { Long = -1 };
Console.WriteLine(foo.ULong);
}
// Define other methods and classes here
[StructLayout(LayoutKind.Explicit)]
public class Foo
{
[FieldOffset(0)]
private ulong _ulong;
[FieldOffset(0)]
private long _long;
public long Long
{
get { return _long; }
set { _long = value; }
}
public ulong ULong
{
get { return _ulong; }
set { _ulong = value; }
}
}
通过将实体框架POCO设置为使用显示的属性,可以控制字段映射到的内存地址。
因此,永远不会发生转换。
此代码比Tanner Swett的代码快100%。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.