What IPC method should I use between Firefox extension and C# code running on the same machine?

Question

I have a question about how to structure communication between a (new) Firefox extension and existing C# code.

The firefox extension will use configuration data and will produce other data, so needs to get the config data from somewhere and save it's output somewhere. The data is produced/consumed by existing C# code, so I need to decide how the extension should interact with the C# code.

Some pertinent factors:

• It's only running on windows, in a relatively controlled corporate environment.
• I have a windows service running on the machine, built in C#.
• Storing the data in a local datastore (like sqlite) would be useful for other reasons.
• The volume of data is low, e.g. 10kb of uncompressed xml every few minutes, and isn't very 'chatty'.
• The data exchange can be asynchronous for the most part if not completely.
• As with all projects, I have limited resources so want an option that's relatively easy.
• It doesn't have to be ultra-high performance, but shouldn't add significant overhead.
• I'm planning on building the extension in javascript (although could be convinced otherwise if really necessary)

Some options I'm considering:

1. use an XPCOM to .NET/COM bridge
2. use a sqlite db: the extension would read from and save to it. The c# code would run in the service, populating the db and then processing data created by the service.
3. use TCP sockets to communicate between the extension and the service. Let the service manage a local data store.

My problem with (1) is I think this will be tricky and not so easy. But I could be completely wrong? The main problem I see with (2) is the locking of sqlite: only a single process can write data at a time so there'd be some blocking. However, it would be nice generally to have a local datastore so this is an attractive option if the performance impact isn't too great. I don't know whether (3) would be particularly easy or hard ... or what approach to take on the protocol: something custom or http.

Any comments on these ideas or other suggestions?

UPDATE: I was planning on building the extension in javascript rather than c++

Answer 1

I would personally used named pipes to do the communication instead of sockets. They're very low overhead, and very reliable on Windows.

This is very easy to use from C++ and from C#.

Answer 2

Well if you're going to use JavaScript I don't see another way to use named pipes or other system dependant communication other than writing proxy component in C++ which will allow you to access OS API directly. On the other hand if you plan to use TCP/UDP for IPC it will be much easier for you, because Firefox provides socket services that you can use easily from JavaScript component.

If blocking is your concern you can use asynchrony socket communication or threading services to avoid locking of Firefox's GUI, but be aware that many objects are accessible only from Firefox's main thread.

Answer 3

The option I selected was #2: use a sqlite db. Main advantages being:

• possible to implement in javascript
• using a sqlite db useful for other reasons
• asynchronous communication improves performance: C# code is able to cache all information the firefox extension requires rather than having to prepare it on-demand. FF extension is able to save all data back to the sqlite db rather than needing it handled immediately by C# code.
• separate layer provides a nice testing-point, e.g. it's possible to run only the FF code and verify the expected results in sqlite, instead of needing a testing harness that operates across FF and C#.

Clearly some of these are scenario-dependant, so I would definitely not say this is the best general-purpose option for communication between FF extn and C# service.