Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » Comunicar procesos que estan en maquinas distintas

C/Visual C - Comunicar procesos que estan en maquinas distintas

Volver
Nuevo Tema
<<>>
 
Vista:

Comunicar procesos que estan en maquinas distintas

Publicado por LUIS (1 intervención) el 23/08/2001 14:52:09
Sé que de hace con socket, pero quieren hacerlo de forma que uno escriba en un fichero de texto y otro lea de él. ¿Como se puede hacer, para que se lea la informacion completa que uno ha escrito y no leamos sólo una parte de la información?, es decir, leer unidades completas tal cual las ha escrito el proceso ya que el proceso que lee estará chequeando continuamente para ver si han escrito en el fichero.
Agradezco cualquier orientación.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Comunicación entre procesos en máquinas distintas usando archivos de texto

Publicado por Alejandro (913 intervenciones) el 11/10/2024 20:11:46
Luis, para comunicar procesos que están en máquinas distintas mediante un archivo de texto, puedes seguir un enfoque donde un proceso escribe en el archivo y el otro lo lee. Sin embargo, hay que tener en cuenta que el acceso a archivos en red puede ser problemático debido a la latencia y la posibilidad de que los procesos no sincronicen correctamente.

Aquí te muestro un enfoque básico para lograr esto:

1. Escritura en el archivo



El proceso que escribe en el archivo debe asegurarse de que la escritura se realice de manera que el otro proceso pueda leer la información completa. Puedes usar un formato específico para delimitar los mensajes, como un carácter especial o una línea en blanco.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include <fstream>
#include <string>
#include <thread>
#include <chrono>
 
void writeToFile(const std::string& filename) {
    std::ofstream outFile(filename, std::ios::app); // Abre el archivo en modo append
    if (outFile.is_open()) {
        for (int i = 0; i < 5; ++i) {
            outFile << "Mensaje " << i << std::endl; // Escribe un mensaje
            outFile.flush(); // Asegura que se escriba inmediatamente
            std::this_thread::sleep_for(std::chrono::seconds(1)); // Espera un segundo
        }
        outFile.close();
    }
}

2. Lectura del archivo



El proceso que lee el archivo debe verificar continuamente si hay nuevos datos. Puedes usar un bucle que lea el archivo y procese las líneas completas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void readFromFile(const std::string& filename) {
    std::ifstream inFile;
    std::string line;
 
    while (true) {
        inFile.open(filename);
        if (inFile.is_open()) {
            while (std::getline(inFile, line)) {
                std::cout << "Leído: " << line << std::endl; // Procesa la línea
            }
            inFile.close();
        }
        std::this_thread::sleep_for(std::chrono::seconds(1)); // Espera un segundo antes de volver a leer
    }
}

3. Sincronización y delimitación



Para asegurarte de que el proceso lector no lea solo una parte de la información, puedes implementar un sistema de delimitación. Por ejemplo, puedes escribir un carácter especial al final de cada mensaje o usar un formato JSON o XML para estructurar los datos.

4. Ejemplo completo



Aquí tienes un ejemplo completo que combina ambas funciones:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
#include <fstream>
#include <string>
#include <thread>
#include <chrono>
 
void writeToFile(const std::string& filename) {
    std::ofstream outFile(filename, std::ios::app);
    if (outFile.is_open()) {
        for (int i = 0; i < 5; ++i) {
            outFile << "Mensaje " << i << std::endl;
            outFile.flush();
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        outFile.close();
    }
}
 
void readFromFile(const std::string& filename) {
    std::ifstream inFile;
    std::string line;
 
    while (true) {
        inFile.open(filename);
        if (inFile.is_open()) {
            while (std::getline(inFile, line)) {
                std::cout << "Leído: " << line << std::endl;
            }
            inFile.close();
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}
 
int main() {
    std::string filename = "comunicacion.txt";
 
    std::thread writer(writeToFile, filename);
    std::thread reader(readFromFile, filename);
 
    writer.join();
    reader.join();
 
    return 0;
}

Consideraciones finales



1. Rendimiento: Este enfoque puede no ser el más eficiente, especialmente si los procesos están en máquinas distintas y hay latencia en la red.
2. Bloqueo: Asegúrate de manejar adecuadamente el acceso concurrente al archivo para evitar problemas de bloqueo.
3. Alternativas: Si la comunicación en tiempo real es crítica, considera usar sockets o una base de datos para la comunicación entre procesos.

Con este enfoque, deberías poder comunicar procesos en máquinas distintas utilizando archivos de texto.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar