Recordings from the BizTalk Performance meeting at the Swedish BizTalk User Group

by | Jun 6, 2010 | BizTalk Community Blogs via Syndication

The videos from the BizTalk performance talk by me and Ewan Fairweather  has finally got published on msdn.

Instrument your BizTalk Server

Optimizing and verifying your BizTalk Server installation is not an easy thing to do. The documentation is good but very extensive. This presentation aims to guide you through the most important operations you need to do in order to boost the performance of BizTalk.

Performance Optimization Patterns

This session will present architectural, design, and development patterns to improve BizTalk processing performance. "Performance" can be expressed by latency and/or throughput, and this session will cover aspects of both. This will include pipeline and orchestration patterns to increase throughput, reduce latency, and reduce memory usage during BizTalk processing. We will also cover the results from BizTalk CAT recent Perf engagements.

endpoint.tv – Activity Designers and Designer Rehosting with Kushal Shah

by | Jun 4, 2010 | BizTalk Community Blogs via Syndication

Windows Workflow Foundation in .Net 4 (WF4) makes it possible for you to build custom activity designers that allow different kinds of users to graphically design business processes. In this episode, Kushal Shah, program manager for the Workflow Designer team, shows us how you can build custom activities with support for the developers and end users who collaborate to build business processes.

Dowload the sample code from this video

For more information, see the Windows Workflow Foundation Developer Center on MSDN.

Using the LOB Activity in AppFabric workflows

by | Jun 3, 2010 | BizTalk Community Blogs via Syndication

 

1.       Right-clicking the workflow project, will show the Add Adapter Service Reference… menu item. 
 

 

2.       This shows the familiar Add Adapter Service Reference dialog box.  (Don’t you all agree this tool still looks too much of ‘Form1/Button1’ app? J).  After selecting the sqlBinding and providing the ServerName and DataBaseName, the connection was made.

3.       This showed all the available metadata for this connection.  It is possible to select stored procedures or tables that will be used in the process.

 

4.       Since the LoanRequest needs to be inserted in the database table, the Client contract type was specified and the correct table (LoanRequests) and operation (Insert) were selected.

 

Using the LOB activity.

 

1.       After clicking OK and performing a rebuild on the project, a new custom activity was added to the Workflow Designer toolbox.  Each operation (Insert, Update …) that was selected results in a specific activity that is part of a category with the database object name.

2.       Dragging this activity on the canvas, shows that the following parameters can be specified on the shape.

 

3.       I only declared the variable ‘saveLoanResult’ that represents the records that should be added to the database.   This variable was linked with the Rows parameter of the InsertActivity shape and is an Array of LoanRequest objects.

4.       The InsertResult parameter would return the result of the database activity, but this parameter is optional, so I did not link it with a variable here.

 

5.       The BizTalk mapper activity was added right before the InsertActivity shape.  Here, I defined a mapping between the loanRequest and the databaseInsert.

6.       Compiling the project and executing the workflow, resulted in a new record in my database table.
 

 

 

Conclusion

The power of connectivity and adapter is now made available to the AppFabric platform in a standardized and user-friendly way.  It is now also easy to connect to various LOB systems, databases and host systems (using the BizTalk Adapters for Host Systems). 

What is not clear at this point is how the licensing will work for these AppFabric features.  But more information about that can probably be expected by the time of the public release.

Sam Vanhoutte

Use Expressions with LINQ to Entities

by | Jun 3, 2010 | BizTalk Community Blogs via Syndication

[Source: http://geekswithblogs.net/EltonStoneman]
Recently I’ve been putting together a generic approach for paging the response from a WCF service. Paging changes the service signature, so it’s not as simple as adding a behavior to an existing service in config, but the complexity of the paging is isolated in a generic base class.
We’re using the Entity Framework talking to SQL Server, so when we ask for a page using LINQ’s.Take() method we get a nice efficient SQL query for just the rows we want, with minimal impact on SQL Server and network traffic. We use the maximum ID of the record returned as a high-water mark (rather than using .Skip() to go to the next record), so the approach caters for records being deleted between page requests.
In the paged response we include a HasMorePages indicator, computed by comparing the max ID in the page of results to the max ID for the whole resultset – if the latter is bigger, then there are more pages.
In some quick performance testing, the paged version of the service performed much more slowly than the unpaged version, which was unexpected. We narrowed it down to the code which gets the max ID for the full resultset – instead of building an efficient MAX() SQL query, EF was returning the whole resultset and then computing the max ID in the service layer.
It’s easy to reproduce – take this AdventureWorks query:
var context = new AdventureWorksEntities();
var query = from od in context.SalesOrderDetail
where od.ModifiedDate >= modified
&& od.SalesOrderDetailID.CompareTo(id) > 0
orderby od.SalesOrderDetailID
select od;
We can find the maximum SalesOrderDetailID like this:
var maxIdEfficiently = query.Max(od => od.SalesOrderDetailID);
which produces our efficient MAX() SQL query. If we’re doing this generically and we already have the ID function in a Func:
Func<SalesOrderDetail, int> idFunc = od => od.SalesOrderDetailID;
var maxIdInefficiently = query.Max(idFunc);
This fetches all the results from the query and then runs the Max() function in code. If you look at the difference in Reflector, the first call passes an Expression to the Max(), while the second call passes a Func. So it’s an easy fix – wrap the Func in an Expression:
Expression<Func<SalesOrderDetail, int>> idExpression = od => od.SalesOrderDetailID;
var maxIdEfficientlyAgain = query.Max(idExpression);
– and we’re back to running an efficient MAX() statement.
Evidently the EF provider can dissect an Expression and build its equivalent in SQL, but it can’t do that with Funcs.

HIPAA Subdocument splitting – EXPLAINED

by | Jun 2, 2010 | BizTalk Community Blogs via Syndication

I wanted to enhance my previous blog entry about how to successfully split the EDI transactions into individual claims.

The one liner does not adequately do justice as to what is really going on, so I thought I would embellish on how to get it properly configured, but also what is really going on, and how to make changes (if you really want to).

The first thing is to explain the fundamental difference between the the single and multiple schema:

The single schema breaks up an interchange into individual transactions per BizTalk message. This means that each transaction with all of the claims in the transaction is submitted as one message.

The multiple schema is designed to break up an interchange into individual claims per message (regardless of the transaction it came in, by default). This means that each message that is submitted to BizTalk Message Box contains only one claim.

The schemas are mostly the same, except for the subdocument_creation_break attribute in the annotation:

<!-- Multiple -->
<xs:element name="TS837Q3_2300_Loop">
<xs:annotation>
 <xs:appinfo>
   <b:recordInfo structure="delimited" delimiter_type="inherit_record" field_order="infix" count_ignore="yes" child_delimiter="default" subdocument_creation_break="yes" notes="Claim information" />
 </xs:appinfo>
</xs:annotation>

<!-- Single -->
<xs:element name="TS837Q3_2300_Loop">
<xs:annotation>
 <xs:appinfo>
   <b:recordInfo structure="delimited" delimiter_type="inherit_record" field_order="infix" count_ignore="yes" child_delimiter="default" notes="Claim information" />
 </xs:appinfo>
</xs:annotation>

One thing that is not documented (at least I could not find it), is that after you downloaded and applied the 5010 hot fix, you need to add the following attribute Split_Without_Sibling_Data to the root <xs:appinfo> element

<!-- Out of the box -->
<xs:appinfo>
 <schemaEditorExtension:schemaInfo namespaceAlias="btsedi" extensionClass="Microsoft.BizTalk.Edi.SchemaEditorExtension.EdiSchemaExtension" standardName="EDI" xmlns:schemaEditorExtension="http://schemas.microsoft.com/BizTalk/2003/SchemaEditorExtensions" />
 <b:schemaInfo subdocument_break="yes" BiztalkServerEditorTool_Version="1.5" root_reference="X12_00401_837_I" displayroot_reference="X12_00401_837_I" version="3.0" standard="EDI" standards_version="00401" xmlns:b="http://schemas.microsoft.com/BizTalk/2003" X12ConditionDesignator_Check="Yes" />
</xs:appinfo>


<!-- After modification -->
<xs:appinfo>
 <schemaEditorExtension:schemaInfo namespaceAlias="btsedi" extensionClass="Microsoft.BizTalk.Edi.SchemaEditorExtension.EdiSchemaExtension" standardName="EDI" xmlns:schemaEditorExtension="http://schemas.microsoft.com/BizTalk/2003/SchemaEditorExtensions" />
 <b:schemaInfo subdocument_break="yes" Split_Without_Sibling_Data="yes" BiztalkServerEditorTool_Version="1.5" root_reference="X12_00401_837_I" displayroot_reference="X12_00401_837_I" version="3.0" standard="EDI" standards_version="00401" xmlns:b="http://schemas.microsoft.com/BizTalk/2003" X12ConditionDesignator_Check="Yes" />
</xs:appinfo>

If you don’t manually modify the schema, you will end up with all of the members in the transaction with one claim in each message that is submitted to the message box. ’Bloated XML’ as a friend of mine calls it.

This means that you are now empowered on how to make changes to the splitting behavior, you can take the subdocument_creation_break attribute and move it from the claim level (2300) and move it to the member level (2000) and BizTalk will split the claims by members with all of that members claims grouped together.

What’s new in TPM for BizTalk Server 2010!!

by | Jun 2, 2010 | BizTalk Community Blogs via Syndication

We are very excited to welcome the public Beta release of BizTalk Server 2010. We have some very interesting enhancements in B2B space in this release. I want to share a brief around the Trading Partner Management feature.

Trading Partner Management(TPM) is increasingly challenging in the exploding global trading economy. A huge heterogeneous mixture of business players are coming in with cost effective options to trade with.

Previous releases of BizTalk provided a functional party management offering that enabled customers to build solutions that needed party management data, but it did come with a few challenges around usability and scalability. To address the growing demand for a scalable TPM, we interviewed a number of customers from different market and sizes and incorporated their valuable feedback. With the new release of BizTalk Server 2010, we have rebuilt the TPM model ground up to meet the tactical and long term needs of the B2B players.

I want to lay out some of the key aspects that are new in TPM for BTS 2010. Detailed blogs would be based on your interest in the specific areas

Functional/Operational

%u00fc Party Model enhanced ground up that would be Business user friendly:

a. Party, Business, Agreement, Protocol Settings: More intuitive model to reflect trading partners, their various businesses, partnerships and agreements between partners. Default Protocol settings to reflect the expectations and abilities of either party getting into an trading partner agreement

b. Inbound, Outbound Settings: Reflective of how business handles inbound messages and sends outbound messages

c. Directional Agreements: Agreements are made two part, one part each for the direction of messages

%u00fc Centralized Business Identities: Identities that are used by the business are centralized without making them protocol-specific. This enhances the productivity as well, as business identities can be set/updated in one place and one time and not repeated across protocol settings

%u00fc Message Type Inclusion/Exclusion: A configurable list of accepted Transaction/Message Types that the business wants to support. Greatly reduces noise of unsupported message types being exchanged and dropped.

%u00fc Productivity around Agreement onboarding:

a. Ability to create protocol settings that are by default expected by a business and reusing them automatically in all agreements created with the business. Ability to override and specific setting as needed in the agreement

b. Ability to save agreements as ’Agreement Templates’ and applying the same across all similar agreements by a click of a button

%u00fc TransactionSet/Payload validation by Message type: No more validation settings at interchange level; now you set validation (’leading trailing spaces, ’extended EDI validation etc) for each message type differently

%u00fc Enhanced Global/FallBack Settings: All the settings possible for an onboarded party can now be set in Fallback settings too(earlier releases didn’t support all settings in Global settings and for some users were forced to use pipeline settings)

Access

%u00fc B2B Operator Role: A new BizTalk role that reduces the onus on the Admins to perform all Party management operations which was also sometimes security risk. The new role allows windows users associated with the role to perform all party management operations.

Upgrade Customers

%u00fc Migration Tool: With all these changes comes a Party Migration tool that helps upgrade customers to easily move from the old PAM based model to the new enhanced TPM of BTS 2010 without having to redo the onboarding of hundreds of parties/agreements

These are the highlights that I wanted to call out and have you all try them out. Any feedback on the feature would be greatly appreciated.

Hoping that the feature excites you as much as it excites me, and looking forward to a great success!!

Until next time

Ravi

*TechEd Alert*

I will be presenting a session at TechEd 2010 North America on this TPM feature with a demo. If you want to see how it really works and hear the story of how this feature got build, do visit the session at TechEd on 9th June (ASI 304: Building Large B2B Integration Solutions on Microsoft BizTalk Server 2010). See you folks there!!!