Passaggio di dati tra l'app C ++ (MFC) e C #

StackOverflow https://stackoverflow.com/questions/184777

  •  06-07-2019
  •  | 
  •  

Domanda

Abbiamo un'app GUI MFC monolitica che si avvicina alla fine della sua vita in C ++. Stiamo programmando di creare nuove funzionalità in C # e trasferire i dati tra ciascuna app.

La domanda è: qual è l'approccio migliore per passare i dati tra C ++ e C #?

Note:
Entrambe le estremità avranno un front-end della GUI e probabilmente dovranno solo passare dati semplici come gli ID e possibilmente avere un meccanismo in cui indica all'altra app quale processo / funzionalità utilizzare.
Ad esempio, una delle applicazioni sarà un sistema CRM in C # che, quando si fa doppio clic su una riga di una griglia, indica l'ID cliente e un messaggio per aprire quel cliente nel Modulo cliente dell'app MFC.

Ho fatto un po 'di ricerche, le opzioni sembrano essere Windows Messaging, Memory Mapping, Named Pipes o qualcosa come Windows Socket. In questa fase ci stiamo sporgendo verso Named Pipes, ma apprezzeremmo davvero altri consigli o suggerimenti o esperienze di altre persone.

È stato utile?

Soluzione

Personalmente penserei di usare qualcosa di simile alle pipe denominate in quanto sono facili da usare dal lato C ++ e da System.IO.Pipes anche dal lato .NET.

Sarebbe anche il percorso della resistenza probabilmente minore se si prevede di sostituire nel tempo gli altri bit non .NET dell'app.

Altri suggerimenti

Fai la tua scelta:

  • file
  • named pipe < - La mia raccomandazione
  • memoria condivisa
  • prese
  • COM
  • Messaggi di Windows

Perché il nome di pipe?

  • Ti offre un modo FIFO di lavorare gratuitamente (come socket, ma non come memoria condivisa)
  • Può comunicare facilmente in entrambi i modi
  • Ben supportato su tutte le piattaforme
  • Facile da usare
  • Passaggio e consegna dei dati affidabili
  • Può essere bloccante e non bloccante
  • Può leggere i dati senza rimuoverli (diversamente dai socket)
  • Può essere espanso per includere facilmente una terza app.

In .Net basta usare System.IO.Pipes.

In C ++ usa CreateNamedPipe e CreateFile.

Puoi anche usare P / Invoke dal lato gestito: questo sarebbe utile se l'app MFC ha un'API C. Inoltre puoi usare COM da entrambi i lati.

Le opzioni che elenchi sono certamente valide, ma potresti anche prendere in considerazione COM.

Userei i socket (TCP) - sia MFC che .NET hanno il supporto diretto per loro.

Hai davvero bisogno di due processi?

Il C ++ non gestito e il codice C # gestito sono perfettamente in grado di funzionare nello stesso processo e con un piccolo livello di C ++ / CLI gestito, è possibile sostituire la complessità della comunicazione tra processi con semplici chiamate di funzione.

Le mie scelte sarebbero i messaggi standard della finestra (ad es. WM_FOO) o DCOM:

  • I messaggi funzionerebbero fintanto che la comunicazione è molto semplice e il sovraccarico nell'impostazione è minimo. Se riesci a ridurre la comunicazione a uno o due numeri interi per messaggio, questo sarebbe probabilmente un buon punto di partenza. Se entrambe le app sono già applicazioni con finestre, entrambe hanno già dei loop di messaggi, quindi sei già quasi arrivato.

  • DCOM richiede molto più overhead del programmatore, ma è bello in quanto è possibile definire un'interfaccia più ricca ed evitare di dover convertire messaggi complessi da / in forma binaria. Se segui questa strada, CoRegisterClassObject è il punto di partenza per la pubblicazione di un oggetto tramite DCOM. Non ho mai provato a farlo da un'app C #, ma in linea di principio dovrebbe essere del tutto possibile

Supponendo che tu abbia l'origine dell'app legacy, vedi se non riesci a compilare tutte le " workhorse " codice come DLL, quindi invocare le singole funzioni / finestre da lì. Una volta che hai funzionato, puoi semplicemente scrivere i wrapper C ++ gestiti attorno alle funzioni di cui hai bisogno e richiamare quelli dal tuo codice C #. L'intero processo può richiedere meno di un giorno, se sei fortunato.

Direi C ++ / CLI se non devi preoccuparti del framework .NET esistente su tutti i sistemi su cui verrà eseguita l'app e COM altrimenti. Dipenderebbe davvero da ciò che ti è più comodo e familiare, però. Mi piace la struttura esistente di "funzione chiamata" di C ++ / CLI e COM (piuttosto che costruirla con altri protocolli), ma sono solo io.

Attualmente sto utilizzando COM per aggiungere alcune funzionalità del componente .NET, principalmente a causa della necessità di funzionare ancora con fallback se .NET non è presente, ma è specifico per le mie esigenze in cui è preferibile la massima distribuzione.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top