Option Explicit
Private WithEvents CEL As CQGCEL
Private Sub Form_Load()
    ' Initialize CQGCEL instance.
    On Error Goto errHndl
    Set CEL = New CQGCEL
    CEL.APIConfiguration.CollectionsThrowException = False
    ' Disable application readiness checking
    CEL.APIConfiguration.ReadyStatusCheck = rscOff
    CEL.Startup
    Exit Sub
errHndl:
    MsgBox "Error occurred during CEL initialization. " & Err.Description
End Sub
Private Sub Form_Unload(Cancel As Integer)
    On Error Goto errHndl
    CEL.Shutdown
    Exit Sub
errHndl:
    MsgBox "Error occurred during CEL initialization. " & Err.Description
End Sub
' Event is fired when the CQGCEL object is successfully started up
Private Sub CEL_CELStarted()
    Debug.Print "CEL Version : " & CEL.Environment.CELVersion
End Sub
' Event is fired when error occures in CQGCEL execution
Private Sub cel_DataError(ByVal obj As Object, ByVal errorDescription As String)
    ' Print the error description
    Debug.Print "Data Error : " & errorDescription
End Sub
' Event is fired when some changes occurred in the connection
' with the CQG data server
Private Sub CEL_DataConnectionStatusChanged(ByVal newStatus As CQG.eConnectionStatus)
    Dim status As String
    Select Case newStatus
        Case csConnectionDelayed
            status = "Delayed"
        Case csConnectionDown
            status = "Down"
        Case csConnectionUp
            status = "Up"
    End Select
    Debug.Print "Data Connection Status changed to " & status
    If newStatus = csConnectionUp Then
        RequestDataSources
    End If
End Sub
' This function requests for available data sources
Private Sub RequestDataSources()
    Debug.Print "Requesting data sources"
    CEL.RequestDataSources
End Sub
' Event is fired when requested data sources collection is resolved
' or when an error has occurred during the request processing
Private Sub CEL_DataSourcesResolved(ByVal dataSources As CQG.ICQGDataSources, _
                                    ByVal cqgErr As CQG.ICQGError)
    Dim i As Long
    If Not cqgErr Is Nothing Then
        Debug.Print "Error occured during data sources request : " & cqgErr.Description
        Exit Sub
    End If
    Debug.Print "Data sources resolved"
    ' Print data for each data source
    Debug.Print "Data sources :"
    For i = 0 To dataSources.Count - 1
        Debug.Print vbTab & "Name : " & dataSources.Name(i)
        Debug.Print vbTab & "Abbreviation : " & dataSources.Abbreviation(i)
        Debug.Print vbTab & "Status : " & dataSources.status(i)
        Debug.Print vbTab & "Contains futures : " & _
                    IIf(dataSources.Type(i) And dstFutures = dstFutures, _
                    "Yes", "No")
    Next
    ' Request available symbols for first data source
    If dataSources.Count > 0 Then
        CEL.RequestDataSourceSymbols dataSources.Abbreviation(0)
    End If
End Sub
' Event is fired when requested symbols collection for specified data source is resolved
' or when an error has occurred during the request processing
Private Sub CEL_DataSourceSymbolsResolved(ByVal dataSourceName As String, _
                                          ByVal dataSourceSymbols As CQG.ICQGDataSourceSymbols, _
                                          ByVal cqgErr As CQG.ICQGError)
    Dim i As Long
    If Not cqgErr Is Nothing Then
        Debug.Print "Error occured during data source symbols request : " & cqgErr.Description
        Exit Sub
    End If
    Debug.Print "Data source " & dataSourceName & " symbols :"
    For i = 0 To dataSourceSymbols.Count - 1
        Debug.Print vbTab & "Abbreviation : " & dataSourceSymbols.Abbreviation(i)
        Debug.Print vbTab & "Description : " & dataSourceSymbols.Description(i)
        Debug.Print vbTab & "Type : " & dataSourceSymbols.Type(i)
    Next
End Sub

using System;
using System.Runtime.InteropServices;
using CQG;
 
namespace Samples
{
    class DataSources : IDisposable 
    {
        // CQGCEL instance declaration
        private CQGCEL cel = new CQGCELClass(); 
 
        // Used to determine is the object manualy disposed
        private bool disposed = false;  
 
        public DataSources() 
        { 
            // Initialize CQGCEL instance 
            try 
            {  
                // Configure CEL
                cel.APIConfiguration.ReadyStatusCheck = eReadyStatusCheck.rscOff; 
                cel.APIConfiguration.CollectionsThrowException = false; 
 
                // Register to CEL's events
                cel.CELStarted += new _ICQGCELEvents_CELStartedEventHandler(cel_CELStarted); 
                cel.DataError += new _ICQGCELEvents_DataErrorEventHandler(cel_DataError); 
                cel.DataConnectionStatusChanged += new _ICQGCELEvents_DataConnectionStatusChangedEventHandler(cel_DataConnectionStatusChanged);
                cel.DataSourcesResolved += new _ICQGCELEvents_DataSourcesResolvedEventHandler(cel_DataSourcesResolved);
                cel.DataSourceSymbolsResolved += new _ICQGCELEvents_DataSourceSymbolsResolvedEventHandler(cel_DataSourceSymbolsResolved);
 
                cel.Startup(); 
            }
            catch (COMException ex)  
            {  
                Console.WriteLine( "Error occurred during CEL initialization. {0}", ex.Message );  
            }  
        }
 
        ~DataSources() 
        { 
            Dispose(false); 
        } 
        
        #region CEL Event Handlers 
 
        // Event is fired when the CQGCEL object is successfully started up
        void cel_CELStarted() 
        { 
            Console.WriteLine("CEL Version : {0}", cel.Environment.CELVersion); 
        }
 
        // Event is fired when error occures in CQGCEL execution
        void cel_DataError(object obj, string errorDescription) 
        { 
            // Some error occurred
            Console.WriteLine("Data Error : " + errorDescription);
         }
 
        // Event is fired when some changes occurred in the connection 
        // with the CQG data server
        void cel_DataConnectionStatusChanged(eConnectionStatus newStatus)
        {
            string status;
            switch (newStatus)
            {
                case eConnectionStatus.csConnectionDelayed:
                    status = "Delayed";
                    break;
 
                case eConnectionStatus.csConnectionDown:
                    status = "Down";
                    break;
 
                case eConnectionStatus.csConnectionUp:
                    status = "Up";
                    break;
 
                default:
                    status = "Unknown";
                    break;
            }
            Console.WriteLine("Data Connection Status changed to " + status); 
 
            if (newStatus == eConnectionStatus.csConnectionUp)
            {
                RequestDataSources();
            }
        }
 
        // This function requests for available data sources
        void RequestDataSources()
        {
            Console.WriteLine("Requesting data sources");
            cel.RequestDataSources();
        }
 
        // Event is fired when requested data sources collection is resolved 
        // or when an error has occurred during the request processing
        void cel_DataSourcesResolved(CQGDataSources dataSources, CQGError err)
        {
            if (err != null)
            {
                Console.WriteLine("Error occured during data sources request : {0}", err.Description);
                return;
            }
 
            Console.WriteLine("Data sources resolved");
 
            // Print data for each data source
            Console.WriteLine("Data sources :");
            for (int i = 0; i < dataSources.Count; i++)
            {
                Console.WriteLine("\t Name : {0}", dataSources[i]);
                Console.WriteLine("\t Abbreviation : {0}", dataSources.get_Abbreviation(i));
                Console.WriteLine("\t Status : {0}", dataSources.get_Status(i));
                if ((dataSources.get_Type(i) & eDataSourceType.dstFutures) == eDataSourceType.dstFutures)
                {
                    Console.WriteLine("\t Contains futures : Yes");
                }
                else
                {
                    Console.WriteLine("\t Contains futures : No");
                }
            }
 
            // Request available symbols for first data source
            if (dataSources.Count > 0)
            {
                cel.RequestDataSourceSymbols(dataSources.get_Abbreviation(0));
            }
        }
 
        // Event is fired when requested symbols collection for specified data source is resolved 
        // or when an error has occurred during the request processing
        void cel_DataSourceSymbolsResolved(string dataSourceName, CQGDataSourceSymbols dataSourceSymbols, CQGError err)
        {
            if (err != null)
            {
                Console.WriteLine("Error occured during data source symbols request : {0}", err.Description);
                return;
            }
 
            Console.WriteLine("Data source {0} symbols :", dataSourceName);
            for (int i = 0; i < dataSourceSymbols.Count; i++)
            {
                Console.WriteLine("\t Abbreviation : {0}", dataSourceSymbols.get_Abbreviation(i));
                Console.WriteLine("\t Description : {0}", dataSourceSymbols.get_Description(i));
                Console.WriteLine("\t Type : {0}", dataSourceSymbols.get_Type(i));
            }
        }
 
        #endregion
 
        #region IDisposable Members
 
        public void Dispose() 
        { 
            Dispose(true); 
 
            GC.SuppressFinalize(this); 
        } 
 
        
        #endregion 
 
        #region Private Methods 
 
        private void Dispose(bool disposing) 
        { 
            // Check to see if Dispose has already been called
            if (!this.disposed) 
            { 
                // If disposing equals true, dispose all managed  
                // and unmanaged resources
                if (disposing) 
                { 
                    // Dispose managed resources
                }
 
                // If disposing is false,  
                // only the following code is executed
                try
                {
                    cel.Shutdown();
                }
                catch
                { }
            } 
            disposed = true; 
        } 
 
        
        #endregion 
    }
}