“Unplugged” online talk with me this Friday

by community-syndication | Nov 16, 2010 | BizTalk Community Blogs via Syndication

(Not) Using Built-in Service Accounts for BizTalk Server

by community-syndication | Nov 15, 2010 | BizTalk Community Blogs via Syndication

Recently I tried installing BizTalk Server 2010 in a pretty locked down environment – as in no accounts except a few domain accounts were given the “log on as a service” right. Thus as a first go I was left trying to use the default accounts on the machine.

These are my short summarized findings trying to run BizTalk using built-in accounts:

• SQL Server – Can run as Local System or Network Service. NOT as Local Service.
• SQL Server Agent – Can run as Local System or Network Service. NOT as Local Service.
• For more SQL Server account info see this link.
• The SSO service – can NOT run as Local Service or as Local System.

  It can run as Network Service, although there are some special requirements – namely: the SSO Administrators group must be pre-created, the Network Service account added to it and the computer restarted.

• BizTalk Server Runtime – Can NOT run as a any form of local built-in account.
• At this point I guess I could have gone on to try the other sub-services as well, like BRE, but why bother Lesson learned. You cannot configure BizTalk Server using only the built-in accounts. Also this link from the BizTalk documentation clearly states that these accounts are not supported, though it is non-specific.

Quoted info on what these built-in accounts mean:

BTUG meeting 2 december: BizTalk 2010

by community-syndication | Nov 15, 2010 | BizTalk Community Blogs via Syndication

Op 2 december a.s. geef ik samen met Steef-Jan Wiggers een presentatie over BizTalk Server 2010. Wil je weten wat er allemaal nieuw is in BizTalk 2010 kom dan naar de BTUG meeting op 2 december. Naast onze presenatie zijn er nog twee andere presentaties: – BizTalk 2010 en Trading Partner Management  (Richard Sargeant) – […]

TechEd Europe 2010

by community-syndication | Nov 15, 2010 | BizTalk Community Blogs via Syndication

Back from TechEd in Berlin, a great week with great technology. I focused my interests around Architecture, Azure, AppFabric (hosting WF/WCF) and BizTalk, but the talks that I liked the most were in other technologies, such as PowerPivot (amazing session by Rafal Lukawiecki., where he opened an Excel file with 101 million rows while using around 200 Megs of  RAM), Umbraco (a surprisingly interesting Open Source CMS) and oData (feed-based info distribution and management). Also attended varied sessions on “LiveLabs” Pivot (now Silverlight PivotViewer)), Office 365 (very, very promising, but what about access to the beta??), Agile Project Management, HTML5, and others. And still found the time to do some Hands-On-Labs. 🙂

I did not attend TechEd last year, and this was a most refreshing return.

You can download several session videos from TechEd Online.

Review: Applied Architecture Patterns on the Microsoft Platform

by community-syndication | Nov 15, 2010 | BizTalk Community Blogs via Syndication

  Recently the book ’Applied Architecture Patterns on the Microsoft Platform’ was released. The book is written by Richard Seroter, Stephen Thomas, Ewan Fairweather, Mike Sexton and Rama Ramani. Yossi Dahan is the technical reviewer. The book is published by Packt Publishing. Shortly before the book was released, an event was held in Stockholm, Sweden. […]

SoCal Codecamp Jan 28 and 29

by community-syndication | Nov 13, 2010 | BizTalk Community Blogs via Syndication

The call for sessions is now open for SoCal Codecamp IV. If you’ve never been to one, Codecamp is a great way to see sessions from the community, for free. Have an idea or a session you’d like to present? Submit it! Want to go? Visit SoCalCodeCamp.com to register.

I missed the last one, and felt guilty about it, so I just submitted the sessions below. Hope to see you there!

Windows Azure Overview

Cloud technologies are transformational, and one of those rare paradigm shifts that we don’t see often. The Windows Azure platform represents a tremendous investment by Microsoft, one that developers can benefit from today. Some of the results of those investments are live today, and you can use them to enable solutions that previously would have been impossible or prohibitively expensive to create. This session will provide an overview of Microsoft’s Windows Azure cloud platform, both the present offering as well as a roadmap of what’s ahead.

Windows Azure Architectural Patterns

Microsoft’s Windows Azure cloud platform is a full Platform-as-a-Service offering, and is much, MUCH more than “Hosting Version 2.0”. Yes, you could do things the way you always have, but as an architect or developer on the Windows Azure platform there are some exciting new architectural patterns that enable the next generation of software. As an architect evangelist on the Microsoft Azure ISV team, I see new patterns regularly. The key takeaway from this session is “question everything”, come and see why.

Windows Azure: what’s in it for an ISV?

Are you currently an Independent Software Vendor, or do you think you have an idea that could be the next Twitter or Facebook? Are you a startup, or would you like to be? As an architect evangelist on the Microsoft Azure ISV team, I get to help people and companies realize their dreams of becoming an ISV, or evolving to the cloud. In this session, we will cover the capabilities and architectural patterns that make the Windows Azure platform so attractive to ISVs, and how it enables possibilities (applications, services, business models) that could not have been done otherwise.

ASP.NET MVC 3: Server-Side Comments with Razor

by community-syndication | Nov 12, 2010 | BizTalk Community Blogs via Syndication

Simplified Asynchronous Programming Model in WCF with async/await

by community-syndication | Nov 12, 2010 | BizTalk Community Blogs via Syndication

Managing multiple asynchronous operations in WCF is currently very complex regardless of whether you use the existing event or Begin/End asynchronous patterns. In fact, both internal and external customers frequently ask about how to implement simple coordination of WCF operations, and even though sending multiple requests to a WCF backend is a core scenario, WCF does not provide a satisfactory solution. The amount of code needed to facilitate even simple coordination tasks is large and prone to bugs, handling errors and timeouts. Yet there are some very common communication-oriented scenarios that require managing multiple outstanding asynchronous operations:

• Execute multiple async operations in parallel and continue when they are all done, either successfully, failed, or timed out.
• Execute sequence of asynchronous operations, stopping if one of the operations fails or times out.
• Nest multiple asynchronous operations.
• Combine asynchronous operations with timers for easy polling at regular intervals.

However, regardless of the current complexity, WCF developers have to use asynchronous requests to write robust implementations, and doing that today is a difficult challenge.

During PDC’10, the C# and VB languages teams released the Visual Studio Async CTP, which aims at providing a new simplified model for doing asynchronous programming in both languages. In WCF, we have decided to adopt this model because we believe it removes the barrier to writing WCF robust asynchronous application, has the least possible learning curve from the existing CLR APM pattern, and provides a simple and consistent model for coordinating, submitting and managing multiple asynchronous WCF operations.

WCF vNext will adopt the Async model in both the client and the server side, and provide new Task-based overloads for some of the most used asynchronous APIs:

Server Side

WCF service developers will be able to define asynchronous operation contracts that return Task/Task<T>:

[ServiceContract]
public interface IServiceContract
{
    [OperationContract]
    Task<string> Hello(string name);
}

In the service contract implementation, WCF service developers will be able to implement that operation contract as an async method, and create/start new tasks, etc.:

namespace WCFServiceModelSamples
{
    public class HelloService : IServiceContract
    {
        public async Task<string> Hello(string name)
        {
            return await Task.Factory.StartNew(() => "hello " + name);
        }
    }
}

There is no need to explicitly implement any Begin/End method, IAsyncResult objects or any type of callback. Internally, WCF will add an operation invoker to the dispatcher that will be able to process Task-based operations, which will make all work transparently to the user.

Client side

The support for generating Task-based operations on the client side will be available to users who rely on proxies generated by our client generation tools (svcutil.exe or Add Service Reference), as well as to users who prefer to directly use ChannelFactory<T>.

The client proxy generation tools will generate Task-based overloads for all operations in the contract by default. This means that WCF client application developers will not need to switch any new knob in the tools to be able to use this model. But they will always be able to opt-out with the /syncOnly switch if they wish. The output of executing ’svcutil.exe /async’ will still generate Begin/End methods, as it does today. WCF users should not experience any breaking change in their code. Finally, it is worth mentioning that WCF developers will be able to generate Task-based overloads as well by using ServiceContractGenerator.

From the implementation side, the support for executing Tasks will be implemented directly in the channel, which makes the generated client proxy code look as clean as this:

public partial class HelloServiceClient : ClientBase<IServiceContract>,
                                          IServiceContract {
    public System.Threading.Tasks.Task<string> GetDataAsync(int value) {
        return base.Channel.GetDataAsync(value);
    }
    ...
} 

Finally, a code snippet for a WCF client application calling asynchronously the WCF service defined above will look like the following:

namespace MyAsyncApplication
{
    class AsyncClientApp
    {
        static void Main(string[] args)
        {
            string[] names = { "dan", "john", "tarae" };

            PrintOutNames(names)
                .ContinueWith(delegate { Console.WriteLine("Done."); });

            Console.WriteLine("Hit ENTER to exit.\n");
            Console.ReadLine();
        }

        static async Task PrintOutNames(string[] names)
        {
            foreach (string name in names)
            {
                try
                {
                    Task<string> task = new HelloServiceClient().Hello(name);
                    if (task == await Task.WhenAny(task, Task.Delay(1000)))
                    {
                        Console.WriteLine(await task);
                    }
                    else Console.WriteLine("Timed out");
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
            }
        }
    }
}

New Task-based public APIs

Even though WCF developers will be able to add their own Task-based wrappers for existing asynchronous APIs based on the Begin/End model via Task.Factory.FromAsync, WCF will provide Task-based overloads for some of the main asynchronous public APIs. In particular, for those in the MEX and Discovery client, for consistency with the tools-generated clients:

• System.ServiceModel.Description.MetadataExchangeClient.BeginGetMetadataAsync
• System.ServiceModel.Discovery.AnnouncementClient.BeginAnnounceOnlineAsync
• System.ServiceModel.Discovery.AnnouncementClient.BeginAnnounceOfflineAsync
• System.ServiceModel.Discovery.DiscoveryClient.FindTaskAsync
• System.ServiceModel.Discovery.DiscoveryClient.ResolveTaskAsync

That’s all folks! Feedback is always encouraged. Please let us know what you think about this new programming model in WCF. Welcome to the new asynchronous programming world!

Amadeo Casas Cuadrado

Program Manager, WCF

Data Driven Unit Test – Excel DSN Error

by community-syndication | Nov 12, 2010 | BizTalk Community Blogs via Syndication

Just a little quick one for myself….

When running some data driven unit tests we were getting the below error.

Unit Test Adapter threw exception: System.Data.Odbc.OdbcException: ERROR [IM002] [Microsoft][ODBC Driver Manager] Data source name not found and no default driver specified.

The cause of this was that we had rebuild the machines and somehow when installing office the DSN for Excel hadnt been created. On all of the other machines it had been setup fine but for some reason on my machine it hadnt been setup.

The fix was to create a DSN called Excel Files pointing to excel driversand then just rerun the unit tests.

As a reminder the test attributes for this were below:

[TestMethod][DeploymentItem(@”..\..\..\mappings.xlsx”)]

[DataSource(“System.Data.Odbc”, “Dsn=Excel Files;dbq=|DataDirectory|\\spreadsheet.xlsx”, “worksheet1$”, DataAccessMethod.Sequential)]