AllenD's WebLog : VSIP

TechEd 2006 - Power To the Pros - Boston

AllenD — Tue, 06 Jun 2006 02:55:00 GMT

I'll be at TechEd this year. Please stop by the VS Extensibility booth for info on extending Visual Studio and the VSIP Partner Program.

I'll try to blog often to give a perspective about the event and the activities that are planned. I'm already tired just thinking about the calendar.

VS SDK V2 Has Been Released

AllenD — Tue, 18 Apr 2006 01:43:00 GMT

I'm proud to announce the availability of the V2 VS SDK supporting VS 2005. This SDK is awesome. It has some incredible sample content including Iron Python language integration including WinForms Designer integration. By examining the Iron Python source code (not included in the SDK, but free) you can see how a language can integration into VS in a rich deep way.

If you noticed, we anticipated our release to be shipped on 4/7, but we held back the release for additional verification and examination to ensure it was the best we could ship. Some of the components were built with the VS 2005 RTM build and that raised a few flags with folks that wanted those components to be built with newer build rules. In the end, we changed a few components and others remained the same. The net result is that you have the best SDK we could ship.

Enjoy!

(And please provide feedback for future SDK's.)

VS SDK (Oct 2005) for VS 2005 now posted

AllenD — Wed, 02 Nov 2005 22:00:00 GMT

I'm very pleased to announce the availability of the Visual Studio SDK for Visual Studio 2005.

VSIP members can now download the VS SDK for the VS 2005 product (which was recently posted for MSDN subscribers). This is the SDK necessary to build integrations into Visual Studio 2005.

Please note that the VSIPDev.com redirects you to a new site which has been modified significantly from the original (it uses Passport for identity management, for instance). Don't be surprised by the changes. Everything is still there, it's just been reorganized.

We'll have updates to this SDK in the near future and they are intended to work side-by-side with released SDK's so you can look forward to new samples, tools and libraries in the future. The SDK team put in a lot of work over the last several months to get this SDK ready for release. We hope you like it. If you see any problems or have suggestions, please visit the Product Feedback Center on MSDN to provide feedback.

PDC Day 3 - Domain Specific Languages - the future of Modeling

AllenD — Thu, 15 Sep 2005 21:13:00 GMT

Bob Muglia's General Session - Windows Server...

I just got out of Bob Muglia's keynote and it was great to see so many cool things happening in the Windows Server product. In particular I was impressed with IIS7 and it's capabilities. They designed an extensibility mechanism in IIS that allows an admin to completely control the modules that are used/loaded for the website as well as capability for a developer to modify the default capabilities of the modules there. What was shown was a different kind of directory listing that actually was a set of thumbnails for the images in the directory listing. Very cool...

Modeling and Visual Studio Team System...

As some of you know we have plans to include the team system modeling technologies API's in the VS SDK. I wanted to attend Jochen Seemann's presentation here at PDC in order to gauge the level of excitement and need for extensibility in order to be certain we provide the best SDK possible. By the size of the crowd (about 1500 people), I'd say that the modeling space is definitely huge and a lot of people are very excited/curious about what we're doing in this space. DSL isn't something to do with broadband or cable-modems. Domain Specific Languages is what we're talking about. Jochen had a quote: "A picture is worth a thousand words...but it's often the case that one doesn't know what the thousand words are." The vision for DSL tools is to instantiate the modeling tools exactly for a custom domain with our tools. We want to give the customer the freedom to express their domain since they are the experts in their domain. The DSL tools are on the web (as of Friday) on the MSDN site at Microsoft.com. You can see some modeling tools today in VS 2005 in the class designer, web service designer and the deployment designer. The DSL tools are designed to provide a toolkit for creating designers for Visual Studio. The DSL tools allow one to use the drawing surface, toolbox, property browser, explorer and validation. The modeling platform includes the following components: In-memory graph database (Domain Model), Drawing Surface (objects (shapes), connectors, auto-layout, routing, all customizable, etc.), Template Engine (for artifact generation), Shell Framework (Visual Studio UI integration - toolbox/menus), Validation Framework (checks constraints and guides user to resolve errors). The roles involved in modeling for software are Architect, Developer and Business Analyst). All of these roles can use MS provided designers, but there are several domains where MS won't provide designers and 3rd parties will provide them. The cool thing is that all of the models based on the platform will be able to work together and link artifacts and designers together.

During the session, Jochen designed a Simple Activity Language. He took 3 steps:

Define domain model (what do the shapes mean on the drawing surface, properties, states, inheritance relationships and behavior relationships, the meta-model)
Define the notation (decompose the language to basic units) - describe the shapes and connectors physical properties (text position, icons, colors, etc)
Define visualizations of the model via the notation elements

This works for really complex models as well as a simple one (like Jochen did on stage). As a side effect of this process you get a real nice specification of the language. To interact with the designer you write code for code/artifact generation, custom serialization, validation/constraints and custom behavior. This code can take advantage of the DSL SDK (that's the thing we want to provide in the VS SDK in the future).

The Toolkit generates a project that is actually a VS Package. It allows the package to launch in the Experimental hive. In the Exp hive we then create diagrams and manipulate the diagram with the design surface according to the model defined in the regular hive. In the demo Jochen then added a property to one of the shapes, rebuilt the model designer and showed again the Exp hive manipulating the designer and see the property he added.

One of the cool things is that the model database is able to be queried via a language and the API generated by the tool for the domain model.

If one can generate a single designer, one can generate multiple designers. What the modeling platform provides is a nice way to make multiple designers work together. A 'software factory' can generate and link these multiple designers. The DSL tools provide a tool window that allows one to create a table consisting of the rows and columns of shapes from two different designer surfaces. The table is then used to add dependencies with a check mark to associate elements from one model to elements from another.

Another cool feature of this toolkit is the linkage with the class diagram and code. With just a couple of clicks one can go from a use case domain shape, to a class object in the class designer to the code.

One of the final thing that Jochen did was to invite a partner (EDS) on stage to show their application which was driven with models during development. The EDS application had a bunch of code generators and stuff from about 4 years ago that generates applications for a 3-tier application using business logic, front end and the database. EDS wrote an add-in that generates a solution based on the models. It uses the API's of the DSL tools and the model. The solution generation add-in creates the front end code, unit tests (including a testing database with random data for testing), database scripts, stored procedures and links everything together using the business logic. The unit tests, by the way, are run by Visual Studio Team System Test.

For the future the DSL toolkit is planned for early 2006. Version 2 will include even tighter VS integration in the next version of VS after VS 2005.

Get more information at http://lab.msdn.microsoft.com/teamsystem/workshop/dsltools

Allen

Visual Studio and Windows Workflow Designer rocks! - PDC Day 2

AllenD — Wed, 14 Sep 2005 20:26:00 GMT

At the morning keynote I saw a great integration with Visual Studio in the Windows Workflow Designer. I'm sitting in the PDC general session this morning and during Eric Rudder's keynote he invited the Windows Workflow Foundation team to demonstrate their cool tools. The really awesome thing that I saw was a great design surface for work flow objects in a graphical form. To seal the deal the demo showed debugging the work flow directly in Visual Studio and seamlessly interacting with the usual C# debugger. The workflow debugger was completely graphical with a little breakpoint glyph attached to the workflow object. There were also 'callstacks' of the work flow objects and properties of the selected work flow objects showing current state to allow debugging the workflow and the code at the same time. This is hugely powerful and really shows off how awesome the Visual Studio platform is.

Another big deal at this session was the Microsoft Expression suite of applications that allow graphic design, web site design and interactive designers to work together. They aren't hosted in Visual Studio (they do share some aspects via common project files), but one can easily see how lots of aspects of those tools can be integrated. For now, they are separate tools.

If you are at the PDC today, please stop by the Tools and Languages Track Lounge. I'll be hanging out there most of the day. At 2:00 pm those of us from the VS Extensibility team that are here are scheduled for a "meet the team" event. Please stop by and say hello.

Blog to you later...

Allen

PDC Day 1 - Power Outages and Uploads

AllenD — Wed, 14 Sep 2005 01:05:00 GMT

Well, yesterday was very eventful.

Just after my previous post, we broke for lunch and just as we were starting to present our after-lunch information the power went out in Los Angeles. Not just in the Convention Center, but all over the city. According to reports 2 million people were affected. It was an interesting 30-45 minutes as we sat around in the dark (a little bit of illumination from ambient light). We finally got up on stage and did some general Q&A. The power finally came back on and we were able to continue our preconference session without further incident.

During my portion of the precon, I wrote a To Do Manager from scratch (ok, practically from scratch). This is the same demo that I did at the Dev Lab in August on campus. The code for this demo has been posted on GotDotNet. This code project requires the Sep 05 CTP of the VS SDK and is expected to work with Visual Studio 2005. I wrote it using a recent VS 2005 release candidate (internal), but it should work with any VS 2005 RTM Release Candidate.

After the precon our VS partner program hosted a little party at Dodger Stadium for a few partners. The Dodgers did very well and it was a nice treat to see a big league game in a beautiful stadium. It was fun talking with partners and letting our hair down a little bit.

This morning I attended BillG's and JimAll's keynotes. They were both very good. Don Box, Chris Andersen, Scott Guthrie and Anders Hejlsberg were very good as usual. Windows Vista is awesome, our programming model and frameworks are really powerful and it is truly a great time to be a software developer.

Fun facts: My pedometer is still going. Totals for the week as of Tue morning: 5.49 miles, 15136 steps. Since the last report this represents 2.88 miles walked.

What is IVsThreadPool?

AllenD — Thu, 16 Jun 2005 05:17:00 GMT

Got a question from VSIP partner Patrick today and wanted to pass it along. Before I do that though, let me once again apologize for not blogging like you want me to. I will strive to do better. I promise.

So, here's the question: What's the deal with IVsThreadPool?

Here's the answer:

The SVsThreadPool service is available to schedule background tasks in a thread pool managed by VS. This is useful for long running tasks that need to get done, but can be done without the user interacting.

First, this is for native code only. If you want managed code then the .net framework’s thread pool is fine. Second, you should make no assumptions about COM threading or CoInitialize settings. Be careful accessing data or calling methods on COM objects where the apartment may need to be switched away from the free thread that the thread pool gives you for your task. This can cause race conditions or data corruption. My recommendation is to have the background task avoid interaction with other threads and objects as much as possible. Do nothing or as little as you can with other COM objects directly and try to use Win32 methods to access shared resources. This is a conservative approach, but it simplifies things tremendously.

The service is designed to have two types of callbacks. First is a callback whenever a thread is available. This is useful for general background work. Once your task exits, then it is done forever and you can reschedule it or another task if you need more background work done. The second is a handle-activated callback where your task method is called whenever the handle you supply is signaled. Once your task exits, the handle is checked again and you will be called again if/when it is signaled. This is useful for Win32 WaitForSingleObject style background work. You have to explicitly shutdown VS or unschedule your task for this type to go away. Be careful to unschedule the task before closing the handle. Once the task is scheduled the handle is used in a WaitForMultipleObjects call on the background thread so if you close it on another thread then that can cause problems (perhaps crashes).

As for setting the event passed to you, you should not set it. It is set by the thread pool service in order to inform you that the thread pool is shutting down. It is meant as a ‘please exit the building now’ kind of signal. If you set it yourself, then that might cause problem, but it is doubtful. For long running tasks, the task should periodically check the state of the handle passed to you to determine if it is signaled. If it is signaled, then the thread pool is terminating and all tasks should exit immediately (basic terminate early work should be done (like closing a file handle to get it to flush data to it, for instance, but no other work should be performed).

You'll find some details in the VSSHELL80.IDL file in the EnvSDK part of the VSIP SKU.

Allen

P.S. Check out the MSDN Forum on VS Extensibility. I’m trying to get myself and more folks to hang out there to answer questions just like this one:

P.P.S I can't wait to tell you all about some exciting changes to the VSIP SKU in the near future. Watch for announcements on the VS Extensibility portal.

Managed Package Framework Webcast

AllenD — Thu, 13 Jan 2005 21:25:00 GMT

I forgot about this 'til now.

http://msevents.microsoft.com/cui/eventdetail.aspx?EventID=1032258553&Culture=en-US is a link to a MSDN webcast I did describing the Managed Package Framework for the masses. Enjoy.

Back in the saddle again

AllenD — Thu, 13 Jan 2005 21:15:00 GMT

Whew! It's been a while hasn't it?

My new son was born 9/30 and I returned to work late October after infant care leave. We're all hard at work here getting Whidbey Beta 2 ready to ship. The holiday's hit and I spent a bunch of time on the road and on airplanes.

I'm back from vacation now and sitting in a rountable discussion with VSIP partners at the January VSIP Dev Lab here in Redmond. Good suggestions and a lot of hard work getting partner products ready to run in Whidbey Beta 2. Thank you to all the parnters in attendance.

Hey, I'm a video star! Check out the latest installment on Microsoft's Channel 9 community site: http://channel9.msdn.com/ShowPost.aspx?PostID=35379. A bunch of interviews of hard-working computer geeks getting Visual Studio ready for release.

I certainly hope to post here more often and do some interesting posts now that things have finally settled down in my life. Hope you are doing well.

Later,

Allen

Out for a while

AllenD — Wed, 29 Sep 2004 16:11:00 GMT

I'm going on infant care leave either tomorrow or next week. I'll most likely not blog anything during that time since I'll be enjoying my new son. I'll return to work at the end of October.

The VSIP/Extensibility team is working hard to get Whidbey Beta 2 ready and everyone is heads down on that effort. It's going to be great to get that beta shipped!

IVsRunningDocumentTable.RenameDocument - how to call in managed code

AllenD — Fri, 20 Aug 2004 20:52:00 GMT

Here's a little code to help managed packages call the Running Document Table to rename a document:

Calling IVsRunningDocumenTable.RenameDocument is not entirely straighforward in managed code. Here's some code the shows how to get the SVsRunningDocumentTable service, find a document therein and then rename it. I've had one partner confused by the calling pattern so I figured I'd share the solution with you in case you ever need to employ it.

IVsRunningDocumentTable pRDT = GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
IVsUIShellOpenDocument doc = GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
IVsUIShell uiShell = GetService(typeof(SVsUIShell)) as IVsUIShell;

if (pRDT == null || doc == null) return;

IVsHierarchy pIVsHierarchy;
uint itemId;
IntPtr docData;
uint uiVsDocCookie;
NativeMethods.ThrowOnFailure(pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, oldName, out pIVsHierarchy, out itemId, out docData, out uiVsDocCookie));

if (docData != IntPtr.Zero) {
    IntPtr pUnk = Marshal.GetIUnknownForObject(pIVsHierarchy);
    Guid iid = typeof(IVsHierarchy).GUID;
    IntPtr pHier;
    Marshal.QueryInterface(pUnk, ref iid, out pHier);
    try {
        NativeMethods.ThrowOnFailure(pRDT.RenameDocument(oldName, newName, pHier, itemId));
    } finally {
        Marshal.Release(pHier);
        Marshal.Release(pUnk);
    }

    Marshal.Release(docData);
    }

I hope this help!

Allen

Regular Expression Language Service

AllenD — Mon, 26 Jul 2004 23:36:00 GMT

I've finally gotten around to posting the Regular Expression Language Service so you can get to it.

This is the project that I wrote during the TechEd VS Extensibility Feature Cookoff where I had to write this in 45 minutes or so. I tried the code with Whidbey Beta 1 and it worked for me.

One major point to remember here is that this is all managed code and really fairly easy to implement compared to working with Babel (native abstraction for language services) or native interfaces directly.

The project is on the workspaces on the GotDotNet site: http://workspaces.gotdotnet.com/RegExLangService

Here's a screen shot.

Extensibility makes MSDN TV

AllenD — Thu, 15 Jul 2004 23:37:00 GMT

Check out Ken Hardy, VS Core PM for Extensibility share some info on MSDN TV.

If you were at TechEd 2004 San Diego, you might catch yourself in the background...

Solution Options Persistence (Part 2)

AllenD — Mon, 12 Jul 2004 19:28:00 GMT

It occured to me that I didn't discuss what the framework will do when the options you specified in the AddOptionsKey method are needed to be loaded or saved.

The framework will eventually call one of two virtual methods that you need to override.

        protected override void OnLoadOptions(string key, Stream stream) {
            // if key is a string this package cares about then
            // stream can be used to read the data for runtime use
            if (key == MyOptionKey)
                try {
                    BinaryReader reader = new BinaryReader(stream);
                    // read the options here...
                } catch (Exception) {
                    // no options, ok, no problem.
                }
            } else {
                // If this isn't a key this package cares about,
                // then call the base class implementation
                base.OnLoadOptions(key, stream);
            }
        }

        protected override void OnSaveOptions(string key, Stream stream) {
            // if key is a string this package cares about then
            // stream can be used to write the data
            if (key == MyOptionKey) {
                try {
                    BinaryWriter writer = new BinaryWriter(stream);
                    // write the options here...
                    writer.Flush();
                    stream.Flush();
                } catch (Exception) {
                    // no options, ok, no problem.
                }
            } else {
                // if this isn't a key this package cares about,
                // then call the base class implementation
                base.OnSaveOptions(key, stream);
            }
        }

Allen

Solution Options Persistence

AllenD — Fri, 09 Jul 2004 22:52:00 GMT

I investigated this question earlier today for an internal VS client and wanted to share the results with the rest of the world...

Your VS Package can place data into the solution file (.sln) or solution user options (.suo) file by implementing IVsPersistSolutionOpts (.suo affecting) or IVsPersistSolutionProps (.sln affecting). These interfaces should be implemented by the same class which implements IVsPackage.

The VS IDE will call these interfaces for each loaded package when a solution is opened/closed. If your package is not loaded when the solution is opened, then you won't be called to load your solution options. The remedy to this problem is to call the SVsSolutionPersistence service's IVsSoltionPersistence::LoadPackageUserOpts method yourself. This will cause the VS IDE to eventually call your IVsPersisteSolutionsOpts::LoadUserOptions method. The IVsSolutionPersistence::LoadPackageUserOpts method takes a IVsPersistSolutionOpts interface parameter which should be your package class pointer. You also specify your unique “keyname” when calling the method.

The above is true in VS7 and VS7.1.

In Whidbey the VSIP Managed Package Framework provides a nice base class (Package) implementing these interfaces and calling them for you. You simply call Package.AddOptionKey to add your unique keyname to the list of option keys the package handles. During the Package.Initialize() method the option keys are loaded using the above services/interfaces. You should call AddOptionKey during your package class constructor or any other method that is called before the base class Initialize() method.

The VSIP EnvSDK sample SlnExt is a great sample showing how to all of this in native code not using the managed package framework. I have designs to rewrite that sample to use the managed package framework, but for now that is left as an exercise for the reader.

Later,

Allen