Matias Woloski’s Blog

I’m inaugurating this new section about this exciting concept
“Software as a Service”.

Diego Dagum, DPE Architect for Microsoft Chile,
interviewed Gianpaolo Carraro, who manages the Architecture Strategy group at
Microsoft. Gianpaolo is passionate about SaaS and together with Fred Chong they plan
to deliver guidance about different aspects of SaaS architectures. 

It’s in Spanish, but you can translate
it

Chris Holmes, an active member of the CAB messageboards, blogged about
how to create an outlook bar and the corresponding CAB classes. Here you have a snapshot:

You can register the Outlook Bar…


OutlookBar outlookBar = RootWorkItem.Items.AddNew<OutlookBar>();

RootWorkItem.UIExtensionSites.RegisterSite("OutlookBar", outlookBar);

Then you can add/remove buttons to the bar…


Button button = new Button();

button.Text = "Payroll";

button.Image = MyProject.Modules.Payroll.Properties.Resources.payroll;

RootWorkItem.UIExtensionSites["OutlookBar"].Add

(button);

RootWorkItem.Commands["LoadPayrollWorkItem"].AddInvoker(button, "Click");

…and smartparts as well.


SomeSmartPart smartPart = this.Items.AddNew("OutlookBarSmartPart");

RootWorkItem.Workspaces["OutlookBarDeckWorkspace"].Show(smartPart);

Finally, another way to design this control is by creating a
custom IWorkspace that accepts a smartpart and a smartpartinfo that
holds the button information so you can do something like this:

OutlookBarSmartPartInfo info = new OutlookBarSmartPartInfo();

info.Text = "Payroll";

info.Image = MyProject.Modules.Payroll.Properties.Resources.payroll;

RootWorkItem.Workspaces["OutlookBar"].Show(smartPart, info);

Don Smith started a series of blogcasts where he is showing some of the Service Factory functionality. As usual this is very good stuff and very developer-friendly.

One of the benefits of CAB is the abstraction it provides regarding the undetlying toolkit. I’ve blogged about the Command, UIElements and Workspace subsystem before.

The Infragistics guys implemented this layer for their toolkit.
DevExpress is another toolkit but they haven’t invested in providing the CAB layer yet. Some people in the CAB messageboards asked about this.
I offered my help and recommended them to open a workspace in
gotdotnet. Vincent from France created the gotdotnet workspace and we
havenow 8 members willing to help building this.

If you are interested as well please join us

On Augus 22nd. 2005 I left a comment in Kenny’s Wolf blog:

    [on writing custom channels]
    “…I think there should be more documentation and examples regarding the
different interfaces provided (IOutputChannel, IRequestChannel,
IReplyChannel, etc). I didn’t know which one I would need in my
bindingelement.”

9 months later…

    Resources for Custom Channel Authors:
    http://windowscommunication.net/customchannels/customchannels.htm

This is the place to go if you ever want to take WCF to the limit by writing a custom channel
On a side note, I must admit these guys created a master piece of
software. WCF is the most extensible thing I ever seen in my life.

The first public drop of Service Factory is available on the workspace.

Download it and give feedback on the message boards! If you want to
keep updated with this project, here you have a list of Service Factory
bloggers:

• Don Smith
• Jason Hogg
• Tom Hollander
• Pablo Galiano
• Pablo Cibraro
• Christian Weyer
• Edward Bakker
• Beat Schwegler
• Matias Woloski

I will post more about this exciting project in the next weeks.

Last week Roberto Schatz, DPE Architect, and Ramiro Iturregui, ISV Developer, organized an
Architects meeting at Microsoft,
Argentina. Eugenio Pace, Product Manager for patterns & practices, and me,
talked about many exciting things including:

• The
  current status of the patterns
  & practices group. Patterns
  & practices won’t be an isolated group anymore; they will be part of a
  product team that will enroll Visual Studio Team System, p&p and MSF
  together.
• What
  patterns & practices been working on? In the UX area CAB was broadly
  adopted and now the SCBAT
  (Smart Client Baseline Architecture Toolkit) is what the developer needs to
  create a Smart Client application. Including guidance right into Visual
  Studio 2005 using GAT (right-click
  -> Add Cab Module, etc), documentation, hands on labs, and two
  reference implementations showing how to manage offline scenarios,
  multiple modules, role-based UI, among other things.
• There
  is news also in the services area (everything that goes from the proxy to
  the database). The SVCBAT (Service BAT) now renamed to Web
  Service Software Factory, has been launched and the first
  drop is available. I encourage you to download it and give feedback
  about your needs in this space.

 Finally, we did some Q&A and gathered some feedback. There
were interesting questions about the past, the present and the future of p&p
deliverables. Thankfully, some attractive croissants entered the room because I
was starving already. J

Angel Lopez who was there and blogged
about it

I’ve been concerned about the relationship between ClickOnce and WCF. Lot of buzz has been generated regarding partial-trust scenario not being supported for WCF v1. I see this as something desirable, but it is not the end of the world

I’ve written a Smart Client application that leverage WCF.  I wanted to deploy it so I choose ClickOnce. ClickOnce supports installing prerequisites as part of the whole process, so I downloaded WinFx and include it as part of the installation. If you are insterested in how to do this, keep reading.

WCF is part of
the WinFX Runtime Components, which is currently in Beta 2 (Feb CTP). The installation of this runtime requires
Admin privileges and the size of the Redistributable package is 45.3 MB.
These are the alternatives to distribute it on client desktops:

• Install
  WinFx manually on each desktop
• Use SMS
  to distribute WinFx
• Include
  WinFx as part of the prerequisites of the ClickOnce application
• Distrubute
  an MSI which includes WinFx

I was interested in the 3rd option, so let’s analyze it further

Include WinFx as part of the prerequisites of the
ClickOnce application

ClickOnce has a feature that allows including the
prerequisites of the application to be deployed. When the application is published
it creates a setup bootstraper that will download and install all the
prerequisites (if they were not installed yet) before the ClickOnce application
is executed. This way the deployment will be more controlled as it will be a
single package.

The user executing the setup bootstraper must have
Admin
privileges. If the user logged does not have Admin privileges, an
option would
be to execute Internet Explorer with “Run As…” and login with a local
administrator account. This will at least install the prerequisites and
also the application in the Administrator profile. Later you would need
to open a new IE instance and launch the app again from the currently
logged user.

The following sequence illustrates the install of

prerequisites (.Net Framework 2.0 and WinFx Beta 2)

<!–[if !vml]–>

Figure 1. Prerequisites of the
application listed in the Publish ClickOnce html file

Figure 2. Pressing
Install will launch the bootstrapper that detects the uninstalled
prerequisites: Net Framework 2.0 and WinFx Runtime Components Beta 2

 
Figure 3. The setup downloads the prerequisites from a specific location

<!–[if !vml]–><!–[endif]–>

Figure 4. After
downloading, the setup will install the WinFx Runtime Components

Using WCF on your application requires more
CAS permissions (FullTrust)

In many real scenarios, developers need their applications
to run as a Partial Trust Application, but need more permissions. For example,
you may need to use a SQL Client. To solve this kind of problems, ClickOnce introduces a feature called Permission
Elevation, which allows an application without enough permissions to
request them to the user. If the user accepts, then the needed permissions are
granted and the application can run normally. This could goes up till
FullTrust which is the requirement for WCF. Besides, in scenarios in which users should not make these kinds of
decisions, a practical solution is offered: system administrators can sign the
application manifests or set a deployment policy that specifies that a
publisher is a trusted source. This way, permissions will automatically be
granted before the application loads.

Figure 5. Installing the application and permission elevation

Creating the prerequisites

WinFx does not come as a prerequisite in the
Visual Studio 2005 Publish tab. However, we can create our own
prerequisite with any MSI or EXE installation.

The process to do this is:

1. Create a new folder called "WinFx" here %Program Files%\Microsoft Visual Studio 8\SDK\v2.0\BootStrapper\Packages
2. Use the Bootstrapper Manifest Generator to create the manifest for WinFx. I’ve created it already for WinFx.
3. Copy the manifest to %Program Files%\Microsoft Visual Studio 8\SDK\v2.0\BootStrapper\Packages\WinFx
4. Copy the WinFx Runtime Components redistributable to the same folder
5. Restart Visual Studio 2005

More resources

• Adding
  Custom Prerequisites:  http://msdn2.microsoft.com/en-us/library/ms165429.aspx
• How
  to: Install Prerequisites with a ClickOnce Application: http://msdn2.microsoft.com/en-us/library/8st7th1x.aspx
• Brian Noyes ClickOnce article, http://msdn.microsoft.com/msdnmag/issues/04/05/clickonce/default.aspx
• Security
  Considerations for ClickOnce Deployments: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dv_vstechart/html/ClickOnceSec.asp
• ClickOnce
  Deployment and Security: http://msdn2.microsoft.com/en-us/library/76e4d2xw.aspx

Don Smith announced today that Service BAT Service Factory is finally a public project. I’ve been part of this project since the beginning of the year and I can tell you that I’m pretty excited about it. Jason Hogg said that this were going to change the way we develop SO applications.

This is a great moment for people writing Service Oriented apps using Microsoft technologies!

First, if you are not aware of patterns & practices latest
activities, let me tell you that they’ve been creating BATs, Baseline
Architecture Toolkits, which are more than App Blocks. They cover the
whole thing! The first one was the SC-BAT (for Smart Client apps using CAB) which was more than successful. So here is the definition:

 What is a BAT? A BAT is a collection of various forms of guidance (written
guidance like patterns, reusable code like application blocks,
executable code like reference implementations, and guidance packages
embedded in Visual Studio) to help .NET developers and architects build
a certain kind of application.

What is the scope of Service BAT Service Factory? In short, from the proxy to the database.

Join this project if you want to

• Write Service Oriented apps using WCF or ASMX
• Leverage the best practices and the experience of a 50 recognized experts in the
  field (the advisor board) and a group of Redmond brainees
• Automate the menial tasks of creating a Service by leveraging the use of GAT
• If you were looking for the Grail on writing backends for Enterprise Applications
• Solve most of the cross-cutting concerns (Exception Shielding, Logging, Versioning, Security, Data Entitlement, and more)
• Align to WCF
• Have great tooling for WCF

See you there!

UPDATE: want to see some early screenshots? look at Edward Bakker post. Christian Weyer also blogged about it.

UPDATE 2: Service BAT was rebranded. Now it’s Web Service Software Factory.

Lately, I’ve been wondering about the strength of ClickOnce
applied in enterprise applications. In these scenarios, the deployment of a
Smart Client application involves more than a simple XCOPY. Let’s enumerate
some of them:

• multiple environments (dev,
  qa, staging, production)
• prerequisites
• CAS permissions
• run as non-admin
• pre and post-deployment
  tasks
• partial deploys (only a set
  of modules)
• rollbacks
• segmented deploy (e.g. only
  deploy a beta testers group)
• versioning

The truth is that ClickOnce has been designed with some of
these things in mind out of the box but not all of them. Fortunately the ClickOnce
world does not finish in the “Visual Studio 2005 Publish tab”.  We have MSBuild
tasks,
mage.exe
and mageui.exe
to overcome the advanced scenarios.
A great
sample showing the advanced features has been written by Mike Bouck.

Based on this and my previous post about dynamic
modules, I’m planning to write a sample consisting of a CAB application leveraging ClickOnce
and CAB Module Loader to download
modules on-demand and load them dynamically.