David DeWinter http://blogs.rev-net.com/ddewinter A Developer's Melting Pot Mon, 25 Aug 2008 03:50:05 +0000 http://wordpress.org/?v=2.6 en DBML Fixup Preview http://blogs.rev-net.com/ddewinter/2008/08/24/dbml-fixup-preview/ http://blogs.rev-net.com/ddewinter/2008/08/24/dbml-fixup-preview/#comments Mon, 25 Aug 2008 03:41:44 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/2008/08/24/dbml-fixup-preview/ Back in February I blogged about DBML Fixup—a tool whose goal was to sync LINQ to SQL models with their respective database schemas from within the Visual Studio environment, as well as to handle running various fixup tasks on models. Now it’s six months later, and I have a much clearer vision of what the tool is meant to be as well as a firmer command on VSX. The following screencast is a preview of the features of DBML Fixup.

 

 

Here are some previous posts which (briefly) describe the domain:

http://blogs.rev-net.com/ddewinter/2008/02/16/the-linq-to-sql-model/

http://blogs.rev-net.com/ddewinter/2008/02/16/linq-to-sql-and-database-schema-sync/

 

Any ideas about directions for the tool? Or maybe something that wasn’t covered in the screencast? I’d love to hear your ideas.

]]> http://blogs.rev-net.com/ddewinter/2008/08/24/dbml-fixup-preview/feed/ Generate Serialization Classes As Part of Your Build (Part 1) http://blogs.rev-net.com/ddewinter/2008/07/08/generate-serialization-classes-as-part-of-your-build-part-1/ http://blogs.rev-net.com/ddewinter/2008/07/08/generate-serialization-classes-as-part-of-your-build-part-1/#comments Tue, 08 Jul 2008 12:58:56 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/2008/07/08/generate-serialization-classes-as-part-of-your-build-part-1/ Yes, I am back from the grave. The past two months have been infuriatingly busy for me (and you’ll see why in a later post), but I finally have some time to write again. The topic? Generating serialization classes as part of your build process (Part 1) and in your own way (Part 2).

I might reach only a niche of .NET developers with this post, but it’s something that niche should be aware of. There is a tool in the .NET framework called xsd.exe, and one of its functions is to generate code, specifically .NET classes, from an XML Schema file (XSD). The tool decorates these classes with XML serialization attributes such that when .NET serializes an instance of the generated class that represents the root element, the output conforms to that XML schema. Often, developers using XML schemas will need to change them throughout the course of a project. Leveraging xsd.exe in a project thus requires the generated classes to be updated when an XML schema is updated. This is a bit dangerous in larger projects because not all developers may realize that the tool must be re-run, especially in the case of extremely minor changes to the schema.

Wouldn’t it be better to have a tighter integration among the XML schema, the generated classes, and the build environment? Fortunately, we can achieve this with a few simple steps, thanks to the MSBuild system for projects inside Visual Studio.

We’ll start from scratch here, so first things first: create a new project. Here I’ll just create a class library called "DeWinterXsd". Then add a new XML Schema file to the project. (You can find it under the Data category of items.)

image

Replace the contents of the schema file with the following snippet. It’s a very simple schema, featuring a root element and two child elements with three attributes among them.

<?xml version="1.0" encoding="utf-8"?>

<xs:schema id="SampleSchema"

          targetNamespace="http://schemas.example.com/SampleSchema.xsd"

          elementFormDefault="qualified"

          xmlns="http://schemas.example.com/SampleSchema.xsd"

          xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:element name="root">

    <xs:complexType>

      <xs:sequence>

        <xs:element name="first">

          <xs:complexType>

            <xs:attribute name="name" type="xs:token" />

            <xs:attribute name="value" type="xs:token" />

          </xs:complexType>

        </xs:element>

        <xs:element name="second">

          <xs:complexType>

            <xs:attribute name="origin" type="xs:token" />

          </xs:complexType>

        </xs:element>

      </xs:sequence>

    </xs:complexType>

  </xs:element>

</xs:schema>

Now that you have the schema, add a new class to your project with the same name as your XML schema file. For example, the name of my schema file is "SampleSchema.xsd", and the name of the class is "SampleSchema.cs". This should nest the .cs file underneath the schema file, akin to how code-behind files are nested under UI files (e.g. Windows Forms, XAML). So how do we generate serialization classes? Right click on your project file and select "Unload Project".

image

And then right click on the project again and click "Edit xxx.csproj".

image

Now you’ll see the contents of the .csproj file itself. If you’re not familiar with the MSBuild system, then here’s the gist of it. Building a project in your solution executes a series of tasks, which are logically grouped into targets. Building will actually run only one target, Compile. However, the Compile target can depend on other targets in order to run correctly, so those targets are run before Compile, and so on. Take a look at your output window sometime while building; it will show you the tasks being executed by each target. For more information, read an MSBuild tutorial, like this one.

What we’ll do now is say that before the compilation target occurs, we want to generate serialization classes using xsd.exe. Scroll to the bottom of the file and you should see this:

<!– To modify your build process, add your task inside one of the targets below and uncomment it.

Other similar extension points exist, see Microsoft.Common.targets.

<Target Name="BeforeBuild">

</Target>

<Target Name="AfterBuild">

</Target>

–>

For now, we’ll uncomment the BeforeBuild target and insert a task to run xsd.exe. But since this is logically better off as its own target (e.g. GenerateSerializationClasses), we’ll specify that the BeforeBuild target depends on another target of our creation.

<Target Name="GenerateSerializationClasses">

</Target>

<Target Name="BeforeBuild" DependsOnTargets="GenerateSerializationClasses">

</Target>

I’ve placed the above lines right above the comments that discuss the BeforeBuild and AfterBuild targets ("To modify your build process, add your task…"). Now…to actually do something inside GenerateSerializationClasses requires the use of the Exec task, which as its name implies, will execute a task as if running it from the command line. Here we need to run xsd.exe, so we need to find where this tool is located. To do this easily, run "where xsd.exe" from a Visual Studio Command Prompt. My xsd.exe is in one of the Windows SDK directories, so I’ll add it to the Exec task like this:

<Target Name="GenerateSerializationClasses">

  <Exec Command="&quot;C:\Program Files\Microsoft SDKs\Windows\v6.0\Bin\xsd.exe&quot; SampleSchema.xsd /classes" />

</Target>

Straightforward, right? The Exec task tells MSBuild to run xsd.exe using the specified command parameters, which will generate serialization classes based off my XSD file (SampleSchema.xsd). If you reload and rebuild your project, then you’ll see the serialization classes appear in the .cs file you provided. But there’s one more thing we can do here first! It makes sense that we want to generate classes only when the schema file has actually changed, so we’ll need a few more attributes to the GenerateSerializationClasses target. The Inputs attribute specifies the inputs to consider for the target, and the Outputs attribute specifies the outputs to consider for the target. MSBuild will use this data to determine whether to run the target at all. Here, our logic is simple: if the schema file has been modified after the last modified time of the class file, then run the target, and that’s exactly what MSBuild will do. The final XML snippet:

<Target Name="GenerateSerializationClasses" Inputs="SampleSchema.xsd" Outputs="SampleSchema.cs">

  <Exec Command="&quot;C:\Program Files\Microsoft SDKs\Windows\v6.0\Bin\xsd.exe&quot; SampleSchema.xsd /classes" />

</Target>

<Target Name="BeforeBuild" DependsOnTargets="GenerateSerializationClasses">

</Target>

<!– To modify your build process, add your task inside one of the targets below and uncomment it.

Other similar extension points exist, see Microsoft.Common.targets.

<Target Name="BeforeBuild">

</Target>

<Target Name="AfterBuild">

</Target>

–>

Now, if you reload and rebuild your project, you can see the fruits of your labor:

image

We’ve generated the code, but it’s not the nicest output. Our classes have camel-cased names to match our element names, and the comments are non-existent for classes and publicly exposed members. Of course, we didn’t add any comments in our XML schema, but even if we used the xs:documentation element to document our elements and attributes, those comments would not be carried across to the generated code.

Next time, I’ll show you how to remedy these and other problems by building your own MSBuild task that can generate the same quality of code as xsd.exe but with a few custom enhancements.

]]> http://blogs.rev-net.com/ddewinter/2008/07/08/generate-serialization-classes-as-part-of-your-build-part-1/feed/ Entity Framework Stored Procedure Generation http://blogs.rev-net.com/ddewinter/2008/04/26/entity-framework-stored-procedure-generation/ http://blogs.rev-net.com/ddewinter/2008/04/26/entity-framework-stored-procedure-generation/#comments Sat, 26 Apr 2008 21:24:13 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/index.php/2008/04/26/entity-framework-stored-procedure-generation/ At work my team and I are utilizing the ADO.NET Entity Framework as a means to mitigate the object-relational impedance mismatch. Simply put, we’re utilizing it as an object-relational mapper for our latest project. So far we have been really impressed with the flexibility it provides us, especially surrounding the area of mapping the same table to multiple entity types and creating inheritance relationships among those entity types. It has proven itself as a much more viable candidate than .netTiers or LINQ to SQL for us.

While I have a lot of praise for the Entity Framework, there are some quirks that take getting used to. For example, you can’t update properties that are part of a primary key, even though you can update (non-identity) columns that are part of the primary key in SQL Server 2005. Another is the requirement that if an entity will be inserted into the database using a stored procedure, it must also be updated and deleted through a stored procedure. Yet another is that each stored procedure mapped to a particular entity type must have parameters mapped to every association key, regardless of the type of stored procedure (INSERT, UPDATE, or DELETE). For example, consider the following model:

image 

If I created stored procedures for the Account entity to use in my EF model, they’d look like this:

CREATE PROC dbo.Account_Insert

(

    @customerId INT

)

AS

BEGIN

    INSERT INTO Account (customerId)

    VALUES (@customerId)

 

    SELECT SCOPE_IDENTITY() as accountId

END

GO

 

CREATE PROC dbo.Account_Update

(

    @accountId INT,

    @customerId INT

)

AS

BEGIN

    UPDATE Account

    SET customerId = @customerId

    WHERE accountId = @accountId

END

 

CREATE PROC dbo.Account_Delete

(

    @accountId INT,

    @customerId INT

)

AS

BEGIN

    DELETE FROM Account

    WHERE accountId = @accountId

END

Notice the delete stored procedure—it must take in both the ID of the Account and the ID of the Customer it is associated with. Based on Colin Meek’s post here, I can understand why this is necessitated by the Entity Framework, but I can’t dispute the fact that it is different from I’m used to writing stored procedures.

As we moved towards implementing sprocs for our persistence layer to utilize, we ran into a few problems. At first, we thought we could utilize old templates from CodeSmith and .netTiers to generate sprocs, and our EF model would consume them gracefully. Unfortunately, if we used these templates, we would end up with sprocs like this for the Account table:

CREATE PROC dbo.Account_Insert

(

    @accountId INT OUTPUT,

    @customerId INT

)

AS

BEGIN

    INSERT INTO Account (customerId)

    VALUES (@customerId)

 

    SET @accountId = SCOPE_IDENTITY()

END

GO

 

CREATE PROC dbo.Account_Update

(

    @accountId INT,

    @customerId INT

)

AS

BEGIN

    UPDATE Account

    SET customerId = @customerId

    WHERE accountId = @accountId

END

 

CREATE PROC dbo.Account_Delete

(

    @accountId INT

)

AS

BEGIN

    DELETE FROM Account

    WHERE accountId = @accountId

END

Notice the slight differences:

  1. The INSERT sproc takes in an output parameter for the identity column and then sets the value of that parameter to the ID that was just inserted. The EF version of the sproc does not take in an output parameter; instead it just selects SCOPE_IDENTITY() for the EF to merge back into the Account entity that was inserted.
  2. The DELETE sproc does not take the parameter for the Customer ID, because it is not part of the primary key.

This causes some vexation for us because our new business domain houses about forty tables for which we need to write CUD sprocs that fit the Entity Framework’s rules. We could write them by hand (which would be painful and subject to error), try to modify CodeSmith’s templates to generate them correctly, or try to generate them using some other way.

From the title of this blog entry, you can probably infer that we didn’t write them by hand. Furthermore, Ryan Hauert and I were toying around with the idea of using T4 Templates to generate the SQL we needed. In all honesty, we didn’t even consider modifying the CodeSmith templates; I don’t think this was a bad choice, as T4 templates can benefit people who don’t want to purchase CodeSmith, but it may’ve been easier for our particular situation. But I digress…

The T4 template we created is designed to be a general purpose way to generate CUD procedures for an Entity Framework model. In case you didn’t read the links I provided on the templates, they are code-generation files which are intrinsically recognized by Visual Studio 2008. (They required the VS SDK in VS2005.) They have a .tt extension, and Visual Studio will nested generated code files underneath them in the Solution Explorer, similar to how designer files are nested under Entity Framework and LINQ to SQL models.

image

It’s a very simple process to use the T4 template:

  1. Add the file into your project. (The file is linked at the end of the blog entry.)
  2. Simply save the template file and CUD sprocs will be generated for every EDMX file in the current directory.

If you want to change what directory the template looks in or what files it generates sprocs for, look at the configuration parameters on lines 24 and 25 in the picture above. You can specify the directory explicitly by initializing the directoryName variable to anything other than the empty string or null. Furthermore, if you want to match a specific EDMX file only, you can use a regular expression to filter out unwanted files. I could use it like this:

Regex edmxFileFilter = new Regex(@"Entities\.edmx");

Then only the Entities.edmx file would be processed.

The template not only generates EF-compliant sprocs, but it also considers only the tables that are in the SSDL of the model file. Unfortunately, the template must query the database (SQL Server 2005 only!) in order to make all the decisions necessary to create the output file. However, this is usually quite fast on generations other than the first one.

As you can see from the picture above, the template requires a few different assemblies to be installed. Most of them shouldn’t be a problem when generating EF sprocs, because it strongly suggests that you have the .NET Framework 3.5 installed. Something you may not have are the SQL Server Server Management Objects (SMO), which offer an abstraction layer over the metadata of a SQL Server instance (e.g. databases, tables, columns, keys, indexes, data types), and keep the template cleaner than if we had to make ad hoc queries directly. The SMO installation is available on this page, where its installer is called "SQLServer2005_XMO.msi." There are other installers for 64-bit and Itanium 64-bit.

Once that is installed the template is very simple to run and gives us output like this:

image

Now we can take this script and run it against SQL Server and then import the sprocs into our Entity Framework model. Finally we can map the stored procedures to the entity types they encapsulate and voilà! We’re done.

There are a few limitations with the template the moment, but it will account for most cases:

  1. No stored procedures are generated for tables that do not have primary keys (in the database, not in the EF model). There is no way we can infer what you meant for the key to be for the update and delete sprocs; while we could generate insert procedures, it wouldn’t help the end user because the EF requires that an entity type be mapped to all three, or none at all.
  2. The template is available only in C# at the moment.
  3. It has not been tested in all scenarios, so any feedback you have would be great. :)
  4. It does not account for entity inheritance.

T4 Template

Special thanks to Bob Pace for giving Ryan and me the idea and providing helpful resources on T4.

Also, if you want to get started writing your own T4 templates, check out Hilton Giesenow’s excellent video here.

May 22, 2008 - Updates:

Ryan and I ran into an issue recently where we were accidentally comparing all of the parameters against values in database rows for the delete stored procedures. This was a mistake, because we really only need to check for equality on the primary key columns. The new template has been uploaded.

]]> http://blogs.rev-net.com/ddewinter/2008/04/26/entity-framework-stored-procedure-generation/feed/ Interact 2008 - Day 3 http://blogs.rev-net.com/ddewinter/2008/04/14/interact-2008-day-3/ http://blogs.rev-net.com/ddewinter/2008/04/14/interact-2008-day-3/#comments Mon, 14 Apr 2008 15:48:32 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/index.php/2008/04/14/interact-2008-day-3/ The final day at Interact 2008 was a fitting end to the conference; for me it was definitely more mellow because there wasn’t a keynote, and I didn’t attend as many breakout sessions. On the other hand, I would be lying if I said I didn’t learn anything.

To replace the keynote the conference organizers had planned a "Birds of a Feather" sessions, small gatherings of about five to fifteen people each that focused on certain topics of discussion, such as "Mobilizing Unified Communications," "Voice Infrastructure," and "Architecting for a UC World." This morning Mark and I attended the "Blogging and Other Online Activities" group (you can probably guess why). There were a lot of great ideas floated not just about blogging, but also about other online collaboration tools like forums, wikis, and newsgroups.

The most interesting discussion was around forums, because there was a lot of debate concerning their effectiveness. I use forums for both technical and interpersonal reasons, so it was interesting to see that the issues of contention apply to both types of forums:

  • They are not effective tools for finding answers to questions.

The forums at MSDN are currently the only forums that I know of that allow users to mark posts as answers. Even so, what if threads have tens or even hundreds of pages? It is not easy to sift through that much content just to find an answer to your question. The forum and thread format, however, does facilitate general discussion threads, but with large threads it’s still not easy to keep track of all that’s been said.

  • Put up an FAQ list? Nobody reads it.

One thing I’ve noticed in both sets of forums is that nobody reads the FAQ. Most people just rush in and post because they want their question to receive special attention (maybe that means their question will be answered more quickly?). One brilliant idea I heard that combats this approach and steers more focus toward the FAQ is for moderators to delete threads that ask questions that are already in the FAQ.

Afterwards, I headed to the Developer Code Camp, where Paul Robicheaux presented the basics of the UCMA and Albert Kooiman did a short demo of Speech Server 2007’s capabilities. I was already familiar with Speech Server 2007, but it was very valuable to understand the purpose of the UCMA and how developers could utilize it (which I discussed yesterday). The code camp at this conference was a little rushed to cover all of the APIs we wanted to, but there was still time before the close of the conference to get hands-on experience with the APIs in the hands-on lab area.

The hands-on labs were divided into two sets depending on your interest: IT professional labs for learning about various deployment and administration scenarios for OCS and its roles, as well as and developer professional labs for developers to experiment with the various APIs (excluding the UCC API). As you can probably guess, I participated only in the developer labs. Unfortunately there was not enough to time to complete all of the labs, but the proctors allowed us to take copies of the lab manuals so we could use them later on. The three APIs I tinkered with were the OC SDK, the UCMA, and the UC AJAX SDK. My impressions? I definitely am not a fan of the AJAX SDK—it is a bit of a pain to have to type out all the XML to communicate with the CWA server role. The OC SDK and the UCMA are higher-level abstractions which are fairly easy to use. But after two days of learning about these APIs I have enough understanding to be able to build more effective applications, which I believe was the point of the code camp.

The last session I attended was a panel on planning voice architecture and deployment in Microsoft OCS; it turned out to a great opportunity to hear common deployment and administration concerns on a melange of topics like OCS interoperability with products from other vendors, 64-bit support, and Windows Server 2008 support.

Overall, Interact 2008 was a fantastic event, ripe with opportunity for everyone who attended. Through these blog posts I have highlighted the sessions themselves, but I didn’t talk much about the many connections that both of us have made through the event, who will be invaluable as develop and deploy OCS at Extend Health later this year. The conference was well worth the effort, and I will likely attend next year’s Interact as well.

The closing event was in a live music venue called Anthology, located in the Little Italy district of San Diego. As always, I’ll let the pictures do the talking (toward the bottom), but I’ll say that there are few things better than watching the Interact 2008 attendees performing karaoke. :)

The Dock Behind the Sheraton

PICT0908

PICT0911

PICT0912

PICT0915

Anthology

PICT0925

PICT0927

 PICT0934

Other Articles In Series

]]> http://blogs.rev-net.com/ddewinter/2008/04/14/interact-2008-day-3/feed/ Interact 2008 - Day 2 http://blogs.rev-net.com/ddewinter/2008/04/12/interact-2008-day-2/ http://blogs.rev-net.com/ddewinter/2008/04/12/interact-2008-day-2/#comments Sat, 12 Apr 2008 17:49:51 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/index.php/2008/04/12/interact-2008-day-2/ The second day at Interact opened with a keynote by Terry Myerson, the Corporate Vice President of Exchange, who approached the idea of Unified Communications from the email (specifically, Exchange) perspective. The previous day’s keynote covered a lot of Terry’s points, but it was interesting to hear how the Exchange team viewed their role in Microsoft’s UC platform. Even though Exchange has Unified Messaging, the team wants to move the focus to UC, not just UM, because the business problem that Microsoft is addressing is achieving people-centric communication. Thus it follows that in any UC solution, it’s people first and tools second.

Terry then touched on the topic of interoperability, discussing how Exchange ActiveSync would be leveraged by the iPhone Enterprise edition. But perhaps the most interesting part of the presentation was the demonstration of Exchange Labs, a new program geared to test the next version of Exchange. In this inaugural rollout, its target audience is select schools and universities as part of Windows Live @ edu, allowing them to connect students, alumni, faculty, and staff through email. There were two individuals who had overseen the deployment of Exchange Labs to their respective school districts with amazing results.

Terry concluded with a quotation from Thomas Jefferson: "Every generation needs a new revolution." I personally think we are seeing great advancements in the area of unified communications—this is our revolution.

Day 2 featured more sessions that appealed to developers than the previous day, so it was right up my alley. Here are the sessions I attended:

  • Microsoft Unified Communications for Developers: Building Communications into Your Applications (Albert Kooiman, Paul Robichaux)

The Microsoft Unified Communications platform enables developers to easily build secure and productivity enhancing applications atop a extensible foundation. This session will explore the concept of communications as a first class feature in Windows and Web applications through sample applications that demonstrate how to build voice, video and messaging communications into your applications along with speech and messaging based UIs. It will give an overview of the types of applications that can be built using messaging as well as software-based Voice over IP (VoIP) and will explain which APIs and SDKs are available to build those applications.

  • Developing with Exchange Web Services (Paul Robichaux, Albert Kooiman)

Exchange Server 2007 introduces new Web Services APIs to integrate information stored in Exchange into line-of-business applications. Examples include calendaring applications, contact management applications, or applications that access other content from the Exchange store, like creating editing and sending messages, handling tasks or managing contacts, etc. This session gives an overview of the Exchange Web Services APIs, and focuses on specific illustrations of how to use Exchange Web Services in your line-of-business applications. This session includes walk-throughs of code examples of how to integrate data from the store into LOB applications and third party solutions.

Both sessions were very interesting as they revealed the life cycle of the current menagerie of UC APIs (UC Client API, UC Managed API, Speech Server 2007 API, UC AJAX SDK, Office Communicator SDK, and Exchange Web Services). The first session gave an overview of the different APIs and how they interoperate with each other and which APIs are appropriate for which scenarios. Here is a very simplified version of a diagram they showed.

image

One thing that may not be familiar to you is the Media Stack component of the architecture. Speech Server 2007 obviously needs media to be able to simulate an IVR or call workflow, but UCMA doesn’t provide those capabilities. Consequently, Speech Server is built on both UCMA and the media stack (which I believe is undocumented).

There are five different platforms on which you can decide to build your application to integrate OCS and its features like presence, audio/video, conferencing, IM, and so on. Here’s a brief summary of what each platform offers:

The Office Communicator SDK is appropriate in scenarios where Office Communicator is already deployed to your end users, because the SDK is essentially a COM Automation API. You can sign in, sign out, and get contacts, groups, and presence information without exposing the OC UI, but if you actually want to initiate IM, audio, or video conversations, then using this SDK will launch the appropriate Communicator window. This is great in the case where your users are familiar with Communicator, because your application will then expose the same level of power that Communicator does with minimal development effort.

The Unified Communications Client API is a much lower level API than the OC SDK and should be used in client scenarios where deploying Communicator is not an option, or you want to expose everything (e.g. IM, audio, video) through your own application’s interface. It is a COM API that is wrapped with a simple PIA. Fortunately the documentation is fairly thorough, but it has a steep learning curve (especially for .NET-only developers).

The UC AJAX SDK is perfect for integrating your web sites with presence and IM capabilities. As its name implies, it is an AJAX-based API, and it communicates directly with the Communicator Web Access Server role (which in turn . It is definitely tedious to craft requests (as it is all XML-based) but it is the best option at this point for web-based integration.

This is what the UC AJAX SDK and part of the Speech Server API rely on to do their dirty work. This API is appropriate for server-side applications to enable scenarios like message broadcasting and IM bots that can interact with end users. Contrary to popular belief, UCMA does support publishing and querying for presence, but it is a bit lower level than the rest of the API.

Speech Server 2007 is in its own niche area, and its goal is to provide IVR solutions for customers. It is based entirely off Windows Workflow Foundation, and there is a superb set of tools that assist you with building and debugging your IVR solutions.

The pictures today are not from an evening event (because there was none), but rather just from the day as a whole.

The Beach Near the Hotel

PICT0866

PICT0869

The Sheraton Hotel (Conference Host)

PICT0872

PICT0878

PICT0879

PICT0881 

Terry Myerson (Right) During Keynote

PICT0884

Exchange Labs

PICT0885

The "Coffee Chat" Area

PICT0888

One of the Breakout Sessions

PICT0889

Beach at Night

PICT0893

Other Articles In Series

]]> http://blogs.rev-net.com/ddewinter/2008/04/12/interact-2008-day-2/feed/ Interact 2008 - Day 1 http://blogs.rev-net.com/ddewinter/2008/04/10/interact-2008-day-1/ http://blogs.rev-net.com/ddewinter/2008/04/10/interact-2008-day-1/#comments Thu, 10 Apr 2008 19:24:32 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/index.php/2008/04/10/interact-2008-day-1/ The first day of Interact 2008 was a superb opening to the conference. The day started with a keynote from Gurdeep Singh Pall, who is the "corporate vice president in the Unified Communications Group at Microsoft Corp. He is responsible for vision, product strategy and R&D for Microsoft’s Unified Communications including voice over Internet protocol (VoIP)."1 From there we had the opportunity to attend "breakout sessions," seminars led by Microsoft employees or MVPs on abstruse topics for OCS, Office Communicator (OC), and Exchange, or participate in hands-on labs—exercises also related to OCS, OC, and Exchange, aimed at developers and IT professionals.

Gurdeep’s keynote stressed three points. The first was the future of software communications. Telephony is an industry that has been dominated by hardware, and the evolution of communication systems has traditionally coincided with the evolution of phones. However, what about other means of communication such as email and IM? It is becoming apparent that software has a place in the communication industry; some would even argue that it plays a major role. By building a platform for software developers to build off in the unified communications area, Microsoft’s UC solution brings the focus away from the presence of a machine (such as a phone or a laptop) to the presence of a human being.

Gurdeep went on to explain his own version of Maslow’s Hierarchy of Needs (called Gurdeep’s Hierarchy of Needs) which addresses the needs of telecom managers. The four lower levels of the pyramid were needs analogous to Maslow’s deficiency needs. If you have them, you don’t think about them; for example, you don’t go around the office exclaiming that you have email—similarly, you don’t think about physiological needs if you have met them. The point was that once the deficiency needs are met, you can self-actualize, which encourages spontaneity and creativity for innovating solutions to business problems.

Finally, Gurdeep discussed the perspective that Microsoft brings to the UC table—moving IT into the "business zone" using three core concepts:

  • Interoperate (1 + 1 = 2)

Previously, the model for UC has been vertically integrated communications, where vendors offer their own stack of technologies to provide a comprehensive telephony solution. Microsoft wants to turn that model on its side by identifying various layers of telephony (hardware, software, devices, etc.) for which multiple vendors can offer a number of different solutions. Microsoft knows it can make advances by providing a software platform which can interoperate with existing vendors’ hardware and devices. This model will allow for industry- and enterprise-specific development and innovation—in essence, self-actualization.

  • Integrate (1 + 1 = 3)

Whereas interoperability is about making sure your platform is compatible with other platform, integration is about achieving synergy across disparate systems in an architecture. At this point, Gurdeep let Albert Kooiman and members of Clarity Consulting to demonstrate how they developed a pilot project which integrated their CRM application with the presence and communication features within Office Communicator and OCS. (This sort of integration is also what we are very attracted to for our own telephony solution.)

  • Impact

Sometimes it’s about more than just ROI. (And I’m sure some of you will disagree.) Gurdeep played a video about children at St. Luke’s Hospital who are getting a second chance at school and education through Microsoft RoundTable. There is an abridged article about the story here.

The rest of the day was filled with a variety of sessions on OCS, OC, Exchange, and various other topics. Here are the choices I made:

  • Microsoft Office Communicator 2007 Internals and Troubleshooting (Nikhil Bobde, Sam Bedekar)

Microsoft Office Communicator 2007 offers the rich client experience and brings together all exciting features that are part of the our [sic] UC offering. Understand the internals of how OC 2007 is built and the various technologies behind it. This session would cover how the client ties together the information from a variety of servers (OCS, MCUs, Edge servers, mediation server, exchange, AD and a host of other web services) to built [sic] the compelling UC scenarios. The session will cover deployment and setup of Office communicator clients and also the integration of OC into other office clients and SPS. We will walk through how to troubleshoot the most common errors/failures seen by the end user in OC UX and quickly pin point the source of failure. The session would help the attendees to gain some valuable insight into the overall client architecture.

  • Setup and Configuration Automation for Microsoft Office Communications Server 2007 (Thomas Theiner)

The planning, preparation and rollout of a system like Office Communications Server with its many components is a challenging project. Learn about the different parts and tools you can use to make this easier.

  • Advanced Validation and Troubleshooting for OCS 2007 (Byron Spurlock, Tom Laciano)

OCS 2007 troubleshooting is to provide the person(s) involved in deploying OCS an in depth insight to the tools that are available and articulate when, where, and how to use them. Leveraging the right tools and knowing what to look for can expedite troubleshooting immensely. We will take a deep dive into logs, validation tools, and diagnostic reports to view the environment from a core level. The following are just a few of areas that we will take a look at in the session: Federation issues, external users not able to connect to the internal environment, validation of the correct ports needed for remote and internal access for Voice, Video, Web Conferencing, and IM functions.

My choices may seem a bit strange knowing that I’m more of a developer than a network administrator, but I have to say that being out of my comfort zone was a great learning experience about the OCS and OC infrastructures. The troubleshooting sessions were the most helpful for me because the speakers discussed the exact steps to take when diagnosing problems both in Office Communicator and in OCS itself. Being able to recognize the problems that come up in this environment as well as knowing how to handle them is invaluable from the developer’s point-of-view, partly because the business side does not usually see the difference between the front-end components like the IVR and CRM application and the back-end servers which comprise the OCS infrastructure.

The session on the automated configuration of OCS was not as useful to me; it is interesting to know how to do it, but it’s probably not a scenario I will come up against soon.

For the closing event, Microsoft planned a night of beachside entertainment at the San Diego Wave House. I had a great time, even though I did not try to surf. (Mark did though!) It was the first time I’d been to the beach in a ong time, too. Here are some shots from the event.

The Pub World Pavilion

PICT0842

The Wave House

PICT0844

Sunset at the Beach

PICT0845

PICT0846

The Beach

PICT0847

Mark Surfing

PICT0851

The Pros at "Bruticus Maximus"

PICT0859

PICT0864

References

  1. http://www.microsoft.com/presspass/exec/gurdeep/default.mspx
  2. https://www.interact08.com/abstracts.aspx

Other Articles In Series

]]> http://blogs.rev-net.com/ddewinter/2008/04/10/interact-2008-day-1/feed/ Interact 2008 - Pre-Game Show http://blogs.rev-net.com/ddewinter/2008/04/07/interact-2008-pre-game-show/ http://blogs.rev-net.com/ddewinter/2008/04/07/interact-2008-pre-game-show/#comments Tue, 08 Apr 2008 05:10:24 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/index.php/2008/04/07/interact-2008-pre-game-show/ Mark and I flew into San Diego tonight, and wow, if you’ve never been here, prepare for some really beautiful scenery! Unfortunately I didn’t get much of a chance to take pictures outside, but I did once we got inside the "Pub World" pavilion. The first night here was phenomenal—I have never been to a Microsoft event like this before, but I am really impressed at the execution.

The event tonight was a chance for people to just get together and enjoy the evening. The pavilion had XBOX360 (Halo and some other games I didn’t recognize), pool, darts (!), air hockey, foosball, ping pong, shuffleboard, and of course, a huge screen showing the NCAA finals. Here are some photos from the event.

PICT0817

PICT0824

PICT0818

PICT0819

PICT0820

Here’s to another great day tomorrow!

]]> http://blogs.rev-net.com/ddewinter/2008/04/07/interact-2008-pre-game-show/feed/ Interact 2008 http://blogs.rev-net.com/ddewinter/2008/04/06/interact-2008/ http://blogs.rev-net.com/ddewinter/2008/04/06/interact-2008/#comments Sun, 06 Apr 2008 23:16:49 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/index.php/2008/04/06/interact-2008/ Recently my blog posts have focused on Visual Studio Extensibility, but the challenges that I have come up against at work involve vastly different technologies. One of these is in the Unified Communications space, where my team and I recently investigated the feasibility of using Microsoft’s Office Communications Server (OCS) in a contact center space. During this pilot project, I helped Ryan Hauert develop a front-end client (a scaled-back CRM application) that utilized the UCC API to interact with OCS. I also created an ACD that linked that front-end client with an IVR workflow built by Bek Yakvalkhodjiev against Speech Server 2007. Instead of using a queue to manage call routing, I used a prototype version of the algorithm that Mark Stafford explains here. The entire project took about three weeks, and that includes the time it took for all of us to learn the APIs and to set up the sandbox environment where OCS was hosted. The results were very fruitful not just for our team, but for the company as a whole to see what Microsoft has to offer versus its competitors in the UC space.

The reason I bring this up is because Mark and I will be heading to Microsoft’s Interact 2008 conference tomorrow in San Diego, California. This will be a fantastic opportunity not only to learn more about what Microsoft is bringing to the table, but also to make valuable connections with other people interested in OCS who are potentially going through the same evaluation that we are right now! If you’re interested in the contact-center-building facet of OCS and are heading to Interact ‘08, feel free to drop me a line through my blog or through my email.

]]> http://blogs.rev-net.com/ddewinter/2008/04/06/interact-2008/feed/ Dynamic Menu Commands in Visual Studio Packages - Part 3 http://blogs.rev-net.com/ddewinter/2008/04/05/dynamic-menu-commands-in-visual-studio-packages-part-3/ http://blogs.rev-net.com/ddewinter/2008/04/05/dynamic-menu-commands-in-visual-studio-packages-part-3/#comments Sun, 06 Apr 2008 01:33:20 +0000 David DeWinter http://blogs.rev-net.com/ddewinter/index.php/2008/04/05/dynamic-menu-commands-in-visual-studio-packages-part-3/ This is the final post in a series detailing how to build dynamic menu commands in Visual Studio packages. The previous posts are located here:

  • Part 1 - Discusses UI Contexts and how to utilize the built-in ones for dynamic menu commands.
  • Part 2 - Discusses the use of the BeforyQueryStatus event to provide more flexibility than built-in UI contexts.

What we’ve explored to date is a way to provide dynamic menu commands (e.g. dynamic visibility, enabled state) in our own package, and the techniques that I’ve shown thus far have worked well for this scenario. However, if you want to develop multiple menu commands or even multiple packages that rely on a custom condition (as shown in Part 2), then you’re stuck implementing the same logic in an event handler for the BeforeQueryStatus event for each OleMenuCommand.

Wouldn’t it be great if we could create our own UI Context, similar to the built-in ones like UIContext_NoSolution or UIContext_FullScreenMode? That way we can create multiple menu commands that rely on that context or even multiple packages which rely on it.

And that’s exactly what this post will cover. We’ll use the solution starting from where we left off at the end of Part 2.

Step 1: Creating New Commands

Because Part 2 covered how to create a new menu command from scratch using the VSCT file and the appropriate procedural code, I’m not going to cover the process in depth here. I’ll be creating two new menu commands, which will be part of the command set that we created in Part 2 (guidDynamicMenuDevelopmentCmdSetPart2 in the GuidList class). In the snippets that follow, the bold sections indicate what I added to achieve this:

PkgCmdIDList Class (in PkgCmdID.cs)

static class PkgCmdIDList

{

    public const uint cmdidBuiltInUIContext =        0×100;

    public const uint cmdidQueryStatus      =        0×101;

    public const uint cmdidCustomUIContext  =        0×102;

    public const uint cmdidCustomUIContext2 =        0×103;

};

DynamicMenuDevelopment.vsct File - Symbols Element

<GuidSymbol name="guidDynamicMenuDevelopmentCmdSetPart2" value="{9d9046da-94f8-4fd0-8a00-92bf4f6defa8}">

  <IDSymbol name="menuidQueryStatusGroup" value="0×1020"/>

  <IDSymbol name="cmdidQueryStatus" value="0×0101" />

  <IDSymbol name="cmdidCustomUIContext" value="0×0102" />

  <IDSymbol name="cmdidCustomUIContext2" value="0×0103" />

</GuidSymbol>

DynamicMenuDevelopment.vsct File - Buttons Element

<Button guid="guidDynamicMenuDevelopmentCmdSetPart2" id="cmdidCustomUIContext" priority="0×1" type="Button">

  <Parent guid="guidDynamicMenuDevelopmentCmdSetPart2" id="menuidQueryStatusGroup"/>

  <Icon guid="guidImages" id="bmpPicSearch"/>

  <CommandFlag>DynamicVisibility</CommandFlag>

  <Strings>

    <CommandName>cmdidCustomUIContext</CommandName>


    <ButtonText>Custom UI Context 1</ButtonText>

  </Strings>

</Button>

<Button guid="guidDynamicMenuDevelopmentCmdSetPart2" id="cmdidCustomUIContext2" priority="0×2" type="Button">

  <Parent guid="guidDynamicMenuDevelopmentCmdSetPart2" id="menuidQueryStatusGroup"/>

  <Icon guid="guidImages" id="bmpPicX"/>

  <CommandFlag>DynamicVisibility</CommandFlag>

  <Strings>

    <CommandName>cmdidCustomUIContext2</CommandName>

    <ButtonText>Custom UI Context 2</ButtonText>

  </Strings>

</Button>

In summary, I added two IDs to the PkgCmdIDList class which specify the IDs of the two new menu commands I’m going to add. Furthermore, I registered these IDs in the VSCT file using IDSymbol elements in the guidDynamicMenuDevelopmentCmdSetPart2 GuidSymbol (which I mentioned earlier). Finally, I added two buttons to the Buttons element that map directly to the commands we created. At this point, we could create handlers for these commands, but it’s really not necessary for us to achieve what we want. If you press F5 and open a project that has at least one project item in it, you’ll see our two new menu commands when right clicking on a project item:

image

(These menu commands appear in the Solution Explorer because we defined their parents as being in the Solution Explorer context menu—see Post 2 for details.)

Step 2: Implementing the Custom UI Context

For our custom UI context, let’s re-implement the functionality that the second command we created (in Post 2) did—display itself when a .dbml file is selected in the Solution Explorer but hide itself when anything else is selected. To do this we’ll need a way to tell Visual Studio what the current UI Context is. Fortunately, the SVsShellMonitorSelection service, through the IVsMonitorSelection interface, exposes the functionality to get and set the current UI context (as well as means to track the current selection). This will definitely fit our needs, but how do we receive notifications when the current selection changes?

This is where the IVsSelectionEvents interface really comes in handy. It doesn’t correspond to a specific Visual Studio service; instead, it’s used in tandem with the IVsMonitorSelection interface to receive notifications when the UI context has changed, when the current selection has changed, and when an element value has changed. The last notification is outside of the scope of this article, but this blog post may help you understand its purpose.

Is what we must do becoming clearer to you? If not, maybe the following steps will help:

  1. Create a UI context GUID that we can use for DBML file selection.
  2. Implement the IVsSelectionEvents interface.
  3. Use that implementation with the SVsShellMonitorSelection service to listen for selection events.
  4. When the selection changes to a DBML file, set the UI context that we created in Step 1 as the active UI context.
  5. Of course, the final step is to hook up our
    menu commands to this UI context to test our work.

Creating the UI Context GUID

This is probably the easiest step out of the five, as all it does is involve our creating a new GUID to put in the GuidList class that we can reference later. I’ll do this using guidgen.exe, accessible through the Tools > Create GUID option in Visual Studio. The result looks like this:

static class GuidList

{

    public const string guidDynamicMenuDevelopmentPkgString = "d626ae3e-6eaa-414f-9a74-4f41fb902a23";

    public const string guidDynamicMenuDevelopmentCmdSetString = "a9d25ef1-3235-4a08-8c93-f26619635e91";

    public const string guidDynamicMenuDevelopmentCmdSetPart2String = "9d9046da-94f8-4fd0-8a00-92bf4f6defa8";

    public const string UICONTEXT_DbmlFileSelectedString = "203116D4-FC70-48d8-A4E8-2467F58B1F65";

 

    public static readonly Guid guidDynamicMenuDevelopmentCmdSet = new Guid(guidDynamicMenuDevelopmentCmdSetString);

    public static readonly Guid guidDynamicMenuDevelopmentCmdSetPart2 = new Guid(guidDynamicMenuDevelopmentCmdSetPart2String);

    public static readonly Guid UICONTEXT_DbmlFileSelected = new Guid(UICONTEXT_DbmlFileSelectedString);

};

Implementing the IVsSelectionEvents Interface

This interface is fairly straightforward to implement. Before getting into the code, remember that we are checking what the new selection is when it changes. If it’s a DBML file in the Solution Explorer, then we activate our UI context. Here’s what my implementation looks like:

/// <summary>

/// Our implementation of the <see cref="IVsSelectionEvents"/> interface,

/// used to set a custom UI context GUID.

/// </summary>

private class SelectionEvents : IVsSelectionEvents

{

    private static IVsMonitorSelection SelectionService;

    private static uint ContextCookie = RegisterContext();

 

    private static uint RegisterContext()

    {

        // Initialize the selection service

        SelectionService = (IVsMonitorSelection)Package.GetGlobalService(typeof(SVsShellMonitorSelection));

 

        // Get a cookie for our UI Context. This "registers" our

        // UI context with the selection service so we can set it again later.

        uint retVal;

        Guid uiContext = GuidList.UICONTEXT_DbmlFileSelected;

        SelectionService.GetCmdUIContextCookie(ref uiContext, out retVal);

 

        return retVal;

    }

 

    // We don’t care about either of these methods, but it’s useful to know what they do.

    int IVsSelectionEvents.OnCmdUIContextChanged(uint dwCmdUICookie, int fActive)

    {

        return VSConstants.S_OK;

    }

    int IVsSelectionEvents.OnElementValueChanged(uint elementid, object varValueOld, object varValueNew)

    {

        return VSConstants.S_OK;

    }

 

    int IVsSelectionEvents.OnSelectionChanged(IVsHierarchy pHierOld, uint itemidOld,

        IVsMultiItemSelect pMISOld, ISelectionContainer pSCOld,

        IVsHierarchy pHierNew, uint itemidNew,

        IVsMultiItemSelect pMISNew, ISelectionContainer pSCNew)

    {

        if (pHierNew != null)

        {

            object fileName;

            pHierNew.GetProperty(itemidNew, (int)__VSHPROPID.VSHPROPID_Name, out fileName);

 

            if (fileName != null && fileName.ToString().EndsWith(".dbml"))

            {

                // If we meet the conditions, set the UI context to be active.

                SelectionService.SetCmdUIContext(ContextCookie, 1);

                return VSConstants.S_OK;

            }

        }

        // Otherwise, deactivate it.

        SelectionService.SetCmdUIContext(ContextCookie, 0);

 

        return VSConstants.S_OK;

    }

}

The implementation should make sense based off my previous article. When the selection changes, we inspect the new IVsHierarchy to find its selection. If the name of the selection ends with ".dbml", then we are dealing with a DBML file. We activate the UI context in this case, and deactivate it in all other cases. Before any of that happens, though, we have to register the UI context GUID with the SVsShellMonitorSelection service, which is what the RegisterContext() method does. The cookie that we receive from the call to IVsMonitorSelection.GetCmdUIContextCookie() is then used to set the UI context later on. There’s a bit of a trickery involved here to understand what’s going on, but most of it should be self-evident.

Registering the Selection Event Listener

Now that we have a listener for the selection events, we need to register it with the selection service. To do this, add this to the Initialize() method in our package:

mySelectionEvents = new SelectionEvents();

IVsMonitorSelection selectionService = (IVsMonitorSelection)this.GetService(typeof(SVsShellMonitorSelection));

selectionService.AdviseSelectionEvents(mySelectionEvents, out mySelectionEventsCookie);

Here, mySelectionEvents and mySelectionEventsCookie are private fields in the package class. The only unfamiliar territory is the IVsMonitorSelection.AdviseSelectionEvents method. Now, I am by no means a COM expert, but this pattern of advising for events and then unadvising for them later on seems to be a common task for applications that interact with COM. The fact that we can unadvise for the events implies that there is a unique identifier for an "advise." This unique identifier is the cookie that is passed by reference into the call for advising for selection events. We store this value in a private field so we can unadvise at an appropriate time i.e. in the package’s Dispose method:

protected override void Dispose(bool disposing)

{

    IVsMonitorSelection selectionService = (IVsMonitorSelection)this.Ge
tService(typeof(SVsShellMonitorSelection));

    if (selectionService != null)

    {

        selectionService.UnadviseSelectionEvents(mySelectionEventsCookie);

    }

 

    base.Dispose(disposing);

}

Hooking Up the Menu Commands

It’s been a long toll, but we’re almost to the end! The last step is to hook up our two menu commands to the UI context we created. Part 1 shows how to do this with built-in UI contexts, and doing it with a custom one is no different. The first step is to add the GUID for our custom UI context to the Symbols element. Then, we add VisibilityItem elements to the VisibilityConstraints section which hook up the menu commands to that context.

The GUID Symbol for the Custom UI Context

<GuidSymbol name="UICONTEXT_DbmlFileSelected" value="{203116D4-FC70-48d8-A4E8-2467F58B1F65}" />

The Visibility Constraints

<VisibilityConstraints>

  <VisibilityItem guid="guidDynamicMenuDevelopmentCmdSet" id="cmdidBuiltInUIContext" context="UICONTEXT_NoSolution" />

  <VisibilityItem guid="guidDynamicMenuDevelopmentCmdSetPart2" id="cmdidCustomUIContext" context="UICONTEXT_DbmlFileSelected" />

  <VisibilityItem guid="guidDynamicMenuDevelopmentCmdSetPart2" id="cmdidCustomUIContext2" context="UICONTEXT_DbmlFileSelected" />

</VisibilityConstraints>

Step 3: The Results!

Now that we’ve gone through that rigmarole, press F5 and load a project with a DBML file in it (or create a DBML file in some file). You’ll see that our two new menu commands (as well the menu command we implemented with the BeforeQueryStatus event handler in Part 2) show up only when right clicking on a DBML file.

image

This concludes both this article on building custom UI contexts and this series on dynamic menus in Visual Studio. I hope this and the past articles help in you Visual Studio Package development!

Associated Solution

Other Articles in the Series