相当于 C++ 在 C# 中的reinterpret_cast
本文关键字:reinterpret cast 中的 C++ 相当于 | 更新日期: 2023-09-27 18:36:11
我想知道 C# 中C++的reinterpret_cast
相当于什么!?
这是我的示例:
class Base
{
protected int counter = 0;
}
class Foo : Base
{
public int Counter
{
get { return counter; }
}
}
Base b = new Base();
Foo f = b as Foo; // f will be null
我不反对为什么f
会为空,因为它应该是。但如果是C++我本可以写Foo f = reinterpret_cast<Foo>(b);
并得到我想要的。我可以做些什么来在 C# 中实现相同的目标?
附言。我假设Base
和Foo
在数据方面是一致的。
[更新]
下面是一个简单的方案,其中reinterpret_cast
可能会有所帮助:
考虑编写一个 XXX-RPC 库,在该库中,您无法控制传入的参数或要调用的服务的签名。您的库应该使用给定的参数调用所请求的服务。如果 C# 支持reinterpret_cast
我可以简单地将给定的参数reinterpret_cast
到预期的参数中并调用服务。
这有效。是的,它和你能想象的一样邪恶和令人敬畏。
static unsafe TDest ReinterpretCast<TSource, TDest>(TSource source)
{
var sourceRef = __makeref(source);
var dest = default(TDest);
var destRef = __makeref(dest);
*(IntPtr*)&destRef = *(IntPtr*)&sourceRef;
return __refvalue(destRef, TDest);
}
需要注意的一件事是,如果您要将T[]
投到并U[]
:
- 如果
T
大于U
,边界检查将阻止您访问超过原始长度的U
元素T[]
- 如果
T
小于U
,边界检查将允许您读取最后一个元素(实际上这是一个缓冲区溢出漏洞)
讨论
正如一些答案所指出的那样,.Net 在问题范围内严格执行类型安全。reinterpret_cast
本质上是不安全的操作,因此实现一个操作的可能方法是通过反射或序列化,而两者是相关的。
正如您在更新中提到的,可能的用途可能是 RPC 框架。RPC 库通常无论如何都使用序列化/反射,并且有几个可用的库:
- protobuf-remote
- msgpack-rpc-cli
所以,你可能不想自己写一个,也许。
如果您的类Base
将使用公共属性,则可以使用自动映射器:
class Base
{
public int Counter { get; set; }
// ...
}
。
AutoMapper.Mapper.CreateMap<Base, Foo>();
Foo foo = AutoMapper.Mapper.Map<Foo>(b);
根本不需要从Base
派生Foo
。它只需要具有您有兴趣映射到的属性。但同样,您可能根本不需要两种类型 - 重新思考架构可能是解决方案。
通常,不需要使用reinterpret_cast
,通过一个干净的架构,很好地适应.Net框架中使用的模式。如果你仍然坚持拥有这样的东西,这里有一个使用紧凑的序列化库protobuf-net的解决方案。
序列化解决方案
您的课程:
using System;
using System.IO;
using ProtoBuf;
using ProtoBuf.Meta;
[ProtoContract]
[ProtoInclude(3, typeof(Foo))]
class Base
{
[ProtoMember(1)]
protected int counter = 0;
public Base(int c) { counter = c; }
public Base() { }
}
[ProtoContract]
class Foo : Base
{
public int Counter { get { return counter; } }
}
以及一个可运行的序列化-反序列化示例:
class Program
{
static void Main(string[] args)
{
Base b = new Base(33);
using (MemoryStream stream = new MemoryStream())
{
Serializer.Serialize<Base>(stream, b);
Console.WriteLine("Length: {0}", stream.Length);
stream.Seek(0, SeekOrigin.Begin);
Foo f=new Foo();
RuntimeTypeModel.Default.Deserialize(stream, f, typeof(Foo));
Console.WriteLine("Foo: {0}", f.Counter);
}
}
}
输出
Length: 2
Foo: 33
如果不想在协定中声明派生类型,请参阅此示例...
如您所见,序列化非常紧凑。
如果要使用更多字段,可以尝试字段的隐式序列化:
[ProtoContract(ImplicitFields = ImplicitFields.AllFields)]
通用reinterpret_cast
肯定可以通过此序列化解决方案或直接通过反射实现,但目前我不会投入时间。
C# 中使用unsafe
块和void*
可以实现类似的行为:
unsafe static TResult ReinterpretCast<TOriginal, TResult>(this TOriginal original)
where TOriginal : struct
where TResult : struct
{
return *(TResult*)(void*)&original;
}
用法:
Bar b = new Bar();
Foo f = b.ReinterpretCast<Foo>();
f = ReinterpretCast<Foo>(b); // this works as well
未经测试。
结构约束使你的问题无效,我想,但它们是必要的,因为类是由GC管理的,所以你不允许有指向它们的指针。
C# 在类型系统中没有允许您执行此操作的漏洞。 它知道事物是什么类型,并且不允许你转换为不同的类型。 其原因相当明显。 将字段添加到 Foo 时会发生什么?
如果你想要一种 Foo,你需要创建一种 Foo 类型。 更好的方法是创建一个 Foo 类型的构造函数,该构造函数将 Base 作为参数。
的"实现"
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
public unsafe static TResult ReinterpretCast<TOriginal, TResult>(/*this*/ TOriginal orig)
//refember ReferenceTypes are references to the CLRHeader
//where TOriginal : struct
//where TResult : struct
{
return Read<TResult>(AddressOf(orig));
}
确保在调用它时知道自己的操作,尤其是对于引用类型。
如果 Foo 和 Bar 是结构体,你可以这样做
[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Explicit)]
public class MyFooBarHelper
{
[System.Runtime.InteropServices.FieldOffset(0)] public Foo theFoo;
[System.Runtime.InteropServices.FieldOffset(0)] public Bar theBar;
}
但我不确定这是否适用于对象。
由于 b 只是 Base 的一个实例,因此您永远无法将其转换为 Foo 的非空实例。 也许界面可能更适合您的需求?