How initialize Direct2D renderer into GDI context from managed code for older version of .NET Framework

Question

Given a legacy desktop application in Windows Form, managed code (a mix of C# and VB projects) running on .NET Framework 3.5 (which can't be migrated to newer .NET for reasons beyond the scope of this question), how GRADUALLY transition the code from GDI+ to Direct2D? Or possibly to Direct3D?

Another constraint is that the resulting application work on Windows 7, but we will migrate to Windows 8 or Windows 10 if that is the only way to get this to work.

(The impetus is bugs in GDI+ handling of texture when used with Graphics.FillPath and a small texture scaling factor; but we eventually want to move to Direct2D or Direct3D anyway.)

What we want to do would be straightforward, if we were targetting .NET Framework 4.0+ and Windows 8+, as documented here:
Direct2D and GDI Interoperability Overview

Unfortunately, attempting to adapt those instructions to our older target specification has run into a series of roadblocks.

First step is to use some managed wrapper to access Direct2D.
(not sure whether Direct2D 1.0 or 1.1 is targetted by wrappers/code examples/tutorials at Microsoft and elsewhere.)

Options I know about:
A. Microsoft DirectX 9.0 for Managed Code (MDX) (last update 2006):
I've seen discouraging comments about this long-unsupported package, and suggestions to use SlimDX or SharpDX instead [or to migrate to newer Microsoft technologies that are supported, but not compatible with our specified older platform]. Doesn't seem like a good long-term direction. So I have not tried this yet.
B. Win2D - does not support Windows 7, nor .NET Framework 3.5.
C. SharpDX (open source, actively maintained):
Tried to use this. Unfortunately, Direct2D was not added until v.3.0.0, which requires .NET Framework 4.0+. So this is not an option, until we are ready for a more major overhaul of our app.

D. SlimDX (open source, last update 2012): Succeeded in installing and rendering to a stand-alone Direct2D window.
Stuck on adapting this to render to a "GDI context", as described in the "Interoperability Overview" linked above.

C++ code from "interoperability" link:

// Create a DC render target.
D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(
    D2D1_RENDER_TARGET_TYPE_DEFAULT,
    D2D1::PixelFormat(
        DXGI_FORMAT_B8G8R8A8_UNORM,
        D2D1_ALPHA_MODE_IGNORE),
    0,
    0,
    D2D1_RENDER_TARGET_USAGE_NONE,
    D2D1_FEATURE_LEVEL_DEFAULT
    );

hr = m_pD2DFactory->CreateDCRenderTarget(&props, &m_pDCRT);

Attempting to write VB code:

Dim factory As New Direct2D.Factory

' --- THIS WORKS using SlimDX, SlimDX.Direct2D ---
'   (But it is not what I need; taken from SlimDX sample code)
' Stand-alone D2D window (NOT to GDI)
' "IntPtr handle" is "The window handle to associate with the device.".
Dim windowProperties As New WindowRenderTargetProperties(handle, New Size(600, 600))
Dim target As New WindowRenderTarget(factory, windowProperties)

' --- Hand-Translation of C++ code from "interoperability" link ---
Dim targetProperties As New RenderTargetProperties
targetProperties.Type = RenderTargetType.Default
targetProperties.PixelFormat = New PixelFormat(Format.B8G8R8A8_UNorm, AlphaMode.Ignore)
' *** How invoke "ID2D1Factory::CreateDCRenderTarget"? ***
'  (There aren't many methods on SlimDX.Direct2D.Factory "factory" above,
'   so if it is possible at all, SlimDX must do this some other way.)
' TODO

---

HOW TO MOVE FORWARD

First question: is the D2D/GDI interoperability described in the link above available for the target platform specified (.NET 3.5, Windows 7)?

If not, then what I am attempting is not possible. Though if Windows 7 is the problem, then a solution for ".NET 3.5 on Windows 10" would be worth knowing.

Second question Assuming the interoperabiity is possible, then I am facing a limitation of SlimDX? Or I've overlooked something? I'd prefer not to add a C++ project to this solution, but if a custom C++ dll could be pre-compiled, and then used [in addition to the SlimDX dll], that would be a (barely) tolerable solution.

Instead of C++ code, manually write managed wrappers to access what is needed [but I can't find in SlimDX] to initialize D2D/GDI interoperability? How convert the C++ code from that link above?

UPDATE

Found the needed call in SlimDX. See my answer for details.

Answer 1

Just discovered DeviceContextRenderTarget class in SlimDX:

' Equivalent to "ID2D1Factory::CreateDCRenderTarget".
    Dim target2 As New DeviceContextRenderTarget(factory, targetProperties)

---

To complete the initialization, need to bind that DC.

C++ from interoperability link:

HRESULT DemoApp::OnRender(const PAINTSTRUCT &ps)
{

    HRESULT hr;
    RECT rc;

    // Get the dimensions of the client drawing area.
    GetClientRect(m_hwnd, &rc);

    // Create the DC render target.
    hr = CreateDeviceResources();

    if (SUCCEEDED(hr))
    {
        // Bind the DC to the DC render target.
        hr = m_pDCRT->BindDC(ps.hdc, &rc);


        // Draw with Direct2D.

        m_pDCRT->BeginDraw();

        m_pDCRT->SetTransform(D2D1::Matrix3x2F::Identity());

        m_pDCRT->Clear(D2D1::ColorF(D2D1::ColorF::White));

        m_pDCRT->DrawEllipse(
            D2D1::Ellipse(
                D2D1::Point2F(150.0f, 150.0f),
                100.0f,
                100.0f),
            m_pBlackBrush,
            3.0
            );

        hr = m_pDCRT->EndDraw();

        // Draw some GDI content.
        if (SUCCEEDED(hr))
        {
         ...
        }
    }

    if (hr == D2DERR_RECREATE_TARGET)
    {
        hr = S_OK;
        DiscardDeviceResources();
    }

    return hr;
}

VB Translation:

' "canvas" is the Windows control (tested with Panel) that I wish to draw D2D in.
Private Sub canvas_Paint(sender As Object, e As System.Windows.Forms.PaintEventArgs) Handles canvas.Paint
    ' Render GDI content that is below D2D content
    '... existing GDI calls ...

    ' Render Direct2D content.
    cDirect2DRenderer.TestRendering(e.Graphics, canvas.ClientSize)

    ' Render GDI content that is above D2D content.
    '... existing GDI calls ...
End Sub

Which uses VB class:

Imports System.Drawing

Imports SlimDX
Imports SlimDX.Direct2D
Imports SlimDX.DXGI

Public Class cDirect2DRenderer

#Region "=== Shared ==="
    Public Shared Sub TestRendering(gr As Graphics, canvasSize As System.Drawing.Size)
        Dim renderer As New cDirect2DRenderer

        ' CAUTION: After this, must call EndDraw or ReleaseHDC when done drawing.
        Dim success As Boolean = renderer.BeginDraw(gr, canvasSize)

        ' Render some Direct2D content.
        success = renderer.Test_Render(success)

        success = renderer.EndDraw(gr, success)
        If Not success Then
            'TODO: Log error.
        End If

        renderer.Dispose() : renderer = Nothing
    End Sub
#End Region


#Region "=== Fields, Constructor, Dispose ==="
    Private Ready As Boolean
    Private _factory As New Direct2D.Factory
    Private Target As DeviceContextRenderTarget
    Private Bounds As Rectangle
    Private Hdc As IntPtr

    Public Sub New()

    End Sub

    Public Sub Dispose()
        If Target IsNot Nothing Then
            Target.Dispose() : Target = Nothing
        End If

        Ready = False
    End Sub
#End Region


#Region "=== BeginDraw, Test_Render, EndDraw ==="
    Public Property Factory As Direct2D.Factory
        Get
            Return _factory
        End Get
        Set(value As Direct2D.Factory)
            If Exists(_factory) Then
                _factory.Dispose()
                '_factory = Nothing
            End If

            _factory = value
        End Set
    End Property

    ' True if Ready to draw.
    ' CAUTION: Even if returns False, Caller must call EndDraw, so that ReleaseHDC is called.
    Public Function BeginDraw(g As Graphics, canvasSize As System.Drawing.Size) As Boolean
        ' CAUTION: After this, must call EndDraw or ReleaseHDC when done drawing.
        EnsureReady(g, canvasSize)
        If Not Ready Then
            ' Initialization failed.
            Return False
        End If

        Try
            Dim success As Boolean = True
            Target.BeginDraw()

            Return success

        Catch ex As Exception
            Return False
        End Try
    End Function

    Public Function Test_Render(success As Boolean) As Boolean
        Try
            Target.Transform = Matrix3x2.Identity
            Target.Clear(New Color4(Color.BlueViolet))
            Dim brush As Direct2D.Brush = New SolidColorBrush(Target, New Color4(Color.Black))
            Dim ellipse As Direct2D.Ellipse = New Ellipse() With {
                    .Center = New PointF(100, 100),
                    .RadiusX = 80, .RadiusY = 80}
            Target.DrawEllipse(brush, ellipse)
            Target.FillEllipse(brush, ellipse)

        Catch ex As Exception
            success = False
        End Try

        Return success
    End Function

    ' True if rendering succeeds.
    ' "success" is accumulation, included in the return value.
    Public Function EndDraw(g As Graphics, success As Boolean) As Boolean
        ' Wrap EndDraw in Try, because "ReleaseHDC" must always be called.
        Try
            ' EndDraw is always called (even if "success" is already False).
            success = success And Target.EndDraw().IsSuccess
        Catch ex As Exception
            success = False
        End Try

        ReleaseHDC(g)
        ' TBD: This could be moved out elsewhere.
        EnsureFactoryReleased()

        If Not success Then
            Trouble()
        End If
        Return success
    End Function

    ' CAUTION: Caller must call EndDraw or ReleaseHDC when done drawing.
    Private Sub EnsureReady(g As Graphics, canvasSize As System.Drawing.Size)
        Dim newBounds As New Rectangle(0, 0, canvasSize.Width, canvasSize.Height)

        If Not Ready OrElse Not SameBounds(newBounds) Then
            If Ready Then
                Dispose()
            End If

            Me.Bounds = newBounds

            Me.Ready = InitializeDevice(g)
        End If
    End Sub

    ' AFTER set Me.Bounds.
    ' CAUTION: Caller must call g.ReleaseHdc(Me.Hdc) when done drawing.
    Private Function InitializeDevice(g As Graphics) As Boolean
        Try
            '' Stand-alone D2D window (NOT to GDI)
            ' ...width As Integer, height As Integer
            'Dim windowProperties As New WindowRenderTargetProperties(handle, New Size(600, 600))
            'Dim target1 As New WindowRenderTarget(factory, windowProperties)

            Dim targetProperties As New RenderTargetProperties
            targetProperties.Type = RenderTargetType.Default
            targetProperties.PixelFormat = New PixelFormat(Format.B8G8R8A8_UNorm, AlphaMode.Ignore)
            ' Equivalent to "ID2D1Factory::CreateDCRenderTarget".
            Me.Target = New DeviceContextRenderTarget(Me.Factory, targetProperties)

            ' CAUTION: Caller must call g.ReleaseHdc(Me.Hdc) when done drawing.
            Me.Hdc = g.GetHdc()
            Try
                'TestStr = Me.Hdc.ToString()
                Dim result As SlimDX.Result = Target.BindDeviceContext(Me.Hdc, Me.Bounds)

                If Not result.IsSuccess Then
                    ReleaseHDC(g)
                End If
                Return result.IsSuccess

            Catch ex As Exception
                ReleaseHDC(g)
                Return False
            End Try

        Catch ex As Exception
            Return False
        End Try
    End Function

    Private Sub ReleaseHDC(g As Graphics)
        Try
            g.ReleaseHdc(Me.Hdc)
        Finally
            Me.Hdc = Nothing
        End Try
    End Sub

    Private Sub EnsureFactoryReleased()
        Me.Factory = Nothing
    End Sub

    Private Function SameBounds(newBounds As Rectangle) As Boolean
        ' TBD: Does Equals do what we need?
        Return (newBounds.Equals(Me.Bounds))
    End Function
#End Region

End Class