Smart Client: So where is the End-Point?

WindowsMobileLogo In my last post about my adventures in Smart Client land I talked about Using WCF Services with Smart Client Applications. In this post I wand to talk about how you can make things like database and service end-points dynamically adjust for different deployment scenarios.

Being a developer at a large corporation presents challenges not faced by those who develop and then deploy to a public customer web hosting.  My company has a fairly rigorous deployment strategy.  While it is designed to safeguard our production environment from any unwanted changes it presents some difficult programming challenges. At my current employer we have 3 main environments, development, test, and production.  The difficulty comes in when you start making database connections or use web or applications services in you application, since each environment will have different connection information.

In this post I am going to detail a possible solution to this issue that I used on my current project, which is a Smart Device project that uses WCF Services on a handheld device to talk to our business layer and data provider.  There aren’t any database connections from the Smart Device so all of the examples here will deal with changing application service end-points.  Please not that this technique would work equally well for database connection info.

The setup, a Smart Device application targeting the .NET Compact Framework 3.5 and using WCF Services.  When I develop I want the services to point our local machine, likewise, when the application is deployed to Test and Production the services should point to the correct resources in that environment.

The first pieced information the application needs to know is what environment are it is currently running in.  I have used different methods to configure this in the past, a setting in the machine.config (for web applications), or a setting the in the app.config for windows client.  In this case I decided to go with a command line argument to simplify switching from one environment to another.  I realize this may not be the best solution, but with the limited access to the OS on the Smart Device I felt changing a shortcut was much easier than trying to dive into the file system and make changes to a config file.

Command line arguments to be passed:

  • Local, to use local services
  • Test, to use services in the Test environment
  • null is passed telling the app to use services in the Production environment

Now put the endpoints for each environment in the the config file using the following naming convention:  Name_environment where environment is Local, Test, or Production.

   1:  <?xml version="1.0" encoding="utf-8" ?>
   2:  <configuration>
   3:    <appSettings>
   4:   
   5:      <add key="MyService_Local" value="http://localhost/MyServer/Service.svc" />
   6:      <add key="MyService_Test" value="http://test.example.com/MySerivce/Service.svc" />
   7:      <add key="MyService_Production"  value="http://production.example.com/MService/Service.svc" />
   8:   
   9:      <add key="MyService_Timeout"  value="180" />
  10:      <add key="MyService_MaxReceivedMessageSize" value="65536"/>
  11:      <add key="MyService_MaxBufferSize" value="65536"/>
  12:   
  13:    </appSettings>
  14:  </configuration>

The next step is to create an ApplicationSettings class that will be used to get the correct endpoints for the service.

   1:  using System;
   2:  using System.Linq;
   3:  using System.Reflection;
   4:  using System.Xml.Linq;
   5:   
   6:  namespace MyClient.Core
   7:  {
   8:      public static class ApplicationSettings
   9:      {
  10:   
  11:          public static string RunTimeEnvironment { get; set; }
  12:   
  13:   
  14:          public static string MetroServiceEndPoint
  15:          {
  16:              get { return ConfigManager.GetAppSetting("MyService_" + RunTimeEnvironment); }
  17:          }
  18:   
  19:          public static TimeSpan MetroServiceTimeout
  20:          {
  21:              get
  22:              {
  23:                  int seconds = Convert.ToInt32(ConfigManager.GetAppSetting("MyService_Timeout"));
  24:                  return new TimeSpan(0, 0, seconds);
  25:              }
  26:          }
  27:   
  28:          public static long MaxReceivedMessageSize
  29:          {
  30:              get { return Convert.ToInt64(ConfigManager.GetAppSetting("MyService_MaxReceivedMessageSize")); }
  31:          }
  32:   
  33:          public static int MaxBufferSize
  34:          {
  35:              get { return Convert.ToInt32(ConfigManager.GetAppSetting("MyService_MaxBufferSize")); }
  36:          }
  37:   
  38:      }
  39:  }

This simple implementation does exactly what we want, given a known environment it will return the correct value from the configuration file.  If the runtime environment is set to Local it will return the information from “MyService_Local”, and adjust for each environment we are in.

So earlier I stated we need to know what environment we are in, this is still unknown. A command line argument has been defined but hasn’t been used to connect the request and the application settings together.  The ApplicationSetting class has a property for RunTimeEnvironment and this will need to be set when the application starts.

Here is what the Main function looks like from the Smart Device application:

   1:  internal static class Program
   2:      {
   3:          [MTAThread]
   4:          private static void Main(string[] args)
   5:          {
   6:              ApplicationSettings.RunTimeEnvironment = GetRunTimeEnvironment(args);
   7:   
   8:              new LogonForm().ShowDialog();
   9:          }
  10:   
  11:          private static string GetRunTimeEnvironment(string[] commandLine)
  12:          {
  13:              if (commandLine.Length != 0)
  14:              {
  15:                  if (commandLine[0].ToUpper().Contains("LOCAL")) return "Local";
  16:                  if (commandLine[0].ToUpper().Contains("DEV")) return "Development";
  17:                  if (commandLine[0].ToUpper().Contains("QA")) return "Test";
  18:              }
  19:   
  20:              return "Production";
  21:          }
  22:      }

The GetRunTimeEnvironment  method sets the correct ApplicationSettings.RunTimeEnvironment property based on the command line argument.  Now we have tied it all together and can change the end-points of our applications services simply by changing the command line in the shortcut on the device.

I hope that has helped ease some of the pain of working with Smart Device applications and using WCF Services.  I have learned a ton about using Smart Device project and the limitations of the .NET Compact framework.  I can’t wait to get back to development on the full framework, which will hopefully be soon.

Using WCF Services with Smart Client Application

WindowsMobileLogo The current project I am assigned to at work is Smart Client application running own Windows CE that communicates with WCF Services that it uses to communicate with SAP via BizTalk Services.  We choose to use WCF because of the power that we felt it would bring to the solution.  What we didn’t realize was the limited support in Visual Studio for consuming WCF Services for a Smart Client application.

In a WinForms application you have two choices to add an Application Reference to your project you can use the SvcUtil.exe or you can right click on the References node of the solution and select Add Application Reference.  In the Smart Client world you don’t have either option, you can try to use the SvcUtil.exe but it will not create a proxy that can compile against NetCF libraries because NetCF does not include all the classes referenced from that source code.

Fortunately we found the Power Toys for .NET Compact Framework 3.5 which contains NetCFSvcUtil.exe that could be used to generate NetCF complaint service proxies.  Once install the power toys you will find the NetCFSvcUtil.exe in the C:\Program Files (x86)\Microsoft.NET\SDK\CompactFramework\v3.5\bin directory.

We setup a batch file to generate the service files for us.  So, all we had to do was make sure we check out the files and then run the command file to update the proxies and check the files back in and we are good.

You should be aware that NetCF does not support all WCF Bindings, it supports: BasicHttpBinding, CustomBinding, WindowsMobileMailBinding, and ExchangeWebServiceMailBinding.  Andrew Arnott has a post about The WCF subset supported by NetCF and other good information.

A good friend and member of our team Devlin Liles, has put together a great post, Batch File and Command File running in Visual Studio, to show how you can execute a command file from the Visual Studio IDE and use the output window for any text.  I highly recommend you check it out.

NetCFSvcUtil.exe http://localhost/MyService.svc

This will generate the CFClientBase.cs and the MyService.cs files we need to access the WCF Service.  If you want to control the namespace that the proxies get created in you can use the /namespace argument to specify this.

NetCFSvcUtil.exe namespace:*,MyNameSpace.Proxies http://localhost/MyService.svc

Likewise you can also control where the files are generated by using the /directory argument.

NetCFSvcUtil.exe namespace:*,MyNameSpace.Proxies http://localhost/MyService.svc /directory:../MyApp/Proxies

There are a lot of other options you can use to control how the proxies are generated you can execute NetCFSvcUtil.exe /? to see all of them and what they do.

This gets you up and running with WCF Services in a Smart Client application, without the robust configuration that is offered with WinForms or WebForm projects.  In my next post I will walk you through how we configured our WCF Service endpoints and set some custom binding information to control how our clients behaved when consuming the services.

Calendar

<<  April 2017  >>
MonTueWedThuFriSatSun
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

View posts in large calendar

Month List