Improve VFP data retrieval with WCF

Total votes: 0
Views: 3,594
Comments: 0
Category: Windows Communication Foundation
Print: Print Article

Please login to rate or to leave a comment.

Published: 04 Apr 2008
By: Josip Zohil
Download Sample Code

This article explains how to set up a WCF client to download the data from the server in asynchronous (non blocking) mode, much faster than with VFP functions or oledb data adapters.

Introduction

In part one we talked about the problem and the WCF service as its solution. The WCF service accepts the request from the client, retrieves the data from the database and sends it to the client in various formats: string, DataSet, DataTable and strongly typed collections. We present the WCF client in this part of the article.

The WCF client

Create a new project named ComWfcVfpClient (See [4]). Rename the created class to ComWfcVfpClient.cs (Listing 6).

Listing 6: The WCF Client class

using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Configuration;
using System.Threading;
using System.IO;
using System.Runtime.InteropServices;
using System.Data;
using System.Xml;
namespace ComWfcVfpClient
{
    public class WcfVfpClient
    {
        public delegate void GridEventHandler(object source,EventArgs e);
        public event GridEventHandler ReceivedData;
        private ComEventArgs eventArgs;
        private string endPointUri = 
           System.Configuration.ConfigurationManager.AppSettings["uri"];
        private ComWfcVfpClient.WcfVfpWs.OrderListCollection olc = null;
        public void OnReceivedData(object source, EventArgs e)
        {
            if (ReceivedData != null)
            {
                ReceivedData(source, e);
            }
        }
        public void StoreResultCom( object source, string methodName, 
           string paramFrom, string paramTo)
        {
             eventArgs = new ComEventArgs();
            eventArgs.ReceivedState = source;
            string Output = null;
           //// Proxy = null; 
           //if you run a new instace of the proxy (open a new channel) in case of 
           //parallel call
           //System.Windows.Forms.MessageBox.Show("start the proxy store result com");
            if (!this.ProxyNotStarted()) return; 
           string retError = null;
            try
            {
                 olc =(ComWfcVfpClient.WcfVfpWs.OrderListCollection) 
                   Proxy.StoreCollection(out retError,methodName, paramFrom, paramTo);
                 if (retError != string.Empty)
                 {
                     eventArgs.ErrorMessage = "Error received StoreResultCom:  " 
                                                    + retError;
                }
                 else
                 {
                     eventArgs.ReceivedType = "C";
                     //remember it is subscribed to the delegate notification
                     eventArgs.ReceivedCollection = olc;                 
              //    System.Windows.Forms.MessageBox.Show("Cllection string length:" + 
              //    olc.ToString().Length.ToString());
                 }
              this.ReceivedData(this, eventArgs);
              //Log.WriteEntry("Return dt from storeResultcom:" + methodName + "  " + 
              //paramFrom + paramTo );
            }
            catch (Exception ex)
            {
                this.ReturnError( ex.Message );
            }
           //  ((IClientChannel)Proxy).Close();
           this.Dispose();
            return ;
        }
        public void StoreResultComAsyn(object source, string methodName, 
          string paramFrom, string paramTo)
        {
            ThreadStart starter = delegate { this.StoreResultCom(source, methodName,
               paramFrom, paramTo); };
            new Thread(starter).Start();
            //anonymus method
        }
        public String MyOperation1(out string retValue, string myValue)
        {
            string Output = null;
            ComEventArgs eventArgs = new ComEventArgs();
            if (!this.ProxyNotStarted())
            {
                retValue = eventArgs.ErrorMessage;
                this.ReturnError(retValue);
                return retValue;
            }
         try
            {
                Output = this.Proxy.MyOperation1(out retValue, "hello");
                Output = "Rv: " + retValue+  
                OperationContext.Current.IncomingMessageHeaders.Count.ToString() +               
             OperationContext.Current.IncomingMessageHeaders.MessageId + " " + Output;
            }
            catch (Exception ex)
            {
                this.Dispose();
                this.ErrorMessage = "MyOperaton1Com:" + ex.Message;
                retValue = this.ErrorMessage;
                this.ReturnError(retValue);
                return this.ErrorMessage;
            }
           Output =this.Proxy .MyOperation1(out retValue, "hello");
         //  ((IClientChannel)Proxy).Close();
            this.Dispose();
             return Output;
        }
        public void StoreHitCom(object source, string methodName, 
           string paramFrom, string paramTo)
        {
            string Output = null;
            string retError = null;
            eventArgs = new ComEventArgs();
            eventArgs.ReceivedState = source;
            eventArgs.ReceivedType = "S";
            if (!this.ProxyNotStarted()) return; 
            try
            {
                Output = Encoding.UTF8.GetString(Proxy.StoreHit(out retError 
                                           ,methodName, paramFrom, paramTo, ""));
                if (retError != string.Empty)
                {
                    this.ReturnError(retError);
                }
                else
                {
                   eventArgs.ReceivedString = Output; 
                }
            }
            catch (Exception ex)
            {
              retError = "StoreHitCom:" + ex.Message;
              this.ReturnError(retError);
            }
            this.ReceivedData(this, eventArgs); 
            this.Dispose();
        }
        public void StoreDataSet(object source, string methodName, 
              string paramFrom, string paramTo)
        {
            string Output = null;
            string retError = null;
            eventArgs = new ComEventArgs();
            eventArgs.ReceivedState = source;
            if (!this.ProxyNotStarted()) return; 
            try
            {
             //System.Windows.Forms.MessageBox.Show("vfp start");
                byte[] xout = Proxy.StoreDataSet(out retError, methodName, 
                     paramFrom, paramTo);
                DataSet ds = new DataSet();
           //System.Windows.Forms.MessageBox.Show("Dataset byte length:"
           // +xout.Length .ToString());
                if (retError != string.Empty)
                {
                   eventArgs.ErrorMessage = retError;
                }
                else
                {
                    Output = Encoding.UTF8.GetString(xout);
                    MemoryStream stream = new MemoryStream(xout);
                    XmlTextReader reader = new XmlTextReader(stream);
                    ds.ReadXml(reader);
                    eventArgs.ReceivedType = "D";
                    eventArgs.ReceivedDataSet =ds ;
                }
            }
            catch (Exception ex)
            {
                this.ErrorMessage = "StoreDataSet:" + ex.Message;
                eventArgs.ErrorMessage = this.ErrorMessage;
            }
            ReceivedData(this, eventArgs); //publish the event
            this.Dispose();
        }
        public void StoreDataTable(object source, string methodName, 
            string paramFrom, string paramTo)
        {
            string Output = null;
            string retError = null;
            eventArgs = new ComEventArgs();
            eventArgs.ReceivedState = source;
         if (  ! this.ProxyNotStarted()) return; 
            try
            {
                //   System.Windows.Forms.MessageBox.Show("vfp start");
                DataTable  xout = Proxy.StoreDataTable(out retError, methodName,
                   paramFrom, paramTo);
                  //        System.Windows.Forms.MessageBox.Show("DatTable rows 
                  // count:" + xout.Rows.Count. ToString());
                if (retError != string.Empty)
                {
                    eventArgs.ErrorMessage = retError;
                }
                else
                {
                    eventArgs.ReceivedType = "T";
                    eventArgs.ReceivedDataTable = xout;
                }
            }
            catch (Exception ex)
            {
                this.ErrorMessage = "StoreDataTable:" + ex.Message;
                eventArgs.ErrorMessage = this.ErrorMessage;
            }
            ReceivedData(this, eventArgs); //publish the event
            this.Dispose();
        }
        public void StoreHitComAsyn(object source, string methodName, 
          string paramFrom, string paramTo)
        {
            ThreadStart starter = delegate { this.StoreHitCom(source, methodName,
                paramFrom, paramTo); };
            new Thread(starter).Start();
        }
        public void StoreDataSetAsyn(object source, string methodName, 
          string paramFrom, string paramTo)
        {
            ThreadStart starter = delegate { this.StoreDataSet(source, methodName,
               paramFrom, paramTo); };
            new Thread(starter).Start();
        }
        public void StoreDataTableAsyn(object source, string methodName, 
          string paramFrom, string paramTo)
        {
            ThreadStart starter = delegate { this.StoreDataTable(source, methodName,
               paramFrom, paramTo); };
            new Thread(starter).Start();
        }
        public void StoreFileCom(object source, string methodName, 
          string paramFrom, string paramTo, string filePath)
        {
         //   Log.WriteEntry("start com storefilecom");
              eventArgs = new ComEventArgs();
            eventArgs.ReceivedType = "F";
            eventArgs.ReceivedState = source;
            string retError = null;
            if (!this.ProxyNotStarted()) return; 
            try
            {
           //     Log.WriteEntry("start com storefilecom:" + methodName + "  " 
           // + paramFrom + paramTo + " "+ filePath);
                byte[] Received = Proxy.StoreFile(out retError, methodName, 
                   paramFrom, paramTo);
           // Log.WriteEntry("Received com storefiletcom:" + methodName + "  " + 
           //paramFrom + paramTo + " " + Received.Length.ToString() + " " + filePath);
              if (retError != string.Empty)
                {
                    this.ReturnError(retError);
                 }
                else
                {
                    if (filePath == string.Empty) filePath = 
                         @"D:\moj\vajawcf\aaa.dbf";
                    string fp = filePath;
                    FileStream fs = new FileStream(@fp, FileMode.Create,
                       FileAccess.Write);
                    fs.Write(Received, 0, Received.Length);
                    fs.Close();
                    eventArgs.ReceivedString = filePath;
       //       Log.WriteEntry("Write file com storefiletcom:" + methodName + "  
       //" + paramFrom + paramTo + " " + Received.Length.ToString() + " " + filePath);
                    this.ReceivedData(this, eventArgs);
                }
            }
            catch (Exception ex)
            {
               this.ReturnError ( "Storefilecom Client:" + ex.Message
                  +"From service:"+retError );
            }
            //    ((IClientChannel)Proxy).Close();
            this.Dispose();
        }
       public void StoreFileComAsyn(object source, string methodName, 
           string paramFrom, string paramTo, string filePath)
        {
            ThreadStart starter = delegate { this.StoreFileCom(source, 
               methodName, paramFrom, paramTo, filePath); };
            new Thread(starter).Start();
        }
        private System.Diagnostics.EventLog Log;
        public WcfVfpClient()
        {
            //log file
            if (!System.Diagnostics.EventLog.SourceExists("WcfVfpClient"))
            {
                System.Diagnostics.EventLog.CreateEventSource(
                    "WcfVfpClient", "WcfVfpClient");
            }
            Log = new System.Diagnostics.EventLog();
            Log.Source = "WcfVfpClient";
            Log.Log = "WcfVfpClient";
            Log.WriteEntry("Start from WcfVfpClient");
        }
        public string EndPointUri
        {
            get { return endPointUri; }
            set { endPointUri = value; }
        }
       private WcfVfpWs.IService1Channel _Proxy = null;
       protected WcfVfpWs.IService1Channel Proxy
        {
            get
            {
                if (_Proxy == null)
                {
                    try
                    {
                        EndpointAddress ep = new EndpointAddress(this.endPointUri);
                        if (endPointUri.StartsWith("net.tcp://"))
                        {
                            System.ServiceModel.NetTcpBinding binding = null;
                            binding = new NetTcpBinding();
                            binding.Security.Transport.ProtectionLevel =
                            System.Net.Security.ProtectionLevel.None;
                            binding.Security.Transport.ClientCredentialType =
                            TcpClientCredentialType.None;
                            binding.Security.Mode = SecurityMode.None;
                            binding.TransactionFlow = false;
                            binding.MaxReceivedMessageSize = 600000000;
                            binding.ReaderQuotas.MaxArrayLength = 99999999;
                            binding.TransferMode = TransferMode.Buffered;
                            _Proxy = 
                 ChannelFactory<WcfVfpWs.IService1Channel>.CreateChannel(binding, ep);
                        }
                    }
                    catch (Exception ex)
                    {
                        this.ReturnError("Proxy not started" + ex.Message);
                    }
                }
                return _Proxy;
            }
            set { _Proxy = value; }
        }
       public void Dispose()
       {
           try
           {
               if (_Proxy != null)
               {
                   if (_Proxy.State != CommunicationState.Faulted)
                   {
                      _Proxy.Close();
                   }
                   else
                   {
                       _Proxy.Abort();
                   }
               }
           }
           catch (FaultException unknownFault)
           {
               System.Diagnostics.Debug.WriteLine("An unknown exception was received." 
                  + unknownFault.Message);
               _Proxy.Abort();
           }
         catch (CommunicationException)
           {
               System.Diagnostics.Debug.WriteLine("Service proxy communication exception.");
               _Proxy.Abort();
           }
           catch (TimeoutException)
           {
               System.Diagnostics.Debug.WriteLine("Service proxy timeout exception.");
               _Proxy.Abort();
           }
           catch (Exception)
           {
               System.Diagnostics.Debug.WriteLine("Service proxy encountred a unknown exception and aborted");
               _Proxy.Abort();
               throw;
           }
           finally
           {
               _Proxy = null;
           }
       }
        private string _ErrorMessage = "";
        public string ErrorMessage
        {
            get { return _ErrorMessage; }
            set { _ErrorMessage = value; }
        }
        private bool ProxyNotStarted( )
        {
            if (this.Proxy == null)
            {
               this.ReturnError ( "Proxy  not started");
               return false;
            }
            else
            {
                return true;
            }
        }
        private void ReturnError( string retError)
        {
            this.ErrorMessage = retError;
            this.eventArgs.ErrorMessage = this.ErrorMessage;
            Log.WriteEntry("From WcfVfpClient:"+ this.ErrorMessage.ToString() + " "  
                + retError);
            this.ReceivedData(this, this.eventArgs);
        }
    }
}

Create a new class ComEventArgs.cs (Listing 7).

Listing 7: The ComEventArgs class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
namespace ComWfcVfpClient
{
         public class ComEventArgs : EventArgs
         {
           public string ErrorMessage = "";
           public string ReceivedType = "";
           public string ReceivedString = "";
           public object ReceivedByte = null;
           public DataSet ReceivedDataSet = null;
           public DataTable ReceivedDataTable = null;
           public object ReceivedState = null;
           public ComWfcVfpClient.WcfVfpWs.OrderListCollection ReceivedCollection = null;
           public bool  IsDownloadCompleted = false;
           public bool Cancel = false;
           public void receivedData(string receivedType,string receivedString, 
               object receivedByte, ComWfcVfpClient.WcfVfpWs.OrderListCollection 
               receivedCollection, DataSet receivedDataSet,
           DataTable receivedDataTable, object receivedState, 
               bool isDownloadCompleted, bool cancel, string erorMessage)
           {
               this.ReceivedType = receivedType;
               this.ReceivedString = receivedString;
               this.ReceivedByte = receivedByte;
               this.ReceivedDataSet = receivedDataSet;
               this.ReceivedDataTable = receivedDataTable;
               this.ReceivedState = receivedState;
               this. ReceivedCollection=receivedCollection;
               this.IsDownloadCompleted = isDownloadCompleted;
               this.Cancel = cancel;
               this.ErrorMessage = erorMessage;
           }
        }
}

In the class ComWfcVfpClient.cs (Listing 6) we define the delegate GridEventHandler and its event ReceivedData. We use it to pass the information to the subscribers (callers) of this class instance. We collect the information in the object eventArgs, generate the event and publish it with the command: this.ReceivedData(this, this.eventArgs);
Add a new Service reference to the WCF service (in our case net.tcp://192.168.123.63:8081/wcfvfpwstcp , see the key uri in app.config in the download). Name it WcfVfpWs. It generate the <client> and <binding> description in the app.config. Double click on the WcfVfpWs service reference in the Solution Explorer and select View in object browser. You see the service description used by the WCF client in conjunction with the app.config.
In the class ComWfcVfpClient.cs is the method WcfVfpWs.IService1Channel Proxy (Listing 6), which generate the client channel (the proxy) and add it few properties (about security, message size etc). When the client is done, the client needs to close the proxy transport channel [7].
In the class ComWfcVfpClient.cs we find similar methods as in the WCF service. We call the service methods in two ways: synchronous (blocking) and asynchronous which run the synchronous method on a new thread. For example the method:

calls the synchronous method StoreDataSet on a new thread (non blocking the VFP form). The above code is not a real callback to the server! It is only a local callback. The method StoreDataSetAsyn is delegating the task to the method StoreDataSet on a new thread and implicitly also the method (event) ReceivedData(this, eventArgs) is fired. It informs (call back) the callers (subscribers) of the results generated by the StoreDataSet. The callers receive the results in the form of two objects (sender - its type is object and eventArgs - of type ComEventArgs). The ComEventArgs type must be known to the caller! (We will present it in next parts).

About Josip Zohil

Josip Zohil, Koper, Slovenia, Josip.Zohil1@guest.arnes.si

This author has published 3 articles on DotNetSlackers. View other articles or the complete profile here.

You might also be interested in the following related blog posts

Announcing Microsoft Ajax Library (Preview 6) and the Microsoft Ajax Minifier read more
WPF Release History : Q2 2009 (version 2009.2.701) read more
Building a class browser with Microsoft Ajax 4.0 Preview 5 read more
Silverlight Release History : Q2 2009 (version 2009.2.701) read more
Business Apps Example for Silverlight 3 RTM and .NET RIA Services July Update: Part 7: ADO.NET Data Services Based Data Store read more
Introducing Versatile DataSources read more
Improving Dynamic Data with Peter's Data Entry Suite read more
Convert Web.UI ASP.NET Grid into a data entry spreadsheet read more
Web.UI 2008.2 Grid News: Grouping read more
Web.UI 2008.2 Grid News: Grouping read more

Top

Please login to rate or to leave a comment.

Product Spotlight

Login

Lost Password?