Jack Gudenkauf (JackG) WebLog : Visual Studio

"Lost" and found

JackG — Fri, 27 Mar 2009 20:46:00 GMT

Where have you been? Assuming I haven’t lost all my readers by now, due to my silence, this seems to be a reasonable question.

Does anyone out there watch “Lost”? I ended up getting hooked in the beginning and now I can’t avert my eyes.

As I wrote this blog, I felt the “Lost” series seemed to be analogous on a few dimensions ;-) The story line seems to do this Present, Past, Present (and now Future) transition. The show seems to be popular enough, so why not use the theme.

The Present

· Beginning in December 2008 (a few months ago), I was fortunate enough to land one of the best jobs I have ever had (and hope to have/retain – scary times we live in).

· I am now back in a managerial role as the Group Manager for the Technical Strategy Engineering team reporting to the office of the CTO. The SVP CTO, David Vaskevitch, has quite a distinguished career spanning the creation of MCS (i.e., Microsoft Consulting Services) to building many teams in SQL (e.g., MTS, COM+,..) and I believe he was also Bill Gate’s first TA. At this juncture, I have had only one meeting with David, but I was impressed on many levels. David reports through Ray Ozzie, who is the Chief Software Architect, and is someone that most people think of, as the “new” Bill Gates.

· My new role is typically called a Product Unit Manager. I have a team of Program Managers, Developers, and Testers. More on my new role later. Remember the “Lost” analogy.

The Past

· First I would like to apologize for my absence in the blogosphere but I was busy wrapping things up on the CLR team wrt Extensibility and the System.AddIn BCL.

· I suppose I could have started from my last blog post in time, but I think I’ll back up a bit in order to give a little context and some insight into my life’s journey and how my blog reflects that journey. Zen has returned to my life J. Side note – highly recommended reading: Zen in the martial Arts, a great concise book with pearls of wisdom I use often in my life and career.

· As I decided to try this blogging thing years ago, I was looking for a theme, a subject, something with continuity. I first started with “Smart Client”, then everything .Net. I wrote about Tools, Extensibility, Add-in’s, Versioning, etc..

o OK, so I have finally realized what my blog is really about. Drum roll please - And it is…. This is where a “Lost” episode would end. Keeping you in suspense. Oh, and there would be some hard pounding beat of music as well – dunt, dunt, da.

· Maybe it’s with maturity, experience, time, age (arg, age) that I finally realized as of this writing that my blog is about my career and life’s journey. I guess in some respects it is a journal or diary of sorts. I often wondered why anyone would care what I’m doing or have done, but I think there is value in sharing ones experiences so that others may (?) benefit. I’m still not sure about that Twitter or Facebook thing though. But I didn’t get blogging in the beginning either. Sure, I understand the Social Networking value, but honestly, who would care what I’m doing right now. <tweet> I’m on a plane coming back from London after visiting MS Research in Cambridge (cool stuff) and I’m writing a blog post </tweet>.

· As evidenced by my time as an Architect on the CLR team (i.e., .Net framework, Common Language Runtime, BCL – Base Class Libraries) I was pretty focused on the difficult Computer Science problems of; Extensibility, Versioning, Isolation, reliability, Security, etc.. And thus my blog posts reflected this period and passion for helping customers (i.e., primarily ISV/VAR/SI) who wrestle with these issues. It was a very challenging set of subject areas that I pursued, beginning when I was the Group Development Manager for the Visual Studio for Office/Applications group.

· So what brought me to the CLR team? Inquiring minds want to know. And that’s how that whole “Lost” thing works – Pieces parts you need to tie together. When I decided I was ready to leave the VSTO/A product unit I began looking around the company for challenging opportunities. In one my interviews with the SQL team, I spoke with a wise (now retired) man who asked what I believe in. Aside from my religious beliefs, I said “I always ask myself, what can I do to make our customers lives easier and what can I do to have the greatest impact for Microsoft.” Of which he replied, “so what are you doing about that?” Damn, those wise people (Zen). They get right to it, don’t they. Bring me a problem *and* a solution. As I discussed my recent work on trying to resolve these hard CS problems I mentioned I felt compelled to drive them to some level of conclusion for our customers but it was clear that the solution and current VSTA implementation needed to be available to a customer base beyond the VSTO/A products. He agreed 100% and said this was one of the biggest .Net issues and concerns for SQL (relative to .Net). He then told me I had an obligation to Microsoft and our customers to drive this effort. He told me I needed to speak with David Treadwell, the then VP of the CLR, in order to transfer this charter to their team. Right, I’ll just phone up a VP! Well, to make a long story short, that’s what I did. David was very approachable and along with moving over the charter, I also moved from a managerial role on VSTO/A to an Architect role in the Program Management discipline on the CLR team. To be clear, it took more than a phone call J

Recent Past

One of the benefits of working for Microsoft is the breadth of opportunities available within the company. To be clear, internal hiring/recruiting is pretty much treated the same as external hiring. That is, you might think your experience within the company would stand on its own, but you still have to apply for the job, go through several interviews for each job, just as though you were new to the company. After all, you’re new to the new team. I think it’s important to know this, as I often get questions about what it’s like working for Microsoft (everyone says I should write a book). To give you as sense of what it’s like, I can tell you that I had somewhere in the neighborhood of ~40 interviews for various jobs during my last/recent search. And around 9 interviews for my current job. These interviews ranged the gambit of the old, “What is your greatest strength” to “write me a doubly linked list at the whiteboard”

Ok, I’m sorry, but I have to go off on a tangent here - For crying out loud, aside from writing a linked list in school, who has ever had to write one since graduating? If you can’t explain the importance of data structures then there is a reasonable concern. But, I have forgotten more than most will learn in their careers. No, I’m not any smarter, I am just seasoned, mature, experienced. Ok, ok, I’ve been around a long time ;-) </rant>.

But I digress.

Where was I?

Right. I was searching for a job when I decided to leave the CLR team.

A season ending episode.

Time Sequence (Season recap)

Ok, so “Lost” periodically brings together the time line, so let’s do that before we lose our sanity.

1. Jack moves from the Development Manager of the MSN platform team to VSTO/A.

2. Jack was Group Dev. Manager of VSTO/A when he decided to start blogging.

3. Aside from the VSTO/A products, he discovered the need for .Net versioning, Isolation, etc..

4. He drives moving the VSTA extensibility technology/charter to the CLR team and moves over to the CLR team as an Architect working with ISV’s on the Add-In model.

5. Blogs a lot about the subject.

6. Then moves to the Technical Strategy Group.

Hey, wait a minute! What happened to the System.AddIn stuff you left behind?

· This whole “Lost” theme gets confusing doesn’t it? Definitely the last time I use it. Or is it? I think the “Lost” writers make it up as they go along.

· So what happened to all the ISV and Add-In work we heard so much about? What are you actually doing now?

o Stay tuned J

RTM of Visual Studio 2008 and .NET Framework 3.5 SP1 (Client App Deployment)

JackG — Mon, 11 Aug 2008 21:15:00 GMT

I wanted to thank all the ISV's, VAR's, and SI's I have spoken with and those who have replied to my requests for soliciting feedback on Client Application Development (e.g., Software as a Service (SaaS) and Rich Internet Applications (RIA)).

This release has a number of significant features and bug fixes.

The RTM announcement may be found here.

Here is a direct link to the Microsoft .Net Framework 3.5 SP1.

Here is a link to Scott Guthrie's blog discussing this release when it was in Beta.

I'm very happy to inform you that your feedback played a significant role in this release, which includes -

"New Breakthroughs for Developing and Deploying Client Applications

The .NET Framework 3.5 SP1 includes the new .NET Framework Client Profile -- the fastest and easiest way to deploy applications for Windows. With .NET Framework 3.5 SP1 and the .NET Framework Client Profile, developers can more easily deploy client applications thanks to an 86.5 percent reduction (197 MB to 26.5 MB) in .NET Framework size. This means that end users will be able to download and install Windows-based applications significantly faster than before. The .NET Framework Client Profile also makes it possible to extend the improved download and installation experience to existing .NET applications.

Developers now can quickly and simply deploy new and existing rich-client applications to a broader audience."

Configuring Visual Studio to Debug .NET Framework Source Code

JackG — Mon, 12 May 2008 21:42:00 GMT

Earlier I posted a link to the announcement on ScottGu's blog about the framework source availiability for debugging. I wanted to follow-up with my experience using the reference source.

I found the installation instructions on "Configuring Visual Studio to Debug .NET Framework Source Code" on Shawn Burke's blog. I assume there is some official MS site for these instructions but I didn't look very hard. If anyone knows the link please let us know. The installation worked great on my Vista laptop with VS 2008. I did notice that much of the Orcas (i.e., 3.5) BCL has yet to be published. Unfortunately this includes the Managed AddIn Framework (MAF, System.AddIn*) source. I am following up on the Orcas release and I will let you know when it gets published. Enjoy! JackG

Visual Studio 2008 and .NET Framework 3.5 RTM

JackG — Mon, 19 Nov 2007 21:38:00 GMT

It's official. We have released to manufacturing.

I am personaly very excited about the Add-in addtions to the BCL, but you can also find over 250 new features in this release (e.g., LINQ). Check out the new release here.

.Net 3.5 for ISV’s, Channel 9 video

JackG — Tue, 09 Oct 2007 23:05:00 GMT

We have modified the Soapbox video by moving the WPF on BCL Add-in model demo to the start of the video and we have posted this updated video to Channel 9. The video will also be on the Channel 9 home page for a while.

From James, “Several weeks back James Vastbinder was able to coax Jack Gudenkauf into doing an interview on .NET 3.5 targeted at ISVs. Jack is an Architect on the Base Class Library team and tasked to work with Microsoft’s ISV Partners.

In this interview:

· Jack talks about the BCL team and how they work within the larger Server and Tools business unit.

· An inside view of the new Add-In Model in 3.5, (Its Jack's baby and he's rightly proud).

· The Process ISV should mentally walk through when moving to managed code.

Tools and utilities used by the CLR team.”

What’s new in the .Net Framework 3.5 (Orcas)

JackG — Thu, 13 Sep 2007 21:26:00 GMT

Visual Studio (VS) 2008 and .Net 3.5, code named “Orcas”, will be released in the near future. This release includes a number of new features and bug fixes. The release includes new major features such as LINQ, Cider (The VS WPF designer), “Crossbow” (WPF and WinForms interoperability), and my personal favorite, the Managed Add-in Framework, etc…

In the past, I outlined, provided sample code, and did some presentations on what’s new in 2.0. Given the pending Orcas release and following my 9/12/07 presentation to ~78 ISV and enterprise partners on what’s new in Orcas, I wanted to share the content I presented. Thanks to all the attendees for your feedback. It is always a pleasure speaking with our customers.

BCL Additions or enhancements

· System.TimeZoneInfo

· System.DateTimeOffset

· System.Collections.Generic.HashSet

· System.IO.Pipes

· EventSchemaTraceListener

· Event Tracing for Windows Vista (ETW)

· System.Threading.ReaderWriterLockSlim

Garbage Collector (GC)

· Overview

· System.Runtime.GCSettings.LatencyMode

· System.GC.Collect(int generation, System.GCCollectionMode mode)

CLR Security

· Support for “Suite B” crypto algorithms on Vista

o Elliptic Curve Diffie Hellman for key exchange (ECDiffieHellmanCng class)

o Elliptic Curve Digital Signature Algorithm for signing (ECDsaCng class)

o FIPS certified Advanced Encryption Standard (AES) for symmetric encryption (AesCryptoServiceProvider class)

o FIPS certified SHA2 for cryptographic hashing (SHA256Cng or SHA256CryptoServiceProvider classes)

· Support for the trusted publisher list for managed controls in the browser

o Enables a simple elevation model for controls in the browser

· New opt-in reflection security model

o Apps can reflect on the private members of libraries at the same or lower trust level. Useful for script engine scenarios

Extensibility (aka., Add-in’s, Add-on’s, Plug-in’s, Component models, …)

· System.AddIn*

o For those who offer, or wish to offer, application extensibility, the CLR now offers a robust solution with a number of features including; Discovery, Activation, Isolation, Unloadability, Sandboxing, Lifetime management, and WPF support.

CLR ThreadPool

o We invested significant development resources improving the managed implementation to be as close to native socket scaling/perf.

o Most of the code is now in managed code, eliminating unnecessary VM transitions

Misc

· MSDN Article on CLR enhancements

· Add-In team Blog

· BCL Team blog

Is he getting on his Soapbox again?

JackG — Thu, 16 Aug 2007 20:17:00 GMT

Last year, I did a webcast when I was attending an SI (Solution/System Integrator) Architect conference in Paris. Ah, Paris in the spring, love the Champs-Elysees and the Aviation club in particular.

The webcast was done as part of an ISV webcast series. I blogged about this webcast previously but I received a number of questions about the need to “sign up” in order to watch the webcast, as well as the long delay (~4minutes) of wasted time in the beginning of the webcast (Setup and polling questions). I have removed the beginning of the webcast and uploaded the edited webcast to the Soapbox server. You no longer need to “sign up” to view the video.

Sorry about the interactive PowerPoint issue. The recording software only shows the final built slide. As a result, I have uploaded the PowerPoint slides.

ISV Insight into the CLR Add-In Model

The webcast content was targeted at the WinFx Add-in model which were the core libraries of System.AddIn* that shipped in Whidbey, prior to the CLR BCL implementation now in Orcas.

I also talk a lot about the VSTA implementation of MAF. For FAQ’s on VSTA and the CLR Add-in implementations, check out these links; FAQ’s: WinFX Add-in model and Visual Studio Tools for Applications, (VSTA) Add-In’s (CLR and VSTA).

Lights, Camera, Action!

JackG — Thu, 16 Aug 2007 01:08:00 GMT

Another Paris Hilton, Pam Anderson, Lindsay Lohan, Britney Spears, or Political video?

Nope, Sorry. All business on this site.

I was recently interviewed by James Vastbinder, an ISV Platform Strategy Advisor for Microsoft.

We discussed the needs of ISV’s and what’s new in the pending Orcas release (i.e., CLR v3.5 and Visual Studio 2008 v9.0).

Video Title: Jack Gudenkauf on the BCL and Add-ins

In this interview, Jack talks about the BCL, CLR, and Add-Ins. See what's new in .NET 3.5 for the CLR.

To watch this video, click here.

For more on our CLR Add-in Forms support, check out this link.

We saved the best for last!

JackG — Fri, 27 Jul 2007 23:03:00 GMT

VS 2008 and .Net 3.5 Beta 2 (code name "Orcas") is now available.

Here is the link to download.

I am extremely excited about this release due to a number of features that I have been passionately advocating on behalf of the customer for several years.

For all those customers who have been asking for the ability to allow an application to Host WPF Add-In’s – It is now in the Beta2 release!!!

I will be posting a link to a web video I did showing the new isolatable (i.e., Cross AppDomain) WPF functionality built upon the Orcas Add-In model. That’s right, UI extensibility on MAF!

You can read about this new feature, as well as a few more highly requested Add-In features, now available in 3.5 Beta2, on this CLR Add-In blog post.

It’s a great time to be an ISV developer, as well as a developer that extends ISV applications.

Add-In’s (CLR and VSTA)

JackG — Wed, 14 Mar 2007 21:18:00 GMT

We have gone through some naming changes with WinFX and .Net. And we have gone through a few on the MAF (Managed AddIn Framework), the WinFX AddIn model and System.AddIn. The previous are all terms we use to discuss the Add-In model in the broad sense. I admit, with my carpel tunnel, MAF is a lot easier to type. So think of them all as the same thing.

That said, MAF has been a source of some confusion since the release of the Orcas CLR implementation. I am frequently asked if this is the same thing as the VSTA product or VSTA SDK offering. The answer is Yes and No J First let’s separate the MAF technology from the VSTA product - I previously posted some answers to questions on MAF vs. the VSTA product.

Now let’s answer the question of whether the CLR implementation of MAF is the same as the VSTA products implementation of MAF. The answer is Yes and No J You knew that was coming ;-)

Yes, they both base their implementation on the core fundamental component called a contract.

They both prescribe and adhere to the separation of integration and implementation, based on the contract and thus provide isolation, unloadability and version resilience.

So what’s the diff?

VSTA utilizes the System.AddIn.dll (v2.0) that shipped with the VSTA SDK. This is the dll that provides the AppDomain creation, Assembly loading, and Add-In activation. This dll was primarily provided for the VSTA Add-in manager, but customers could have used this dll as a nice clean wrapper on top of Add-In contracts. The API resolved a lot of difficult things to resolve if you tried to roll your own Add-In implementation using AppDomainSetup, Assembly.Load, etc..

The CLR utilizes the new System.AddIn.dll (v3.5) that will ship with Orcas (i.e., Visual Studio.next). This dll is a new implementation that provides Discovery (i.e., a new feature), AppDomain creation (including a simplified enum for Full Trust, Intranet, and Internet), Assembly loading, and Add-In activation.

The CLR and VSTA loader implementations also provide AppDomain (AD) creation (and pooling) as well as out of process creation (and pooling of AD’s therein).

System.AddIn.Contract.dll remains basically the same (after all it cannot change in a breaking way).

The generic vs. custom contract model is the primary difference in the two (i.e., CLR and VSTA) implementations. VSTA provides the implementation of the generic contracts and the CLR now provides the base implementation of IContract, as well as other infrastructure that previously resided in VSTA.

The overriding design goal of VSTA was to provide a next generation managed solution akin to VBA. As a result, we needed to support existing VBA partners in the most transparent way possible. To this end, we created a tool called ProxyGen that takes as input, either a COM object model (using TypeLibs) or an existing managed object model (using reflection) and produces as output, a proxy dll that Add-In’s program against. You can think of the tool as a similar to tlbimp. The proxy also has some code that handles “remote reflection”. In addition to the proxy (Gen), VSTA shipped two Adapters: A COM adapter which used IJW to call from Managed code through IDispatch to an existing COM OM. And a managed Adapter that does local (on the Host side) reflection on a managed Host object model. The adapters do not change as the Host object model (OM) changes. The proxy may change for new Add-In’s to take advantage of new host functionality. As a result of this dynamic “pseudo” late-bound model, VSTA utilized a set of “generic” (i.e., predefined for VSTA internal usage) contracts built upon the base IContract for handling proxy requests, adaptation, remote arguments, etc…

The CLR implementation and thus customer adoption of MAF (the base) is based upon a “custom” contract model, as opposed to a generic contract model (e.g., used by VSTA). The custom contract model is more or less about expressing a type as a contract and it is built upon what we call a pipeline which handles the flow of execution between the Host Object model and the Add-In. The premise of a proxy (calling through – no implementation) is the same in both models. However the terminology and usage of terms is slightly different. VSTA exposes a proxy to Add-In’s whereas the CLR exposes a “view” to the Add-In’s, which gets adapted to a contract and adapted back again from the contract to a Host view. The CLR provides this proxy/adaptive behavior over a “pipeline” and you can read more on the pipeline model in our MSDN articles. The reality is that VSTA is using Proxies and Adapters on both sides of the boundary but since the Add-In mostly contains proxy functionality, we called the VSTA Addin side a proxy.

A picture is worth a thousand words

Diagram of the CLR model

Diagram of the VSTA Model

A few BCL additions/enhancements (I will post more on each)

· There is also the addition of BCL support for IContract collections.

· The CLR provides a base implementation of IContract, called ContractBase.

· Lifetime management.

· Discovery.

I hope this clears up some confusion or at least sparks enough questions that I can answer in an attempt to clarify some of the confusion.

Visual Studio 2005 Service Pack 1 Update for Windows Vista

JackG — Thu, 08 Mar 2007 05:03:00 GMT

The Visual Studio 2005 Service Pack 1 Update for Windows Vista addresses areas of Visual Studio impacted by Windows Vista enhancements.

Secret revealed

JackG — Thu, 01 Mar 2007 20:33:00 GMT

In a previous post (Extra, Extra – Read all about it!) I mentioned an upcoming highly requested feature. Well, it’s here. Last night we released the Visual Studio, code name “Orcas” March 2007 CTP. In this release you will find a number of VS, Language, and Platform features. And the System AddIn library has a new feature. We extended Add-in activation beyond AppDomains to support activating Add-In’s out of process! I will post more on the Add-In team blog about the feature (as well as a little refactoring of the code we did) but here is a little code snippet using the calculator sample from our MSDN articles, showing how simple it is to activate an Add-In out of process and some additional control you may attain as a Host using process isolation.

…

AddInToken calcToken = ChooseCalculator(tokens);

//Activate the selected AddInToken in a new AppDomain sandboxed in the internet zone

//Calculator calculator = calcToken.Activate<Calculator>(AddInSecurityLevel.Internet);

AddInProcess addInProcess = new AddInProcess();

Process HostProcess = Process.GetCurrentProcess();

System.Diagnostics.Trace.WriteLine("Calc Host PID: " + HostProcess.Id.ToString());

// The Process ID is -1 (i.e., Unassigned. Not yet created until Activate)

System.Diagnostics.Trace.WriteLine("addInProcess PID: " + addInProcess.ProcessId.ToString());

Calculator calculator = calcToken.Activate<Calculator>(addInProcess, AddInSecurityLevel.FullTrust);

// Get the AddinProcess created

Process tmpAddinProcess = Process.GetProcessById(addInProcess.ProcessId);

// Constrain the process WS

tmpAddinProcess.MaxWorkingSet = (IntPtr)((long)tmpAddinProcess.MaxWorkingSet - (long)tmpAddinProcess.MinWorkingSet / 2);

…

Where can I get the bits?

Use the following links for step-by-step instructions on installing and using the VPC images or installable bits.

Microsoft Office, MSDN, Extensibility (Add-In’s)

JackG — Thu, 18 Jan 2007 03:46:00 GMT

We recently published an article on the new CLR System.AddIn libraries in the February 2007 MSDN magazine. As I looked at the magazine cover I was *amused* by the coincidental irony of an issue that proudly announced not 1, but 3 separate Add-In solutions.

1. CLR Inside Out - .Net Application Extensibility

2. RibbonX API (A COM Add-In for Excel)

3. Office Add-Ins

I suppose this is further evidence of the demand and importance of application extensibility. This plethora of solutions however, contributes to customer confusion. This is the primary reason why I have been pushing for a unified model, freely available in the platform, for use by Microsoft products, as well as customers offering application extensibility.

Four solutions

Wait a minute – didn’t you just say 3. Is this a zero or one base issue again ;-) Each solution evolved from the previous and each subsequent solution usually offers enhanced functionality. Software, like fine wine, should get better with age.

1. The COM model

In the beginning, Office realized the value of extensibility, as well as the benefits of a COM interface model. However, utilizing an undefined COM interface model leads to customer complexity, lack of uniformity, etc… As a result, Office drove the definition of a “standard” interface definition for external application automation. This definition was called IDTExtensibility. Subsequent to this, they refined this interface into the present day IDTExtensibility2. I’ll defer talking about why a pure interface based model is inadequate (e.g., Immutability without adaptation, Up/Down Casting, etc..).

2. Managed (.Net) Shim

With the advent of managed code we discovered the need for interoperability between managed code and COM. Interop gives us the ability to retain our legacy code base while moving forward. In order to enable (and simplify) developers to write managed (i.e., C#, VB.Net, IronPython, ...) Add-In’s against an unmanaged COM Object Model, the Microsoft Visual Studio team built project templates for creating a managed project for IDTExtensibility2.

You can see what I am talking about by opening Visual Studio, Select File, New, Project, Other Project Types, Extensibility, Shared Add-In (VS installed templates), select the application(s) to extend (e.g., Word, Excel,..).

3. VSTO (Visual Studio Tools for Office)

When I was the Development Manager for the VSTO team it was one of my primary objectives to enhance the Office Application (i.e., App level) extensibility offering in order to provide a more robust managed code experience. We actually delivered the Outlook (customer demand was overwhelming) Add-In project in the Whidbey (VS 2005) product. You can read about some of the VSTO additional value added on top of the VS Shim project on MSDN. Recently the VSTO team used this code base to offer a breadth of Office Add-in’s, (Word, Excel, Powerpoint, Visio, …).

You can see what I am talking about by opening Visual Studio, Select File, New, Project, Visual C#, Office, Outlook Add-In (VS installed templates).

4. CLR Add-In model

The CLR Add-in model is the evolution of the work we did for Visual Studio Tools for Applications (VSTA). I was also the Dev Manager for the VSTA v1 product. The Trinity team owns both the VSTO and VSTA products. You can think of VSTA as the managed version of VBA. Here is a link to a post on FAQ’s on VSTA and the CLR Add-In model. I will be updating the post with the latest information on what is now shipping in the CLR Orcas release.

The CLR MAF (Managed Add-In Framework) is now available for ISV’s and developers for inclusion in your products for enabling a version resilient, isolatable managed object model. Keep in mind that you can build this on top of your COM object model. The CLR Add-in model provides Add-In discovery, activation, lifetime management, and a design for your object model to enable isolation, remoting, and version resilience.

When VSTO moves over (I can’t guarantee when) to using the CLR Add-In model you will inherently be using the CLR implementation under the covers of the VSTO Office projects they generate. VSTO host extensibility is offered via the PIA’s as well as the VSTO product extensions they add to the Host Office applications (e.g., Task Pane). Therefore, the discovery, isolation, activation and VSTO extensions should be built upon the CLR Add-In model.

At some juncture (hopefully soon) VSTA will also reconcile their MAF implementation with the CLR implementation (more on this later). I expect the VSTA product will offer its current generic adapter MAF implementation as well as a custom contract model based upon the CLR implementation. The discovery and activation within the VSTA Add-in manager may also be built in part on the CLR offering, but I’ll leave that to TQ to determine.

Extra, Extra – Read all about it!

JackG — Fri, 12 Jan 2007 05:32:00 GMT

(5/16/08, Updated MSDN Link)

Application Extensibility

Back in February 2006, the Managed Add-In Framework charter and myself, moved over to the CLR team. See my previous post, “The only constant is change”. After the transition, I spent several months initially focusing on ISV/VAR/SI .Net concerns. You can checkout my posts on ISV/VAR/SI’s. Not surprisingly, many of these customers need a .Net solution for Application Extensibility. This requirement is often tied to the Managed Add-In Framework solution. I now have an overall responsibility for ISV application extensibility needs and a primary focus on the Managed Add-In Framework.

Hot off the Press

Jesse Kaplan (the PM on the Add-in team) and I recently published the first of two articles on the CLR’s implementation of MAF. Here is a link to the first MSDN article.

“The Microsoft .NET Framework has made it very easy to take components built by different developers and companies and integrate them into your own applications. But it's only easy if you know which components you're building against. If those components are not known at build time, which is typically the case for add-ins, then things become much more difficult. Developers often have questions when extending their applications.”…

Come and get it

Over the last few months the CLR team has been working hard in developing MAF for the Orcas release. Here is the link to the Microsoft Pre-release Software Visual Studio Code Name "Orcas" - January Community Technology Preview (CTP) (Installable Bits). In this release we added a few new Add-In features.

“Support for advanced lifetime management of add-ins and their AppDomains

We’ve added the helper classes that manage the lifetime of add-ins, the objects passed between the host and add-ins, and even of the AppDomains the add-ins live in. By using the ContractBase and LifetimeToken handle, pipeline developer can let the hosts and add-ins act as if everything, including the AppDomain the add-in was activated in, was controlled by the garbage collector even though .Net Remoting would normally make that impossible. “

Stay tuned

If you have read to this point, I’ll let you in on a little secret. In addition to the second MSDN article, we have another highly desired Add-in/Application extensibility feature that will be available in the February CTP!

VS 2005 SP1 released

JackG — Tue, 19 Dec 2006 02:52:00 GMT

If you are using Visual Studio 2005, you may wish to get service pack 1 (SP1) which was just released. The beta for VS Windows Vista will also be released asap. Here are the links.