Using Vertex Arrays with OpenTK

hop of those help? Vertex Buffer Objects are essentially Vertex Arrays, where instead of pointing to a address in your program's process address space, OpenGL gives you a handle to OpenGL managed memory and the Vertex Array pointers are offsets into the memory given out by that handle.
It is actually very easy to add VBO support to programs that already make use of Vertex Arrays. It's as easy to conditionally use VBOs if they are available and fall back to client addess space Vertex Arrays if not.

To fix the issue you can do Using GLEW for extension wrangling:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <GL/glew.h>
#include <GL/glut.h>

typedef struct vector /*dynamic vector of void* pointers. This one is used only by the deflate compressor*/
{
  void* data;
  size_t size; /*in groups of bytes depending on type*/
  size_t allocsize; /*in bytes*/
  unsigned typesize; /*sizeof the type you store in data*/
} vector;

static unsigned vector_resize(vector* p, size_t size) /*returns 1 if success, 0 if failure ==> nothing done*/
{
  if(size * p->typesize > p->allocsize)
  {
    size_t newsize = size * p->typesize * 2;
    void* data = realloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = data;
      p->size = size;
    }
    else return 0;
  }
  else p->size = size;
  return 1;
}

static void vector_cleanup(void* p)
{
  ((vector*)p)->size = ((vector*)p)->allocsize = 0;
  free(((vector*)p)->data);
  ((vector*)p)->data = NULL;
}

static void vector_init(vector* p, unsigned typesize)
{
  p->data = NULL;
  p->size = p->allocsize = 0;
  p->typesize = typesize;
}

static void* vector_get(vector* p, size_t index)
{
  return &((char*)p->data)[index * p->typesize];
}


/* function to calculate each data point */
float func(float x)
{
    return (float)sin(x);
}

GLuint vbo = 0;
GLsizei vertcount = 0;
void update(float (* func)(float x), float x1, float x2, int N)
{
    float x, dx = 1.0f/N;
    vector pts;

    vector_init( &pts, sizeof( float ) );
    for(x = x1; x < x2; x += dx)
    {
        vector_resize( &pts, pts.size + 2 );
        *(float*)vector_get( &pts, pts.size-2 ) = x;
        *(float*)vector_get( &pts, pts.size-1 ) = func(x);
    }

    vertcount = (GLsizei)( pts.size / 2 );
    glBindBuffer( GL_ARRAY_BUFFER, vbo );
    glBufferData( GL_ARRAY_BUFFER, pts.size * pts.typesize, pts.data, GL_DYNAMIC_DRAW );
    glBindBuffer( GL_ARRAY_BUFFER, 0 );

    vector_cleanup( &pts );
}

/* plotting function - very slow */
void draw(float x1, float x2, float y1, float y2)
{
    glPushMatrix(); 

    glScalef( 1.0f / (x2 - x1), 1.0f / (y2 - y1), 1.0f );
    glTranslatef( -x1, -y1, 0.0f );
    glColor3f( 1.0f, 1.0f, 1.0f );

    glBindBuffer( GL_ARRAY_BUFFER, vbo );
    glEnableClientState( GL_VERTEX_ARRAY );
    glVertexPointer( 2, GL_FLOAT, 0, 0 );
    glDrawArrays( GL_LINE_STRIP, 0, vertcount );
    glDisableClientState( GL_VERTEX_ARRAY );
    glBindBuffer( GL_ARRAY_BUFFER, 0 );

    glPopMatrix();
};

/* Redrawing func */
float xmin = -10, xmax = 10, ymin = -5, ymax = 5;
void redraw(void)
{
    glClearColor(0, 0, 0, 0);
    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    // -x, +x, -y, +y, number points
    draw(xmin, xmax, ymin, ymax);

    glutSwapBuffers();
};

/* Idle proc. Redisplays, if called. */
int nPoints = 3000;
void idle(void)
{
    // shift 'xmin' & 'xmax' by one.
    xmin++; 
    xmax++;

    update(func, xmin, xmax, nPoints);

    glutPostRedisplay();
};

/* Key press processing */
void key(unsigned char c, int x, int y)
{
    if(c == 27) exit(0);
};

/* Window reashape */
void reshape(int w, int h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, 1, 0, 1, -1, 1);
    glMatrixMode(GL_MODELVIEW);
};

/* Main function */
int main(int argc, char **argv)
{
    GLenum err;

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
    glutCreateWindow("Graph plotter");
    glutReshapeWindow(1024, 800);

    // init GLEW and output some GL info
    err = glewInit();
    printf("GL_VERSION  : %s\n", glGetString(GL_VERSION)  );
    printf("GL_VENDOR   : %s\n", glGetString(GL_VENDOR)   );
    printf("GL_RENDERER : %s\n", glGetString(GL_RENDERER) );
    if( GLEW_OK != err )
    {
        printf("glewInit failed: %s", glewGetErrorString(err));
        return EXIT_FAILURE;
    }

    if( !glewIsSupported("GL_VERSION_1_5") )
    {
        printf("OpenGL version 1.5 or greater required.\n");
        return EXIT_FAILURE;
    }

    glGenBuffers( 1, &vbo );

    /* Register GLUT callbacks. */
    glutDisplayFunc(redraw);
    glutKeyboardFunc(key);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);

    /* Init the GL state */
    glLineWidth(2.0);

    /* Main loop */
    glutMainLoop();
    return 0;
}

fixed the issue. Will look into that further I have a basic understanding of Vertex Arrays, Vertex Buffer Objects and Shaders. However, I am not sure if I can reuse them or whether the association is bijective. , Yes you can :)
VBO - controls where your data is stored

wish helps you XNA is using Direct3d, whereas OpenTK is OpenGL. In the general case, you cannot draw using OpenGL into a Direct3d window.[1]
What you can do is switch from XNA to MonoGame. It is an open-source implementation of XNA and supports both Direct3d and OpenGL. If you use the OpenGL version, you will be able to draw into the same window using both XNA and OpenTK.

hope this fix your issue Apply the [StructLayout(LayoutKind.Explicit)] attribute to the struct and then apply [FieldOffset(n)] to each field to position it at your selected byte position, n.
This gives you fine-grained control of position, and since the sizes of primitive types in C# do not depend on the platform (64 vs 32 bit) that also tells you the size and complete layout.