What is the best way to integrate with fast programs from C # code?

Question

from my research, there seem to be basically 3 options.

1: Using COM
2: Using the web service and web connector
3: Using a third-party component (and seems to be pretty much)

Each of these options presents a problem for me:
1: I was told that I can not use COM
2: This solution seems very hokey to me, since I need to integrate from a Windows service
3: Some of these solutions are quite expensive.

It seems like I have to go the third way, and in my mind there are two front runners:

1: QODBC (http://www.qodbc.com/usa.html)
2: AccessBooks (http://www.synergration.com/AccessBooksUpdater/default.aspx)

My questions, dear reader, are as follows:

1: What solution (com, web service, third party) do you use?
2: Why did you choose it for other parameters?
3: Is there any other option that I missed?

Answer 1

I decided to go with another product not mentioned above under the name "QuickBooks ADO.NET Data Provider", apparently it was made by the same people who make the QuickBooks integrator product

The reasons why I chose it ...

1) It has a remote access component
You install a remote server, and you can access your QuickBooks data from anywhere on your network.

2) The remote access component can work as a service
Nuff said

3) Provides SQL style interface for QuickBooks data
4) Some kind of automatic caching to speed up data access

Answer 2

I used the Quickbooks SDK because I was developing an import tool for a friend and we did not have the luxury of buying a third-party library.

I started developing it as a web service, but I had to step back after I realized that we need to not only deploy the redistributable Quickbooks SDK on the server, but we also need to install Quickbooks on our own. And more often than never, Quickbooks displayed a dialog that is bad on the server.

While this dialog has been opened, the Quickbooks SDK will refuse any connection to it.

In the end, I did it as a pure C # Winform program. From there, its quite a breakthrough.

The program was based on a fast boot session class that handled the session and message

public static class Quickbooks { public static QuickbookSession CreateSession() { return new QuickbookSession(); } } public class QuickbookSession : IDisposable { /// <summary> /// Initializes a new instance of the <see cref="QuickbookSession"/> class. /// </summary> internal QuickbookSession() { this.SessionManager = new QBSessionManager(); this.SessionManager.OpenConnection2( ConfigurationManager.AppSettings["QuickbooksApplicationId"], ConfigurationManager.AppSettings["QuickbooksApplicationName"], Utils.GetEnumValue<ENConnectionType>(ConfigurationManager.AppSettings["QuickbooksConnectionType"])); var file = Quickbook.QuickbookDatabaseFilePath; if (string.IsNullOrEmpty(file)) { file = ConfigurationManager.AppSettings["QuickbooksDatabaseLocalPath"]; } this.SessionManager.BeginSession(file, Utils.GetEnumValue<ENOpenMode>(ConfigurationManager.AppSettings["QuickbooksSessionOpenMode"])); } /// <summary> /// Gets the Quickbook session manager that is owning this message. /// </summary> public QBSessionManager SessionManager { get; private set; } public QuickbookMessage CreateMessage() { return new QuickbookMessage(this.SessionManager); } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (disposing) { // get rid of managed resources } this.SessionManager.EndSession(); this.SessionManager.CloseConnection(); System.Runtime.InteropServices.Marshal.ReleaseComObject(this.SessionManager); } } 

After that, it was easy to create a session, create a message, and add another request.

 using(var session = Quickbooks.CreateSession()) { // Check if the job already exist using (var message = session.CreateMessage()) { var jobQuery = message.AppendCustomerQueryRq(); jobQuery.ORCustomerListQuery.CustomerListFilter.ORNameFilter.NameFilter.Name.SetValue("something"); jobQuery.ORCustomerListQuery.CustomerListFilter.ORNameFilter.NameFilter.MatchCriterion.SetValue(ENMatchCriterion.mcContains); var result = message.Send(); // do stuff here with the result } } 

This code is far from being bulletproof from many of the traps of Quickbooks. Quickbooks SDKs are also pretty slow. For example, getting a list of suppliers takes about 2 minutes for about 1,000 suppliers.

Answer 3

I used nSoftware's QuickBooks integrator in the project I was in. It's easier than using the QuickBooks SDK, and the support is great. This product has been around for 8 years.

http://www.nsoftware.com/ibiz/quickbooks/

Answer 4

Although I'm sure there are some cases in which this will not work, my first area of ​​attack will be the Quickbooks SDK found at the Intuit developer Center .

Answer 5

If you are looking for source code or something ready for .NET, there are Kentico, Ektron, and nopCommerce connectors for QuickBooks. Please check out the store .