Once the above issue got fixed we tried opening up the grammar again in Intellipad. It first of all took a long time to parse the grammar and finally it threw an ArgumentNullException. We had no clue why this was happening as this was raised by the M compiler. We raised another bug on the Microsoft “Oslo” Connect site for this issue. Once again the reply that we got from Microsoft was that this was indeed a bug in the M compiler and it had been fixed in their current codebase. Now we need to wait till the next CTP comes out probably in the month of November this year, to see whether they have actually solved the issue. You can check out the bug that we had raised in this regard, here.

Due to the above issues that we faced with the “Oslo” May 2009 CTP; we were forced to continue using the “Oslo” Jan 2009 CTP for our development work. Playing around with CTPs is not really an easy job, is it?

SOA initiatives using ASMX services and trying to reach out to all the stakeholders on internet using SOAP/http clients was the natural option, where as to connect with employees, internal users or partner’s it would have used TCP IP based .Net Remoting. Thus to serve different user base, one has to use different transport option and each transport needed independent implementation.

Unlike ASMX services which were primarily Http based, WCF Services can be reached using multiple protocols like Http, TCP IP, Named Pipe and MSMQ. Other clients like internet/intranet or partners can use any of the above mentioned preferred channels to hook on to these services without IT having to maintain separate code base to serve different client class.

Interoperability

Large Enterprises having mix of technologies, Interoperability requirements with Non Microsoft clients is one of the common scenarios in any SOA initiatives. With ASMX WS-*, XML Serialization is not standardized and hence it is difficult to achieve true interoperability. With WCF, it generates standard SOAP based XML to be consumed by clients. Additionally by using data contracts and message contracts, information exchange with non Microsoft clients’ become easy and improves interoperability.

Performance

Most often sharpness of underlying technology contributes in meeting performance based business SLAs (e.g. In banking gateway for Money transfer, Number of clients served per second). ASMX services were part of .net framework 2.0, since then with .net 3.5 and 4.0 around, there has been continuous improvements in core .net framework to improve performance.

One of the key reasons WCF performance is better than ASMX services is due to the improved serialization techniques in the .net framework. WCF services provide 25 to 40% improvement in performance over ASMX services and hence become natural preference for high performance application.

Extensibility

If ASMX services were to be delivered to clients, only possible way to host them was on to IIS (Internet Information Server). With WCF services, one can host the services into Windows services, Windows Activation Service (WAS) or IIS. WCF also supports claims based authorization which is more granular than existing mechanisms. With WCF starting from application runtime, security, binding, serialization, channel system to service host everything is extensible.

ASMX with WSE 3.0 supports security and http buffering/caching/sessions but still lacks support for Session management, Concurrency, Security, Reliable messaging, Transaction, Throttling, Exception handling and faults. In applications explicitly using WSE to support some of these features is difficult and cumbersome, where as with WCF WSE is inbuilt.

With .Net 4.0, the argument to migrate becomes even stronger because of the benefit from platform features like CLR enhancements, Improved Garbage collection, Parallel programming, Distributed caching, and improved support for REST, and Workflow Services.

With above benefits making way to WCF migration, one of the ways to solve service migration problem is by overlaying WCF attribute over ASMX attributes. e.g. With ServiceContract() attribute on ASMX Service class, and OperationContract() on service methods/operations and then making  appropriate changes in .config file. This wrapper based approach may make asmx services work with asmx and wcf clients. But with this approach, since the underlying code is still asmx, it will not benefit from the underlying framework advantages that WCF provides as discussed above.

Within Infosys, we have built tool to automate and address such service migrations from ASMX to WCF. If you are looking for help on such initiatives, please feel free to reach out to us.

While troubleshooting such problems one should start with following
1. The service application hosted on IIS should be using dedicated application pool (no other application is using the same application pool)

2. In case if the client application (asp.net) is also hosted on the same IIS server it should be using another dedicated application pool

Once these basic things are ensured, one should configure perfmon on IIS server with Instances counter from ServiceModelService 3.0.0.0. The instances count can help plot the service instances consumed from the application at any given point of time.

Another way to validate this is by taking memory dumps using DebugDiag, downloadable here.

Take full memory dump on server running WCF services (for IIS 6 and above, w3wp process id running WCF, or aspnet_wp for IIS 5). The Debugdiag tool needs to be installed on machine running IIS and the appropriate application Crash/Hang rule should be configured in this tool to capture the dump. Once the memory dump is captured on server, one can analyze this dump using WinDbg client, this tool can be downloaded from here

Once dump is obtained, next step is to start analyzing dumps. Steps to analyze the memory dumps are as follows

1) Open Crash Dump in WindDebug from File-> Open Crash dump

2) Set symbol path using command !symfix D:\Symbols

3) Load SOS file for .net 2.0 CLR using
   .Load C:\Windows\Microsoft.NET\Framework\v2.0.50727\SOS.dll

4)   To list addresses of all objects of type ServiceThrottle that exist on the managed heap. Use !dumpheap -type ServiceThrottle –short

------------------------------
0:000> !dumpheap -type ServiceThrottle -short
09f20b10
09f22a14
09f24a56
09f25023
0deaa456

5)For each address from the above output, list dumpobject address using command
!do 0deaa456

0:000> !do 0deaa456
Name: System.ServiceModel.Dispatcher.ServiceThrottle
MethodTable: 1b1ba2e4
EEClass: 1ae21f20
Size: 36(0x24) bytes
 (C:\WINNT\assembly\GAC_MSIL\System.ServiceModel\3.0.0.0__b77a5c561934e089\System.ServiceModel.dll)
Fields:
      MT      Field         Offset                 Type VT     Attr      Value         Name
1b1ba328  400371c        4 ...cher.FlowThrottle  0   instance 0deaa454   calls
1b1ba328  400371d        8 ...cher.FlowThrottle  0  instance 0dea45b    sessions
1b175dbc  400371e        c ...her.QuotaThrottle  0  instance 00000000  dynamic
1b1ba328  400371f       10 ...cher.FlowThrottle  0  instance 00000000 instanceContexts
1b1b994c  4003720       14 ...l.ServiceHostBase 0  instance 0deaa168 host
793043b8  4003721       1c       System.Boolean 1 instance 0deaa234 isActive
79330508  4003722       18        System.Object  0 instance 0deaa3b8 thisLock

6) The ServiceThrottle object has many fields but sessions will help us progress. Type !do address of the sessions field to see what's inside of it.
!do 0dea45b
 
0:000> !do 0dea45b
Name: System.ServiceModel.Dispatcher.FlowThrottle
MethodTable: 1b1ba322
EEClass: 1ae21c43
Size: 36(0x24) bytes
 (C:\WINNT\assembly\GAC_MSIL\System.ServiceModel\3.0.0.0__b77a5c561934e089\System.ServiceModel.dll)
Fields:
      MT      Field       Offset                 Type VT     Attr        Value       Name
79332b38  50034f4       18         System.Int32  1 instance       10             capacity
79332b38  50034f5       1c         System.Int32  1 instance       10              count
79330508  50034f6        4        System.Object  0 instance 0deaa570 mutex
7931e84c  50034f7        8 ...ding.WaitCallback  0 instance 0deaa52c release
00000000  50034f8        c                               0 instance 0deaa57c waiters
793308ec  50034f9       10        System.String  0 instance 0deaa4b4 propertyName
793308ec  50034fa       14        System.String  0 instance 0deaa4f0  configName
 
The above highlighted capacity shows what the maximum capacity of WCF pool is; count indicates the current number of instances. In this example since both are 10, it indicates that no new WCF connection can be created unless the existing ones are being released.

Remedies

Unlike ASMX services, the WCF services needs to be explicitly instantiated and once the service call is completed the proxy connection needs to be explicitly closed. Not doing so correctly can result in to server side WCF connection exhaustion ultimately leading to service denial.
There may be scenarios where the concurrent users may be 2 or 3 and still the WCF connection pool may get exhausted, this can happen due to one of the possible condition

1.While working with the application, the concurrent browser sessions would have reached to 10 and hence connection pool got exhausted and couldn’t serve beyond 10 concurrent requests

2.WCF Service in turn calling Database stored procedures or other code which is long running and hasn’t returned the call to service, connection timeout settings are not hit and hence pool got exhausted.

3.WCF connections being leaked from some part of the code as WCF proxies were not closed appropriately.

For #2, the service side .config parameters which control settings are mentioned in serviceThrottling section depicted as
 
<serviceBehaviors>
        <behavior   name="My.Samples.ServiceLayer.CricketScoreServiceBehavior">
          <serviceThrottling
                 maxConcurrentCalls="10"  
                 maxConcurrentSessions="10” />
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="false" />
 </serviceBehaviors>

maxConcurrentCalls specifies maximum number of messages actively processing over a servicehost, where as maxConcurrentSessions controls how many maximum concurrent sessions can exists on the service host.  Refer the details about these settings here
Setting these to 10 may not be enough in scenarios where total No. of users or concurrent users are high.
For the above service, as soon as the total service instance reaches to 10, the next client call to service would go in wait state. It would remain in wait state and wait till the existing WCF connections are closed or timed out. Hence it is important that the timeout setting kicks in ASAP so that the client can acquire connection. These settings are controlled using the client side .config parameters which are ReceiveTimeout and InactivityTimeout

•InactivityTimeout - This inactivity timer fires if no messages, either application or infrastructure, are received within the timeout period. An infrastructure message is a message that is generated for the purpose of one of the protocols in the channel stack, such as a keep alive or an acknowledgment, rather than containing application data.

•ReceiveTimeout - This inactivity timer fires if no application messages are received within the timeout period. This specifies, for example, the maximum time a client may take to send at least one message to the server before the server will close the channel used by a session. This behavior ensures that clients cannot hold on to server resources for arbitrary long periods.

<system.serviceModel>
    <bindings>
      <wsHttpBinding>
        <binding name="WSHttpBinding_ICricketScoreService"
          closeTimeout="00:01:00"
          openTimeout="00:01:00"
          receiveTimeout="00:10:00"
          sendTimeout="00:01:00"
            <reliableSession ordered="true" inactivityTimeout="00:10:00"
            enabled="false" />
        </binding>
      </wsHttpBinding>
    </bindings>
</system.serviceModel>
 
 
Details about other WCF settings can be referred from here
Timeout settings are handy, but for #3 above, important that in the client side code one must ensure that the WCF proxy connections be explicitly closed. Following code snippet can be used as guidance for appropriate connection closing.

Try
  {
      CricketScoreService.ScoreClient _obj;
     _obj = new CricketScoreService.ScoreClient();
      //do other activities like calling Business layer method and once
      //done close the WCF connection as below
     _obj.Close();
  }
              Catch (Exception e) //catch service exception like faulted, etc.
      {
         if (obj!= null) &&
            (_obj.State == System.ServiceModel.CommunicationState.Faulted)
          {
           _obj.Abort();
          }
         Else if (obj!= null) &&
                 (_obj.State != System.ServiceModel.CommunicationState.Closed)
                {
                    _obj.Close();
                }
      }
   
 
Another recommended way to close WCF connection is by “using” statement as follows,
using (CricketScoreService.ScoreClient sc = new CricketScoreService.ScoreClient ())
       {
         sc.getScores(“111”);
       }

The using block automatically calls sc.Dispose() when it's done.
using statement doesn’t always ensure closed connection, hence it is not recommended to be used for closing connections. 
With ClientBase abstract class(which any WCFClient would inherit, check here), implementing the Dispose() method will make a call to Close(). When the ClientBase's Close() method is called, a web service call actually goes out to the WCF service, informing it that the connection session is no longer required. The problem with this mechanism is that when the Close() method is called, an exception can be thrown. After all, it involves yet another network call to a web service. It's for this reason that the using statement isn't recommended with WCF clients.

With this as background, watch out for WCF application hang problem for applications running in UAT, or production scenarios and this should come handy resolving it.

The making of a bridge entails site inspection to ground preparation to blueprinting ending with construction where there are tests in the intervening duration to ensure that this is safe and can serve the intended purpose without risking the lives of the users who are going to use this to go from Point A to Point B. The work is not limited to only bridge but also entails making approach roads and giving a complete end to end solution to the commuter needs.

The team has also updated the documentation for the “Oslo” platform on MSDN. I think the lack of sufficient documentation has been one of the key challenges that people faced in their effort to understand the platform and I hope Microsoft comes out with better documentation for things like customizing Intellipad, adding new modes, error handling within Intellipad, System.Dataflow APIs etc.

Listing few problems I came across with this windows version. I searched on technet and msdn forums and didnt find any solutions.

1. Once in a while Windows 7 desktop UI flickers. When it flickers it flickers violently. Entire Task bar and all the icons go blank. I am yet to figure out the reasons/conditions under which it behaves like this.

2. Wrong system icon tray notifications. Though I have internet connection, the net work notiifcation displays incorrect meesage that "no internet access" as shown in the below image. This is true for both LAN connection and Wireless Lan connection.

3. After Upgrade from Windows Vista, my VPN CheckPoint SecureClient was not starting. Went to Services MMC and found that "Check Point VPN-1 Securemote service" is dependent on VPN-1 module that has been deleted or marked for deletion. Tried many things but finally reinstallation of the Secure Client Software did the trick. After reinstalling i found that "Check Point SSL Network Extender" has been added to services list. In the Log On options, "Allow Service to interact with Desktop" has been checked.

4. e Trust Anti Virus 8.1 version from Computer Associates. This is not compatible with Windows 7. It is installed properly and works. Just that it does not download the latest signature files. Add to this, Action Center shows me that this Antivirus software is not compatible and suggests me other compaines anti virus programs. Being on the corporate network cannot use anti virus software not recommended by our network group. Currently working with our network team to sort it out. This may force me to take my laptop off the network or force me to down grade my o/s to Vista.

5. Not exactly related to Windows 7. IE 8 that comes as a default browser is not compatible with Outlook Web Access. This requires Exchange Server to be upgraded with a patch to allow DHTML controls on browser. Any patch management on servers is a huge task for network folks so would take take. Some of our internal IS apps are not compatible with IE 8. So I am planning to install a VPC image on my laptop with IE 6 as browser. Are there any better ways to work around it??

If you are aware of any solutions to the above problems, please point me to them.

• Add a new classification type to the ClassificationTypes.xcml file in the Settings folder, as shown below:

<act:Export Type='mvstc:ClassificationTypeDefinition'>
      <ls:ClassificationType Name='CustomKeyword' DerivesFrom='text' />
</act:Export>

To define the format for the classifiaction type that we just added, we need to define the format in the ClassificationFormats.xcml file in the Settings folder, as shown below:

<act:Export Name='{}{Microsoft.Intellipad}ClassificationFormat'>
      <ls:ClassificationFormat Name='CustomKeyword'
                             FontFamily='Consolas'
                             FontWeight='Bold'
                             Foreground='#FF2B91AF' />
</act:Export>

Make sure that “Name” attribute while defining the format should be same as the Name of the classification type that we had defined in the previous step.

In your DSL MGrammar code you can use the classification type created above in the following manner:

@{Classification["CustomKeyword"]}
token MyToken = “SampleToken”;

Now if you save the .xcml files, close (if already open) and open up Intellipad, you will be able to see the new classification type in action.

• Now the second option is to have a separate .xcml file for our DSL, where we could specify the classification types specific to our DSL and can be deployed when we install our own mode into Intellipad. In order to define the same classification type specified above in a separate .xcml file, you need to first create a file with the extension .xcml (Name doesn’t matter, but something related to your DSL would be better), and then specify the type and the format as shown below:

<act:Exports xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'
             xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
             xmlns:act='clr-namespace:System.ComponentModel.Activation;assembly=Activation'
             xmlns:mvstc='clr-namespace:Microsoft.VisualStudio.Text.Classification;assembly=Microsoft.VisualStudio.Platform.Editor'
             xmlns:ls='clr-namespace:Microsoft.Intellipad.LanguageServices;assembly=Microsoft.Intellipad.Core'>
 

   <act:Export Type='mvstc:ClassificationTypeDefinition'>
      <ls:ClassificationType Name='CustomKeyword' DerivesFrom='text' />
   </act:Export>
   <act:Export Name='{}{Microsoft.Intellipad}ClassificationFormat'>
      <ls:ClassificationFormat Name='CustomKeyword'
                             FontFamily='Consolas'
                             FontWeight='Bold'
                             Foreground='#FF2B91AF' />
   </act:Export>
</act:Exports>

Once you have saved the file, you can either put this file under the Settings folder or you can create a new directory for your DSL under the C:\Program Files\Microsoft Oslo SDK 1.0\Bin\Intellipad\Components folder, and put it in that directory to enable Intellipad to pick up the types and their formats.

As per my understanding, Intellipad by default picks up the classification types by scanning the files with .xcml extension both in the Settings as well as the sub folders under the Components folder and picking up all the Export elements with the type as ClassificationTypeDefinition. Considering this fact, to me the second option would be a better one to go for, when it comes to ease of deployment and maintenance. But when it comes to performance, I feel having all the types in one file would be a better option. Hence if you have a lot of custom classification types that you would be creating for your DSL then I would suggest you go for the second option, but if the number of classification types you are going to create are less in number, then it would be better to define those in the ClassificationTypes.xcml and ClassificationFormats.xcml files under the Settings folder.

Microsoft Project code name “Velocity”, part of .net 4.0 is Microsoft’s highly scalable in memory cache framework for all kinds of data in distributed applications. Usually caching is employed in application to improve the performance and scalability. Good candidates for caching data is static or master data e.g. product list. Recommended practice is to cache master or reference or lookup data as it hardly changes over time but at times scenarios exists where transactional or session specific data needs to be cached for valid reasons.

Velocity can be hosted either within the application (embedded) or as an independent service. If hosted within the application, the distributed cache shares the memory with the application. If hosted as service, client access the cache using client APIs.

To ensure every time the request to cache is fulfilled and the cache returns the correct results in quick time, distributed cache can be partitioned, clustered and or replicated. Nodes can be added or removed dynamically to and from clusters to increase the throughput or decrease the response time. Velocity will do implicit load balancing and new data will be cached in new node and existing data will also be migrated to new node.

Clients can either directly query the Cache host which in turn returns the correct cached object or client can locally host the routing table which keeps track of where the distributed cached objects are and can query cached objects directly.

To ensure cache consistency, Velocity supports Notification services, optimistic and pessimistic concurrency. Expiration of cache is time based and cache object eviction can kick in based on least recently used object algorithm or high water mark of the application.

Velocity provides SessionStoreProvider class that plugs into Asp.net session storage provider model and stores session state. Using Velocity ensures non sticky session routing and ensures session data is available across clusters.

For application specific data the cache can be hosted or embedded within the application. For data required enterprise wide or cuts across multiple applications should be exposed using Cache Service. In the enterprise architecture, Velocity can very well sit on top of Master Data management applications and negotiate the frequent Database hits from client applications.

APIs from System.Web.Caching namespace can be used only in Web applications, the problem with directly using these APIs in the application is every developer uses his creativity in dealing uniquely with cache and hence it is recommended to use Enterprise Library Caching application block to standardize the coding/usage pattern. With 4.0 the new namespace System.Caching will take over for specifically inproc caching. System.Web.Caching will remain to support backward compatibility.

In process cache is the fastest of all the caching techniques. Enterprise library Caching application block using in-process cache has limitations on the scalability, reliability and availability front, when the asp.net worker process gets recycled the data in the in memory cache is lost. In Web garden, where multiple worker processes exists, the data integrity issues surface from the limitation due to synchronization of multiple copies of cache. In Web farm scenario, where multiple servers exist, a standalone cache is unaware of other servers and their respective state which again leads to data integrity issues. In process cache cannot usually grow beyond what the application process can handle where as distributed cache can grow in size through distribution.

Outproc technique using Asp.net State Server/service on 32bit machine can grow up to 2GB of memory space, up to maximum 3 GB if you use the /3GB switch. As 32bit servers are becoming legacy and 64bit becomes main stream, this limitation of memory space will not hold long. If run with single state server, the state service technique has single point of failure. If State server is clustered, it has the limitations of data synchronization across cluster. If the state service or the machine on which it is running goes down, clustered state service will still not be able to recover the state of the data e.g. Ready to check out shopping basket. Though you can still continue to be in the application and may or may not have to re login into the application, selecting and adding items in to the basket will have to be started all over again, ultimately hampering the user experience.

Outproc techniques using SQL Server to some extent resolve above mentioned data integrity and scalability issues, but the idea behind caching is to save the database roundtrip, and here the data is being cached in another SQL Server database instance defeats part of the objective. In customer scenarios where SQL Server cannot be used as caching database, custom provider for Oracle or for that matter any database can be used to extend it to respective database but the database roundtrip limitation holds.

Till date if the architecture needs to deal with distributed caching problem, it has to live with the limitations of out of the box outproc techniques or rely on 3rd party components like NCache,
ScaleoutState Server, StateMirror, etc. Having out of the box support for distributed cache from .net 4.0 Velocity framework would help deal with such scenarios without additional investments.

In physics, Velocity is ratio of change of distance to change in time in specific direction. The Microsoft framework Velocity certainly attempts to fulfill this definition by making the data available to end user in quick time J

Now, it’s time to think big. Microsoft Operations framework (MOF) addresses the entire gamut of challenges cutting  across CIOs, managers, admins and developers.

The guidance in the Microsoft Operations Framework encompasses all of the activities and processes involved in managing an IT service: its conception, development, operation, maintenance, and—ultimately—its retirement. MOF organizes these activities and processes into Service Management Functions (SMFs), which are grouped together in phases that mirror the IT service lifecycle. Each SMF is anchored within a lifecycle phase and contains a unique set of goals and outcomes supporting the objectives of that phase.