Эквивалент reinterpret_cast C++ в C#

обсуждение

Как указывают некоторые ответы, .Net строго обеспечивает безопасность типов в рамках вопроса. reinterpret_cast по своей сути является небезопасной операцией, поэтому возможные способы ее реализации — либо через рефлексию, либо через сериализацию, тогда как оба они связаны.

Как вы упомянули в обновлении, возможное использование может быть инфраструктурой RPC. Библиотеки RPC в любом случае обычно используют сериализацию/рефлексию, и есть несколько пригодных для использования:

• protobuf-remote
• msgpack-rpc-cli

так что, возможно, вы не захотите писать его сами.

Если ваш класс Base будет использовать общедоступные свойства, вы можете использовать AutoMapper:

class Base
{
    public int Counter { get; set; }
    // ...
}

...

AutoMapper.Mapper.CreateMap<Base, Foo>();
Foo foo = AutoMapper.Mapper.Map<Foo>(b);

Где Foo вообще не обязательно должно быть получено из Base. Он просто должен иметь свойство, которое вы хотите отобразить. Но опять же, вам может вообще не понадобиться два типа — решением может стать переосмысление архитектуры.

Как правило, нет необходимости использовать reinterpret_cast благодаря чистой архитектуре, которая хорошо вписывается в шаблоны, используемые в .Net Framework. Если вы все еще настаиваете на том, чтобы иметь что-то подобное, вот решение с использованием компактной библиотеки сериализации 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, безусловно, можно реализовать либо с помощью этого решения для сериализации, либо напрямую с помощью отражения, но в данный момент я бы не стал тратить время.

Это работает. И да, это так зло и так прекрасно, как вы только можете себе представить.

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, проверка границ позволит вам прочитать последний элемент (фактически это уязвимость переполнения буфера)

Возможно, вы сможете добиться аналогичного поведения с блоками unsafe и void* в C#:

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. Возможно, интерфейс может лучше соответствовать вашим потребностям?