Es un juego online llamado GunZ del Servidor IJJI, http://gunz.ijji.com/index.nhn
en el cual en el Lobby dentro del juego hay espacio para escribir lo que deceo hacer esque al poner alguna palabra que yo indique haga tal accion para esto ocupo descubrir primero el address de la direccion donde escribo dicha palabra.

Pues hasta ahorita seria mejor lo que es el CheatEngine que esta aqui

Bueno hace tiempo cree tambien un grafico aunque lo mio fue de barras usando la DLL Zed Graph la cual te permite crear de varios tipos de graficos entre ellas la que tu mencionas bueno aqui te dejo un link que muestra ejemplos y demas:
http://www.recursosvisualbasic.com.ar/htm/vb-net/22-ocx-zed-graph-para-chart.htm

Espero y te sirva.

sip, eso lo entiendo, pero lo que yo no se es como obtener el address, ya que el del programa que corro siempre cambia y ya e intentado usando los offsets y ni asi porque como a la tercera ejecucion vuelve a cambiar lo cual me impide y por eso es lo que deceo ver como buscar un texto en la memoria del programa, ya que manejar readprocessmemory si me funciona, pero tarda demasiado y lo que es CheatEngine & ArtMoney no les toma mas de 1 min cosa que no entiendo como lo logran leer la memoria sin que les tome tanto tiempo como a mi :s

Revise el codigo del ejemplo que colocastes y no es lo que busco ya que ahi ya asignan el address sin tener que buscarlo, aun asi gracias seguire leyendo mas sobre el tema aver que encuentro :p

Bueno estuve buscando y leyendo y al final me encontre con este codigo en C al parece, aunque aun no se muy bien utilizarlo, pero lee la memoria mas rapido lo cual si logro entenderlo podria talves usarlo a mi gusto, espero y pueda ayudarme.

#include <windows.h>
#include <stdio.h>
 
#define IS_IN_SEARCH(mb,offset) (mb->searchmask[(offset)/8] & (1<<((offset)%8)))
#define REMOVE_FROM_SEARCH(mb,offset) mb->searchmask[(offset)/8] &= ~(1<<((offset)%8));
 
typedef struct _MEMBLOCK
{
    HANDLE hProc;
    unsigned char *addr;
    int size;
    unsigned char *buffer;
 
    unsigned char *searchmask;
    int matches;
    int data_size;
 
    struct _MEMBLOCK *next;
} MEMBLOCK;
 
typedef enum 
{
    COND_UNCONDITIONAL,
    COND_EQUALS,
 
    COND_INCREASED,
    COND_DECREASED,
} SEARCH_CONDITION;
 
 
MEMBLOCK* create_memblock (HANDLE hProc, MEMORY_BASIC_INFORMATION *meminfo, int data_size)
{
    MEMBLOCK *mb = malloc (sizeof(MEMBLOCK));
 
    if (mb)
    {
        mb->hProc = hProc;
        mb->addr = meminfo->BaseAddress;
        mb->size = meminfo->RegionSize;
        mb->buffer = malloc (meminfo->RegionSize);
        mb->searchmask = malloc (meminfo->RegionSize/8);
        memset (mb->searchmask, 0xff, meminfo->RegionSize/8);
        mb->matches = meminfo->RegionSize;
        mb->data_size = data_size;
        mb->next = NULL;
    }
 
    return mb;
}
 
void free_memblock (MEMBLOCK *mb)
{
    if (mb)
    {
        if (mb->buffer)
        {
            free (mb->buffer);
        }
 
        if (mb->searchmask)
        {
            free (mb->searchmask);
        }
 
        free (mb);
    }
}
 
 
void update_memblock (MEMBLOCK *mb, SEARCH_CONDITION condition, unsigned int val)
{
    static unsigned char tempbuf[128*1024];
    unsigned int bytes_left;
    unsigned int total_read;
    unsigned int bytes_to_read;
    unsigned int bytes_read;
 
    if (mb->matches > 0)
    {
        bytes_left = mb->size;
        total_read = 0;
        mb->matches = 0;
 
        while (bytes_left)
        {
            bytes_to_read = (bytes_left > sizeof(tempbuf)) ? sizeof(tempbuf) : bytes_left;
            ReadProcessMemory (mb->hProc, mb->addr + total_read, tempbuf, bytes_to_read, (DWORD*)&bytes_read);
            if (bytes_read != bytes_to_read) break;
 
            if (condition == COND_UNCONDITIONAL)
            {
                memset (mb->searchmask + (total_read/8), 0xff, bytes_read/8);
                mb->matches += bytes_read;
            }
            else
            {
                unsigned int offset;
 
                for (offset = 0; offset < bytes_read; offset += mb->data_size)
                {
                    if (IS_IN_SEARCH(mb,(total_read+offset)))
                    {
                        BOOL is_match = FALSE;
                        unsigned int temp_val;
                        unsigned int prev_val = 0;
 
                        switch (mb->data_size)
                        {
                            case 1:
                                temp_val = tempbuf[offset];
                                prev_val = *((unsigned char*)&mb->buffer[total_read+offset]);
                                break;
                            case 2:
                                temp_val = *((unsigned short*)&tempbuf[offset]);
                                prev_val = *((unsigned short*)&mb->buffer[total_read+offset]);
                                break;
                            case 4:
                            default:
                                temp_val = *((unsigned int*)&tempbuf[offset]);
                                prev_val = *((unsigned int*)&mb->buffer[total_read+offset]);
                                break;
                        }
 
                        switch (condition)
                        {
                            case COND_EQUALS:
                                is_match = (temp_val == val);
                                break;
                            case COND_INCREASED:
                                is_match = (temp_val > prev_val);
                                break;
                            case COND_DECREASED:
                                is_match = (temp_val < prev_val);
                                break;
                            default:
                                break;
                        }
 
                        if (is_match)
                        {
                            mb->matches++;
                        }
                        else
                        {
                            REMOVE_FROM_SEARCH(mb,(total_read+offset));
                        }
                    }
                }
            }
 
            memcpy (mb->buffer + total_read, tempbuf, bytes_read);
 
            bytes_left -= bytes_read;
            total_read += bytes_read;
        }
 
        mb->size = total_read;
    }
}
 
 
 
MEMBLOCK* create_scan (unsigned int pid, int data_size)
{
    MEMBLOCK *mb_list = NULL;
    MEMORY_BASIC_INFORMATION meminfo;
    unsigned char *addr = 0;
 
    HANDLE hProc = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pid);
 
    if (hProc)
    {
        while (1)
        {
            if (VirtualQueryEx (hProc, addr, &meminfo, sizeof(meminfo)) == 0)
            {
                break;
            }
#define WRITABLE (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)
            if ((meminfo.State & MEM_COMMIT) && (meminfo.Protect & WRITABLE))
            {
                MEMBLOCK *mb = create_memblock (hProc, &meminfo, data_size);
                if (mb)
                {
                    mb->next = mb_list;
                    mb_list = mb;
                }
            }
            addr = (unsigned char*)meminfo.BaseAddress + meminfo.RegionSize;
        }
    }
 
    return mb_list;
}
 
 
void free_scan (MEMBLOCK *mb_list)
{
    CloseHandle (mb_list->hProc);
 
    while (mb_list)
    {
        MEMBLOCK *mb = mb_list;
        mb_list = mb_list->next;
        free_memblock (mb);
    }
}
 
void update_scan (MEMBLOCK *mb_list, SEARCH_CONDITION condition, unsigned int val)
{
    MEMBLOCK *mb = mb_list;
    while (mb)
    {
        update_memblock (mb, condition, val);
        mb = mb->next;
    }
}
 
 
void dump_scan_info (MEMBLOCK *mb_list)
{
    MEMBLOCK *mb = mb_list;
 
    while (mb)
    {
        int i;
        printf ("0x%08x %d\r\n", mb->addr, mb->size);
 
        for (i = 0; i < mb->size; i++)
        {
            printf ("%02x", mb->buffer[i]);
        }
        printf ("\r\n");
 
        mb = mb->next;
    }
}
 
 
void poke (HANDLE hProc, int data_size, unsigned int addr, unsigned int val)
{
    if (WriteProcessMemory (hProc, (void*)addr, &val, data_size, NULL) == 0)
    {
        printf ("poke failed\r\n");
    }
}
 
unsigned int peek (HANDLE hProc, int data_size, unsigned int addr)
{
    unsigned int val = 0;
 
    if (ReadProcessMemory (hProc, (void*)addr, &val, data_size, NULL) == 0)
    {
        printf ("peek failed\r\n");
    }
 
    return val;
}
 
 
void print_matches (MEMBLOCK *mb_list)
{
    unsigned int offset;
    MEMBLOCK *mb = mb_list;
 
    while (mb)
    {
        for (offset = 0; offset < mb->size; offset += mb->data_size)
        {
            if (IS_IN_SEARCH(mb,offset))
            {
                unsigned int val = peek (mb->hProc, mb->data_size, (unsigned int)mb->addr + offset);
                printf ("0x%08x: 0x%08x (%d) \r\n", mb->addr + offset, val, val);
            }
        }
 
        mb = mb->next;
    }
}
 
 
int get_match_count (MEMBLOCK *mb_list)
{
    MEMBLOCK *mb = mb_list;
    int count = 0;
 
    while (mb)
    {
        count += mb->matches;
        mb = mb->next;
    }
 
    return count;
}
 
 
 
unsigned int str2int (char *s)
{
    int base = 10;
 
    if (s[0] == '0' && s[1] == 'x')
    {
        base = 16;
        s += 2;
    }
 
    return strtoul (s, NULL, base);
}
 
 
MEMBLOCK* ui_new_scan(void)
{
    MEMBLOCK *scan = NULL;
    DWORD pid;
    int data_size;
    unsigned int start_val;
    SEARCH_CONDITION start_cond;
    char s[20];
 
    while(1)
    {
        printf ("\r\nEnter the pid: ");
        fgets (s,sizeof(s),stdin);
        pid = str2int (s);
        printf ("\r\nEnter the data size: ");
        fgets (s,sizeof(s),stdin);
        data_size = str2int (s);
        printf ("\r\nEnter the start value, or 'u' for unknown: ");
        fgets (s,sizeof(s),stdin);
        if (s[0] == 'u')
        {
            start_cond = COND_UNCONDITIONAL;
            start_val = 0;
        }
        else
        {
            start_cond = COND_EQUALS;
            start_val = str2int (s);
        }
 
        scan = create_scan (pid, data_size);
        if (scan) break;
        printf ("\r\nInvalid scan");
    }
 
    update_scan (scan, start_cond, start_val);
    printf ("\r\n%d matches found\r\n", get_match_count(scan));
 
    return scan;
}
 
 
void ui_poke (HANDLE hProc, int data_size)
{
    unsigned int addr;
    unsigned int val;
    char s[20];
 
    printf ("Enter the address: ");
    fgets (s,sizeof(s),stdin);
    addr = str2int (s);
 
    printf ("\r\nEnter the value: ");
    fgets (s,sizeof(s),stdin);
    val = str2int (s);
    printf ("\r\n");
 
    poke (hProc, data_size, addr, val);
}
 
 
void ui_run_scan(void)
{
    unsigned int val;
    char s[20];
    MEMBLOCK *scan;
 
    scan = ui_new_scan();
 
    while (1)
    {
        printf ("\r\nEnter the next value or");
        printf ("\r\n[i] increased");
        printf ("\r\n[d] decreased");
        printf ("\r\n[m] print matches");
        printf ("\r\n[p] poke address");
        printf ("\r\n[n] new scan");
        printf ("\r\n[q] quit\r\n");
 
        fgets(s,sizeof(s),stdin);
        printf ("\r\n");
 
        switch (s[0])
        {
            case 'i':
                update_scan (scan, COND_INCREASED, 0);
                printf ("%d matches found\r\n", get_match_count(scan));
                break;
            case 'd':
                update_scan (scan, COND_DECREASED, 0);
                printf ("%d matches found\r\n", get_match_count(scan));
                break;
            case 'm':
                print_matches (scan);
                break;
            case 'p':
                ui_poke (scan->hProc, scan->data_size);
                break;
            case 'n':
                free_scan (scan);
                scan = ui_new_scan();
                break;
            case 'q':
                free_scan (scan);
                return;
            default:
                val = str2int (s);
                update_scan (scan, COND_EQUALS, val);
                printf ("%d matches found\r\n", get_match_count(scan));
                break;
        }
    }
}
 
 
 
 
int main (int argc, char *argv[])
{
    ui_run_scan();
    return 0;
}
 
 
 

Bueno buscando en google hay formas de convertir un DataTable a Html, por lo que nos facilitara el trabajo ^^
Al final el codigo podria quedarnos asi

private void button1_Click(object sender, EventArgs e)
        {
            SqlConnection cn = new SqlConnection("conexión");
            SqlDataAdapter cm = new SqlDataAdapter("select invtid,desc,qtyord,precilista,preciomargen from soshipline where shipperid='12345'", cn);
            DataTable dt = New DataTable();
            cm.Fill(dt);
            String datos = ConvertToHtmlFile(dt):
 
            MailMessage msg = new MailMessage();
 
 
            msg.To.Add(new MailAddress("econtreras@hofmann.cl"));
 
            msg.From = new MailAddress("servidor@hofmann.cl");
 
            msg.Subject = "Venta Bajo Margen";
 
            msg.Body = datos;
 
            msg.IsBodyHtml = true;
 
            SmtpClient clienteSmtp = new SmtpClient("smtp.xxxxxxxxxx.cl");
 
 
            // Este es el código nuevo
 
            clienteSmtp.Credentials =
            new NetworkCredential("servidor@hofmann.cl", "xxxxxxxxxxxx");
 
 
 
            try
            {
 
                clienteSmtp.Send(msg);
 
            }
 
            catch (Exception ex)
            {
 
                MessageBox.Show(ex.Message);
 
 
 
            }
        }
 
public static string ConvertToHtmlFile(DataTable targetTable)
{
 string myHtmlFile = "";
 
 
 if (targetTable == null)
 {
  throw new System.ArgumentNullException("targetTable");
 }
 else
 {
  //Continue.
 }
 
 
 //Get a worker object.
 StringBuilder myBuilder = new StringBuilder();
 
 
 //Open tags and write the top portion.
 myBuilder.Append("<html xmlns='http://www.w3.org/1999/xhtml'>");
 myBuilder.Append("<head>");
 myBuilder.Append("<title>");
 myBuilder.Append("Page-");
 myBuilder.Append(Guid.NewGuid().ToString());
 myBuilder.Append("</title>");
 myBuilder.Append("</head>");
 myBuilder.Append("<body>");
 myBuilder.Append("<table border='1px' cellpadding='5' cellspacing='0' ");
 myBuilder.Append("style='border: solid 1px Silver; font-size: x-small;'>");
 
 
 //Add the headings row.
 
 
 myBuilder.Append("<tr align='left' valign='top'>");
 
 
 foreach (DataColumn myColumn in targetTable.Columns)
 {
  myBuilder.Append("<td align='left' valign='top'>");
  myBuilder.Append(myColumn.ColumnName);
  myBuilder.Append("</td>");
 }
 
 
 myBuilder.Append("</tr>");
 
 
 //Add the data rows.
 foreach (DataRow myRow in targetTable.Rows)
 {
  myBuilder.Append("<tr align='left' valign='top'>");
 
 
  foreach (DataColumn myColumn in targetTable.Columns)
  {
   myBuilder.Append("<td align='left' valign='top'>");
   myBuilder.Append(myRow[myColumn.ColumnName].ToString());
   myBuilder.Append("</td>");
  }
 
 
  myBuilder.Append("</tr>");
 }
 
 
 //Close tags.
 myBuilder.Append("</table>");
 myBuilder.Append("</body>");
 myBuilder.Append("</html>");
 
 
 //Get the string for return.
 myHtmlFile = myBuilder.ToString();
 
 
 return myHtmlFile;
}

Bueno he llevado tiempo en esto y no logro avanzar lo que deceo es poder obtener el value de la memoria de algun proceso, he leido y hecho varios intentos pero no e logrado concretarlo, por lo que he pasado aca a ver si tienen alguna idea de como hacerlo asi como Cheat Engine, que permite buscar un texto en la memoria de los procesos, eso es lo que deceo hacer, lo mas lejos que llegue fue hacerlo con ReadProcessMemory, pero tarda demasiado por lo que si pudiesen ayudarme seria de gran ayuda, tambien si esto se puede hacer en algun otro lenguaje podria ayudarme asi nomas hago que suelte el address de localizacion en un txt.

Espero contar con la ayuda de alguno de ustedes ^^

Gracias,
Saludos.

P.D. Feliz dia de Reyes (Para los que lo festejan)

Si, la verdad yo prefiero usar este mismo yo a la final use este, y me facilito mas el trabajo

Bueno creo entender mas no estoy seguro podria ser asi,
como ya te dije NO-IP es un redireccionador o DNS asi mandara a tu IP y si tu IP actualiza este mismo tambien lo hace, ya por ejemplo en mi caso lo registre asi
crymore.sytes.net
lo cual eso redireeciona o me manda a mi IP, ahora solo falta agregarle el puerto y elcomando para que sea abierto y fin
Al final que daria asi para abrir
IP:PUERTO
crymore.sytes.net:801

Process.Start("http://crymore.sytes.net:801/")
 

Aqui un ejemplo

Si el archivo a copiar es una imagen llamemosla "imagen.jpg", al insertarla en recursos solo es imagen y bueno el codigo seria asi

Dim archivo as Byte() = My.Resource.imagen
Dim carpeta as String = Applicattion.Startpath + "\Recursos\"
File.WriteAllBytes(carpeta + "Imagen.jpg",archivo)