Is it possible to import or reference a small subset of OpenTK.Compatibility.dll?

extern alias open_tk_glu;
 
using System;
using System.Collections.Generic;
using System.Xml;
using System.Runtime.InteropServices;
using System.Diagnostics;
 
using OpenTK;
 
namespace Util
{
    //
    //This class use the OpenGL GLU tessellation
    //functions to triangulate a simple polygon.
    //
    //This code is based largely on Michael Foetsch
    //triangulation tutorial that can be found, as of
    //February 2, 2008, at http://www.geocities.com/foetsch/articles.htm.
    //
    //It interfaces with OpenGL through OpenTK.
    //
 
    static class Tesselate 
    {
        // Some of this code is lifted from the OpenTK tesselation sample:
        // Define the signatures for the callback functions, and declare the callbacks.
        delegate void BeginCallbackDelegate(int mode);
        delegate void EndCallbackDelegate();
        delegate void VertexCallbackDelegate(IntPtr v);
        delegate void EdgeFlagCallbackDelegate(int flag);
        delegate void ErrorCallbackDelegate(int code);
        unsafe delegate void CombineCallbackDelegate(
            [MarshalAs(UnmanagedType.LPArray, SizeConst = 3)]double[] coordinates,
            [MarshalAs(UnmanagedType.LPArray, SizeConst = 4)]double*[] vertexData,
            [MarshalAs(UnmanagedType.LPArray, SizeConst = 4)]float[] weight,
            double** dataOut);
 
 
        //After a successful call to Triangulate, this public list holds the indices
        //for the given input.
        static public List<int> Indices;
        static public bool InvalidPolygon;
 
        // Triangulate       
        unsafe static public bool Triangulate(Vector2[] Input, int[] VertsPerContour)
        {
            InvalidPolygon = false;
            Indices = new List<int>();
 
            IntPtr tess = IntPtr.Zero;
            // create tesselation object
            tess = open_tk_glu::OpenTK.Graphics.Glu.NewTess();
 
            // register tesselation callbacks
            open_tk_glu::OpenTK.Graphics.Glu.TessCallback(tess, open_tk_glu::OpenTK.Graphics.TessCallback.TessBegin, new BeginCallbackDelegate(BeginCallback));
            open_tk_glu::OpenTK.Graphics.Glu.TessCallback(tess, open_tk_glu::OpenTK.Graphics.TessCallback.TessEdgeFlag, new EdgeFlagCallbackDelegate(EdgeCallback));
            open_tk_glu::OpenTK.Graphics.Glu.TessCallback(tess, open_tk_glu::OpenTK.Graphics.TessCallback.TessVertex, new VertexCallbackDelegate (VertexCallback));
            open_tk_glu::OpenTK.Graphics.Glu.TessCallback(tess, open_tk_glu::OpenTK.Graphics.TessCallback.TessEnd, new EndCallbackDelegate(EndCallback));
            open_tk_glu::OpenTK.Graphics.Glu.TessCallback(tess, open_tk_glu::OpenTK.Graphics.TessCallback.TessCombine, new CombineCallbackDelegate(CombineCallback));
            open_tk_glu::OpenTK.Graphics.Glu.TessCallback(tess, open_tk_glu::OpenTK.Graphics.TessCallback.TessError, new ErrorCallbackDelegate(ErrorCallback));
 
            //copy input into a linear array of floats
            double[] Vertices = new double[3 * Input.Length];
            for(int v=0;v<Input.Length;v++)
            {
                Vertices[v*3+0] = Input[v].X;
                Vertices[v*3+1] = Input[v].Y;
                //Vertices[v*3+2] = Input[v].Z;
                Vertices[v*3+2] = 0.0;
            }
 
            // begin polygon
            open_tk_glu::OpenTK.Graphics.Glu.TessBeginPolygon(tess, IntPtr.Zero);
 
            // go through the contours
            int CurrentContour = 0;
            int VertsThisContour = 0;
 
            for(int v=0;v<Input.Length;v++)
            {
                if(v == 0)
                    open_tk_glu::OpenTK.Graphics.Glu.TessBeginContour(tess);
 
                // pass the corresponding vertex to the tesselator object
                double[] VertsToPass = new double[3];
                VertsToPass[0] = Vertices[v * 3 + 0];
                VertsToPass[1] = Vertices[v * 3 + 1];
                VertsToPass[2] = Vertices[v * 3 + 2];
                open_tk_glu::OpenTK.Graphics.Glu.TessVertex(tess,VertsToPass,v);
 
                if(InvalidPolygon)
                    break;
 
                VertsThisContour++;
 
                if(VertsThisContour >= VertsPerContour[CurrentContour])
                {
                    VertsThisContour = 0;
                    open_tk_glu::OpenTK.Graphics.Glu.TessEndContour(tess);
 
                    CurrentContour++;
 
                    if(CurrentContour < (long)VertsPerContour.Length)
                    {
                        open_tk_glu::OpenTK.Graphics.Glu.TessBeginContour(tess);
                    }
                }
            }
 
            if(InvalidPolygon)
            {
                // destroy the tesselation object
                open_tk_glu::OpenTK.Graphics.Glu.DeleteTess(tess);
                tess = IntPtr.Zero;
 
                return false; //error in polygon definition
            }
            else
            {
                //-------------------------------------------------------------
                // AccessViolationException: Attempted to read or write protected memory.  Occurs here...
                //-------------------------------------------------------------              
                open_tk_glu::OpenTK.Graphics.Glu.TessEndPolygon(tess);
 
                // destroy the tessellation object
                open_tk_glu::OpenTK.Graphics.Glu.DeleteTess(tess);
                tess = IntPtr.Zero;
 
                //The Indices object is now valid.
                return true;
            }
        }
 
 
        //GLU callback functions
        static void BeginCallback(int type)
        {
 
        }
 
        static void EdgeCallback(int flag)
        {
 
        }
 
        static void VertexCallback(IntPtr vertexIndex)
        {
            unsafe
            {
                Indices.Add(*((int*)vertexIndex));
            }
        }
 
        static void EndCallback()
        {           
        }
 
        unsafe static void CombineCallback(double[] coords, double*[] vertexData, float[] weight, double** outData)
        {
            //This means the polygon is self-intersecting.
            //See the OpenTK tesselation example for a working version of the
            //combine callback.
            InvalidPolygon = true;
        }
        static void ErrorCallback(int errno)
        {
            //some error ocurred, mark this triangulation as invalid
            InvalidPolygon = true;
        }
 
    }
}