Webucator recently teamed up with Microsoft to present a webinar designed to explore the architecture of search in SharePoint 2010, the components that are part of this service application, what they are used for and how they differ from what was available in SharePoint 2007. The webinar also covered the changes in this search architecture when you deploy FAST Search for SharePoint.

You can also learn more about SharePoint by exploring our SharePoint training, and more specifically, our SharePoint 2010 Search and FAST Search Server 2010 Training.

[youtube:http://www.youtube.com/watch?v=ZiMBcVmgZlE=505&w=640]

This is a video demonstration of how to create a basic Web Part for SharePoint 2010 using Visual Studio 2010. The intent of the video is to showcase how easy it is to create, package and deploy a Web Part into a test environment with the latest tools. The demonstration was done on a Virtual Machine running under Hyper-V with Visual Studio installed along side SharePoint. If you have any questions for us, leave a comment below. Enjoy!

SharePoint 2010 Video Tutorial

Creating a SharePoint 2010 Web Part with Visual Studio 2010

[youtube:http://www.youtube.com/watch?v=mFHQYQIMVPk=700&w=900]

Want more? Try our SharePoint training options!

Explore the architecture of search in SharePoint 2010, with Leonardo Souza, Senior Technical Instructor at Microsoft. The free, 60-minute webinar will cover the components that are part of this application and their uses. Souza will also explain how the SharePoint 2010 components differ from what was available in SharePoint 2007. Souza will cover the changes in this search architecture when you deploy FAST Search for SharePoint.  

After this webinar, attendees will have a better understanding of how the pieces of this search puzzle fit together and how you can architect, size and scale your search solutions in SharePoint 2010.

Click to register for the SharePoint webinar.

About the Presenter
Leonardo Souza, Senior Technical Instructor at Microsoft, is a professional with more than ten years of experience working with Microsoft technologies and over half a decade dedicated to the search industry, helping organizations implement powerful search solutions either working directly in the field or teaching search-focused classes from Brazil to China.

About Webucator 
Webucator provides online and onsite business and technical training, including Microsoft Training, SharePoint Training and more.

(The following is a guest blog from Neil Tucker, MOC 50331 trainer and course developer)

The 50331 course is designed to help candidates who want to work as and pass the Windows 7 Enterprise Desktop Support Technicians. It includes features to improve the learning experience of students and make it easier to review the material during and after class.

These features include the following:

1. Interactive Simulations: The students can use simulations to practice the lab exercises. The interactive nature of these simulations allows you to go back and forth through each step so the lab can be repeated as many times as you wish. Students are given copies of these simulations so they can easily redo lab exercises without a specialized classroom setup.
2. Modular Course Delivery: The course is designed so that the chapters/modules can be delivered in any order. For organizations that have specific Windows 7 knowledge requirements for their technicians, modules can be skipped or rearranged with no difficulties and no lab associated problems.
3. “Resolve” sections: Each module has a Resolve section where real world examples are included to help the students apply what they learn to a specific scenario. Possible answers to each scenario are also included.
4. Appendices: The appendix includes answers to end-of-module review questions, lab questions and a simplified version of the lab exercises. There is also an optional PowerShell tutorial for those who want to learn and practice using this feature.

In additional to the above features of the course, additional updates have been made to the latest revision including:

1. Assessment Tests: A pre-assessment and post-assessment test is now included with the course. These multiple-choice exams use a pool of randomized questions to help students assess their knowledge before and after the class. For those preparing for the certification tests, it helps them to study more efficiently by highlighting sections where more review is needed.
2. Content Updates: Based on feedback from students and trainers, some of the content has been updated. More details have been added to make the practical exercises easier, the group policy, virtualization & cloud related content has been updated and new security and IE9 content added.

A lot of information for Windows 7 technicians is covered in this 5-day course, but the tools and content have been organized to make the material easier to digest and review, even after the class is over. To learn more about the upcoming classes, view the MOC 50331 training schedule.

We’ve recently developed new resources to help clients achieve their Microsoft certification goals. We now offer a directory of Microsoft certification training, organized according to specific certification paths and the associated courses. More specifically, we have Microsoft SharePoint certification training, and Microsoft Visual Studio certification training,

The certification directory contains a wide variety of Microsoft certification paths including SharePoint, SQL, Dynamics, .Net, and more. Within each path, we’ve listed the available Microsoft Official Courses, which will help the applicant prepare for the certification exam. To help visitors learn more about the final exams, we also listed the exam links for each specific certification, to help visitors learn more about the final exams.

Here’s a cool video from Microsoft showing the value of becoming certified:

To view the new Microsoft Certification Training Directory, click here. To check out all of our .NET 4.0 training, click here.

Join our Microsoft Certified Trainers as they answer questions about Microsoft Certification. This clip was taken from a recent webinar.

Microsoft Certification Tips

[youtube:http://www.youtube.com/watch?v=EgiKkA4_GYI&h=505&w=640]

Click to see our Microsoft Certification Training directory to explore the courses that help you prepare for the certification exams. You can also view our full listing of Microsoft training.

Hear about our latest webinars by subscribing to our newsletter. Click here to subscribe.

Watch this recorded webinar to learn to use the new features in Windows 7 to benefit your organization. The presenter also explains the new Windows 7 certification options and suggests appropriate paths. 

What Every Technician Should Know About Windows 7

[youtube:http://www.youtube.com/watch?v=p2EiMnlWaC0&h=505&w=640]

Learn more about our  Microsoft training. Hear about our latest webinars by subscribing to our newsletter. Click here to subscribe.

Learn how to develop Silverlight applications for SharePoint 2010, from the MOC 10175A Microsoft SharePoint 2010, Application Development course. This webinar includes concepts from our SharePoint 2010 training classes to provide a brief overview of the integration between Silverlight and SharePoint 2010, using the SharePoint client object model.

Developing Silverlight Applications for SharePoint 2010

[youtube:http://www.youtube.com/watch?v=iAhDiaazBaQ&h=505&w=640]

Hear about our latest webinars by subscribing to our newsletter. Click here to subscribe.

Prior to .NET, Visual Basic had one logical conjunction (And) and one logical disjunction (Or). Thus, we consider this block of code:

If x = 1 And y = 1 Then
   ' Do Something
End If

When this If statement is evaluated, both statements will be checked.  However, what if x = 1 is false?  Do we really need to check y = 1?

The answer is that we do not need to check the second statement.  In fact, we can actually short-circuit the If statement by using the following:

If x = 1 AndAlso y = 1 Then

The benefit of this statement is in the performance of your code.  By eliminating the check of the second statement, if the first statement is already false, is reducing the amount of time and resources needed to process this If statement.  While the statement above is quite simple, image if you have a much more complex If statement with a number of expressions to be evaluated.

Likewise, we can also use this statement:

If x = 1 OrElse y = 1 Then

As with the AndAlso statement, this statement will short-circuit the checking process if the first statement is true.

So, when you start typing out your next compound if statement, remember the AndAlso and OrElse keywords.  While these keywords may be rather verbose, at least your code will be more efficient.

Get the latest tips, tutorials, and news about our classes by email! Click here to sign up for our newsletter!

Check out this video demonstration on using the Silverlight DataForm control and the DomainDataSource control with WCF RIA Services. This video is a continuation of my previous video on getting started with RIA Services in Silverlight 4.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight networking is covered in our Comprehensive Microsoft Silverlight 4 course.

Get the latest tips, tutorials, and news about our classes by email! Click here to sign up for our newsletter!

Check out this video demonstration on using WCF RIA Services in Silverlight 4 with Visual Studio 2010.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight networking is covered in our Comprehensive Microsoft Silverlight 4 course.

Get the latest tips, tutorials, and news about our classes by email! Click here to sign up for our newsletter!

Check out this video on how to update the UI in Silverlight automatically when an bound object’s property changes.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight data binding is covered in our Comprehensive Microsoft Silverlight 4 course.

Get the latest tips, tutorials, and news about our classes by email! Click here to sign up for our newsletter!

Check out this video on how to create Silverlight easing functions using Blend 4.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight easing functions and Blend 4 are covered in our Comprehensive Microsoft Silverlight 4 course.

Check out this video on how to configure Forms-Based Authentication in SharePoint 2010. Additionaly the video demonstrates how to manage membership accounts using IIS administrators console.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Forms Based Authentication is covered in our SharePoint 2010 course SharePoint 2010 Configuration and Administration.

Check out this video on how to use SharePoint Designer 2010 to create an association between two external content types. You can watch my previous video on creating External Content Types that this video builds onto.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

External content types are covered in our SharePoint 2010 course SharePoint 2010 Application Development class.

Check out this video on how to use SharePoint Designer 2010 to create external content types.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

External content types are covered in our SharePoint 2010 course SharePoint 2010 Application Development class.

Check out this video demonstration of how to edit a SharePoint 2010 site’s Web.config file using SPWebConfigModification.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Web.config modifications are covered in our SharePoint 2010 course SharePoint 2010 Application Development class.

In many cases, if you have not done an extensive review of the .NET Framework, you probably haven’t discovered some rather interesting features that exist.  One such feature is the BitVector32 structure.  I would suspect that only those of us who have spent any time preparing for taking a certification exam are familiar with BitVector32.

The BitVector32 structure is in the System.Collections.Specialized namespace.  Essentially, it is a single array (vector) of 32 bits, where a value of one corresponds to true (on) and a value of zero is false (off).  By default, when creating a new BitVector32 object, you will start with all of the bits turned off.  As an alternative, you can pass a parameter into the constructor to turn on some of the bits.  If you want all of the bits turned on, pass the value of -1, which is the bitwise complement to zero.  This is demonstrated in the following code:

BitVector32 bvOff = new BitVector32();
BitVector32 bvOn = new BitVector32(-1);
BitVector32 bvDemo15 = new BitVector32(15);

Console.WriteLine("Output:");
Console.WriteLine("bvOff    = {0}", bvOff.ToString());
Console.WriteLine("bvOn     = {0}", bvOn.ToString());
Console.WriteLine("bvDemo15 = {0}", bvDemo15.ToString());

//Output:
//bvOff    = BitVector32{00000000000000000000000000000000}
//bvOn     = BitVector32{11111111111111111111111111111111}
//bvDemo15 = BitVector32{00000000000000000000000000001111}

The BitVector32 structure is powered by two methods: CreateMask and CreateSection.

The CreateMask method is a static method that allows for the creation of a series of masks that turns the BitVector32 object into a set of bit flags.  We see this in the following example:

BitVector32 bvDemo = new BitVector32();

int[] aintMasks = new int[5];

for (int i = 0; i < 5; i++)
{
	if (i == 0)
		aintMasks[i] = BitVector32.CreateMask();
	else
		aintMasks[i] = BitVector32.CreateMask(aintMasks[i - 1]);
}

Console.WriteLine("Output after setting each mask to true:");

foreach (int intMask in aintMasks)
{
	bvDemo[intMask] = true;

	Console.WriteLine("intMask = {0}\tbvDemo = {1}", intMask, bvDemo.ToString());

	bvDemo[intMask] = false;
}

//Output after setting each mask to true:
//intMask = 1     bvDemo = BitVector32{00000000000000000000000000000001}
//intMask = 2     bvDemo = BitVector32{00000000000000000000000000000010}
//intMask = 4     bvDemo = BitVector32{00000000000000000000000000000100}
//intMask = 8     bvDemo = BitVector32{00000000000000000000000000001000}
//intMask = 16    bvDemo = BitVector32{00000000000000000000000000010000}

As you can see from the results, CreateMask without a parameter sets the first mask to the first bit.  By using the previous bit flag as the parameter, we set the mask on the next bit value within the BitVector32 object.  Of course, we can extend this so that we have masks on all 32 bits.

With the CreateSection method, we can parse the BitVector32 object into a series of sections based on a set of short integers.  In the following example, we create four sections based on the values of 1, 3, 7, and 15 respectively.

BitVector32 bvDemo = new BitVector32();

BitVector32.Section bvsSection1 = BitVector32.CreateSection(1);
BitVector32.Section bvsSection2 = BitVector32.CreateSection(3, bvsSection1);
BitVector32.Section bvsSection3 = BitVector32.CreateSection(7, bvsSection2);
BitVector32.Section bvsSection4 = BitVector32.CreateSection(15, bvsSection3);

Console.WriteLine("Initial section values:");
Console.WriteLine("\tSection1: {0}", bvDemo[bvsSection1]);
Console.WriteLine("\tSection2: {0}", bvDemo[bvsSection2]);
Console.WriteLine("\tSection3: {0}", bvDemo[bvsSection3]);
Console.WriteLine("\tSection4: {0}", bvDemo[bvsSection4]);

Console.WriteLine();
Console.WriteLine("BitVector32 output after setting each section to different values:");
Console.WriteLine("\tInitial:         {0}", bvDemo.ToString());

bvDemo[bvsSection1] = 1;
Console.WriteLine("\tSection1 =  1:   {0}", bvDemo.ToString());

bvDemo[bvsSection2] = 2;
Console.WriteLine("\tSection2 =  2:   {0}", bvDemo.ToString());

bvDemo[bvsSection3] = 5;
Console.WriteLine("\tSection3 =  5:   {0}", bvDemo.ToString());

bvDemo[bvsSection4] = 11;
Console.WriteLine("\tSection5 = 11:   {0}", bvDemo.ToString());

Console.WriteLine();
Console.WriteLine("New section values:");
Console.WriteLine("\tSection1: {0}", bvDemo[bvsSection1]);
Console.WriteLine("\tSection2: {0}", bvDemo[bvsSection2]);
Console.WriteLine("\tSection3: {0}", bvDemo[bvsSection3]);
Console.WriteLine("\tSection4: {0}", bvDemo[bvsSection4]);

//Initial section values:
//        Section1: 0
//        Section2: 0
//        Section3: 0
//        Section4: 0

//BitVector32 output after setting each section to different values:
//        Initial:         BitVector32{00000000000000000000000000000000}
//        Section1 =  1:   BitVector32{00000000000000000000000000000001}
//        Section2 =  2:   BitVector32{00000000000000000000000000000101}
//        Section3 =  5:   BitVector32{00000000000000000000000000101101}
//        Section5 = 11:   BitVector32{00000000000000000000001011101101}

//New section values:
//        Section1: 1
//        Section2: 2
//        Section3: 5
//        Section4: 11

A practical usage for the BitVector32 sections would be associating each section to a multiple-choice question for a test or a survey.  For example, when using four possible choices for each question, each section could be set to a value of 3 which would allow for the values of 0 (00), 1 (01), 2 (10), or 3 (11).  Thus, you could create a test or survey that had up to 16 questions.

The BitVector32 structure provides .NET developers with another choice in how to gather and process bit data.  In addition to some of its practical uses, it is a very interesting component within the .NET Framework. To learn more about the .NET Framework features, consider our .NET training.

Check out this video demonstration of how to create a SharePoint 2010 dialog window.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Dialog windows are covered in our SharePoint 2010 course SharePoint 2010 Application Development class.

Check out this video demonstration of how to update a Microsoft Silverlight application running out-of-browser.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight out-of-browser features are covered in our Comprehensive Microsoft Silverlight 4 course.

Having recently sat and passed Microsoft SharePoint 2010 developer exams 70-573 and 70-576 I thought I would share what I used to prepare as well as thoughts on the exams themselves!

First, about the 70-573 exam.  Passing this exam will earn you the MCTS: SharePoint 2010, Application Development certification.  The MCTS acronym is for Microsoft Certified Technology Specialist.  The exam was pretty straight forward with scenarios and code samples.  At the beginning of the exam you can choose to see code in either VB.Net or C#.  In preparation for this exam I used and would recommend the following:

• Our online instructor led course MOC: 10175.  This course does a good job of covering at least 80 percent of what you’ll see on this exam. That’s not an official number; it’s based on my own educated guess.  There are a few areas that are not covered in this course that you are likely to see on the exam.  Topics that I encountered on my own exam included:
  • Developing custom search solutions.
  • Developing Timer jobs.
  • Creating custom Field controls.

  Here’s a book for additional topics or self study I liked “SharePoint 2010 as a Development Platform” published by Apress.  It’s a massive volume at over a thousand pages but it’s one of the most complete reference books I’ve found out there.  The authors do a good job in showing code examples as well as explaining concepts. This book doesn’t go into Timer jobs but there are plenty of references on the Web for that topic.

The 70-576 exam is the “Pro” level exam.  Passing this exam in addition to the 70-573 exam will earn you the MCPD: SharePoint Developer 2010 certification.  The MCPD acronym is for Microsoft Certified Professional Developer.  I found this exam to be a bit more awkward to classify.  It had elements that are more IT admin based as well as stuff that is developer based.  As with the 70-573 exam you can choose either VB.Net or C# at the beginning but I encountered very little code on my exam.  The questions where more scenario based and had you making decisions on best practices and efficiency.  In preparation for this exam, I used and would recommend the following:

• Our online instructor led course MOC: 10232.  This course covers just about everything you’ll see on this exam.  If I had to quantify it I’d say it would be in at least the 80 percent range.  Like the MOC: 10175 course for the 70-573 exam, there are a couple of topics that are on the exam but not covered in the course.  Uncovered topics that I found on my exam included:
  • Developing custom search solutions.
  • Developing Timer jobs.

  A book for additional topics or self study that I liked is “Professional SharePoint 2010 Development” published by Wrox.  The book is deceptively thin page wise.  This is due to most of the code not being included in the printed text but in downloadable Visual Studio solutions.  The book did do a nice job covering topics such as custom Search solutions.

While passing these exams and holding the certifications isn’t necessarily the best measure of your proficiency in SharePoint, it does provide something solid to be measured with.  In addition to that, just studying and preparing for these exams will force you to explore topics that might not have explored otherwise.  In some people’s cases, such as my own, the certifications are required for your job.  Overall I felt the exams where fair and followed their published objectives.  I hope that this information will be useful to others that are either required or just desire to obtain the certifications.

Check out this video demonstration of how to use WCF Data Services to preform batched updates to list data in a SharePoint 2010 site. This is an extension of an earlier video demonstration of how to query a SharePoint site using Data Services. WCF Data Services is also know as ADO.NET Data Services and is an easy way to implement REST in the .NET Framework.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Silverlight integration into SharePoint 2010 is covered in our SharePoint 2010 Application Development class.

Check out this video demonstration of how to create a SharePoint 2010 Event Receiver using Visual Studio 2010. Along the way I point out various features within Visual Studio that make this task very easy.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Event receivers are covered in our SharePoint 2010 course SharePoint 2010 Application Development class.

Check out this video demonstration of how to create a SharePoint 2010 custom list definition without a content type using Visual Studio 2010. There are numerous examples of how to create list definitions that include a content type. I wanted to demonstrate a simpler example without a content type.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Custom list definitions are covered in our SharePoint 2010 course SharePoint 2010 Application Development class.

Check out this video demonstration of how to use the SharePoint 2010 and WCF Data Services API with Microsoft Silverlight. WCF Data Services is also know as ADO.NET Data Services and is an easy way to implement REST in the .NET Framework.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Silverlight integration into SharePoint 2010 is covered in our SharePoint 2010 Application Development class.

In May, I posted an article on our potential SharePoint 2010 classes. We are now offering many of these SharePoint 2010 classes regularly. Because SharePoint is so huge, it can be difficult to know which course is right for you.  To help prospective clients determine the right mix and sequence of SharePoint 2010 courses for them, we use the following grid as a guide:

SharePoint 2010 Training Reference Guide (Click image below to open PDF version)

If you need SharePoint 2010 training, please check our list of SharePoint 2010 classes or contact us for more details.

Check out this video demonstration of the basics of C# Lambda expressions using Visual Studio 2010.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Lambda expressions are covered in our MOC 10266 – Programming in C# 4.0 with Visual Studio 2010 course.

Check out this video demonstration of how to get started programming the Entity Framework using Visual Studio 2010.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight client access policies are covered in our Comprehensive Microsoft Silverlight 4 course.

Check out this video demonstration of how to use the SharePoint 2010 client API for Microsoft Silverlight.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Silverlight integration into SharePoint 2010 is covered in our SharePoint 2010 Application Development class.

Check out this video demonstration of how to manage large lists in SharePoint 2010. In this video I work with a list that has over 5000 items in it.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Managing SharePoint lists is covered in several of our SharePoint 2010 courses.

Check out this video demonstration of how to access a SharePoint list using Microsoft Silverlight. In this video I retrieve data using the SharePoint 2010 Web Services API.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Silverlight integration into SharePoint 2010 is covered in our SharePoint 2010 Application Development class.

Check out this video demonstration of how to create and use a client access policy in Microsoft Silverlight using Visual Studio 2010. Client access policies are necessary when Microsoft Silverlight makes a call to a website other than the site the Microsoft Silverlight application originates from.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight client access policies are covered in our Comprehensive Microsoft Silverlight 4 course.

Check out this video demonstration of how to create keyframe animations for Microsoft Silverlight using Expression Blend 4. The animation is done entirely through the Expression Blend 4 designer including starting the animation with a mouse click on the animated control.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight animations are covered in our Comprehensive Microsoft Silverlight 4 course.

Check out this video demonstration of how to create a basic animation in Microsoft Silverlight using Expression Blend 4. The animation is done entirely through the Blend 4 designer including starting the animation with a mouse click on the animated control.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Microsoft Silverlight animations are covered in our Comprehensive Microsoft Silverlight 4 course.

The following exercises I wrote for a SharePoint Developers course but I thought the steps could come in handy for any SharePoint 2007 site. The first exercise demonstrates a nice little short cut to get the site’s web.config file configured for AJAX. Server names and directory paths would need to be modified for the environment you are working in.

Exercise 1: Configuring the Web Site’s Web.config for the .NET 3.5 Framework and AJAX

1. Open Visual Studio 2008.
2. Click File -> Open -> Web Site.
3. Browse to c:\inetpub\wwwroot\wss\Virtualdirectory\100
4. Click “Open”
5. Make sure you click “Yes” to the displayed dialog box asking if you want to convert the Web site to the 3.5 Framework.

   Note: Clicking yes to this dialog will get Visual Studio to make most of the necessary changes to the site’s web.config file necessary for AJAX to work.
   

6. Add a reference to System.Web.Extensions to the SafeControls list.
   • Locate the <SafeControls> element and add a new blank line to the end of the list of <SaveControl>’s just before the </SaveControl> element.
   • Add the following <SafeControl> element in the new line.

     <SafeControl
     Assembly=“System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35”
     Namespace=“System.Web.UI”
     TypeName=“*”
     Safe=“True“ />
     

     Note: The web.config file is case sensitive so be careful of your typing.

7. Add the AjaxControlToolkit.dll to the Global Assembly Cache.
   • Open two Windows Explorer Windows.
   • In one window navigate the folder containing the AjaxControlToolkit.dll file.
   • In the second window navigate to the C:\Windows\Assembly folder.
   • Drag the AjaxControlToolkit.dll file from the one window into the Assembly folder window.

     Note: You cannot copy and paste into the GAC you must drag and drop.

8. Add a reference to the AjaxControlToolkit.dll in the Web site’s web.config file.
   • Locate the <compilation><assemblies> element and add a new line to the bottom of the <add> elements list, before the </assemblies> end element.
   • Add the following new <add> element in the new line.

     <add
     assembly=“AjaxControlToolkit, Version=3.0.20820.16598, Culture=neutral, PublicKeyToken=28f01b0e84b6d53e“ />
     

     Note: The web.config file is case sensitive so be careful of your typing.
     

9. Register the AjaxControlToolkit’s tag prefix within the Web site’s web.config file.
   • Locate the <pages><controls> element and add a new line to the bottom of the <add> elements list, before the </controls> end element.
   • Add the following new <add> element in the new line.

     <add
     namespace=“AjaxControlToolkit“
     assembly=“AjaxControlToolkit“
     tagPrefix=“ajaxToolkit“ />
     

     Note: The web.config file is case sensitive so be careful of your typing.
     

10. Save the changes you’ve made to the site’s web.config file.
11. Open Internet Explorer and browse to the site to make sure it still works and there aren’t any errors in the web.config file.

Exercise 2: Add a ScriptManager to the MasterPage

1. Open SharePoint Designer 2007 to your team site.
2. Open up the master page for your site (/_catalogs/masterpage/default.master).
3. Add the following into the markup of your page. A recommended location is right beneath the WebPartManager registration (search for <WebPartPages:SPWebPartManager id=”m” runat=”server” />):

   <asp:ScriptManager runat=”server” ID=”ScriptManager1″></asp:ScriptManager>

4. Save the page.
5. If you get a popup, click “Yes” to customize the page.

Exercise 3: Creating an AJAX Web Part Project

1. Open a new Instance of Visual Studio 2008.
2. Click File -> New -> Project.
3. From the Project Types list click “SharePoint” and then choose the “Web Part” template.
4. Name the new project “AjaxDemoWP” and click “Ok”.
5. Choose “Full Trust (Deploy in GAC)” for the trust level and click “Ok”.
6. Rename WebPart1 to AjaxExamplePart.
   • Right click the folder icon in Solution Explorer named “WebPart1″.
   • Choose “Rename” from the menu.
   • Type the name “AjaxExamplePart”.
   • Select “Yes” to the dialog box asking if you would like VSeWss to also rename all associated Web Part files.
7. Create a reference to the AjaxControlToolkit.dll file.
   • You’ll have use the Browse tab to locate that file somewhere on your D or C drive.
8. Create a reference to the System.Web.Extensions.dll assembly file.
   • You should be able to create this reference using the .NET tab in the reference dialog box.
9. Edit the AjaxExamplePart.xml file to provide a group name for it to display under in the Web Part catalog.
   • Change the current “File” element from this:

     <File
     Path=“AjaxExamplePart.webpart“
     Url=“AjaxExamplePart.webpart“
     Type=“GhostableInLibrary“ />
     

   • To this:

     <File
     Path=“AjaxExamplePart.webpart“
     Url=“AjaxExamplePart.webpart“
     Type=“GhostableInLibrary“>
     

     <Property
     Name=“Group“
     Value=“Ajax Web Part Demo“ />
     

   </File>
   

10. Edit the “CreateChildControls()” method to have the following lines of code inside the method:

    base.CreateChildControls();
    var tb = new TextBox();
    tb.ID = “theLabel”;
    var ce = new AjaxControlToolkit.CalendarExtender();
    ce.TargetControlID = tb.ID;
    Controls.Add(tb);
    Controls.Add(ce);

11. Set the project’s debug property browser URL. �
    • Right click the project “AjaxDemoWP”.
    • Select the “Properties” menu item
    • Select “Debug” in the properties page.
    • Set the “Start browser with URL:” to your servers address. In my case that’s http://virsrv08:100/.
    • Right click the “AjaxDemoWP” properties tab and choose “Save Selected Items
    • Press the F5 key to build, package, deploy, reset IIS and open the browser with to the site’s home page.



12. Add the new AjaxDemoWP Web Part to the site’s home page.
    • Click Site Actions -> Edit Page.
    • In the Left web part zone click “Add a Web Part”.
    • In the “Add Web Parts” window scroll down until you find the “Ajax Web Part Demo” group.
    • Check the box next to the “AjaxExamplePart Web Part” and click the “Add” button.
    • Click on the “Exit Edit Mode” link and you should see your Web Part displayed on the page looking like a TextBox but it should display a calendar when you click on it. 

Close the browser window to exit debug mode.
This topic is are covered in our SharePoint Developer course offerings.

This is a video demonstration of how to enable Forms authentication in a SharePoint 2007 site. In addition I demonstrate how to use IIS 7 running on Server 2008 to create and configure user accounts for Forms authentication.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Themes are covered in several of our SharePoint course offerings.

This is a video demonstration of how to view data validation exceptions in Silverlight 4. Silverlight silently suppresses exceptions that occur when invalid data is applied to a bound object. Setting the binding expressions ValidatesOnExceptions to true will cause the UI controls to automatically display any validation errors generated by the bound data.

[

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Data binding and validation are covered in our Comprehensive Silverlight 4 training course.

This is a video demonstration of how to create a custom theme for use in a SharePoint 2007 installation. Custom themes are one way to brand your SharePoint site without having to write any code and offer easy reusability across multiple sites.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Themes are covered in several of our SharePoint course offerings.

This is a video demonstation of how to create a custom control template for a Silverlight application using Expression Blend 4. Blend makes it very easy to take a shape or a path and turn it into a control such as a button. Adding some flair to the control is just as easy using the pre-built states that Blend generates as I demonstrate in the video.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Silverlight 4 control templates and Blend 4 are covered in our new Silverlight 4 class.

In this video I demonstrate how to add a bit of animation to a Silverlight 4 application using the FluidMoveBehavior from Expression Blend 4. Behaviors are a way to wrap UI functionality into something that can be easily reused. In fact, in Expression Blend you can simply drag and drop the behavior from the “assets” panel onto the control you want the effect to apply to. No code is required once the behavior has been defined and Blend 4 has 13 different behaviors predefined that you can use. This video showcases one of those predefined behaviors, the FluidMoveBehavior.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Silverlight behaviors are covered in our new Silverlight 4 class.

I have posted several short video demonstrations of various aspects of building a Silverlight application.  The application was purposefully simple in order to highlight some of the new tools and techniques in Visual Studio 2010 as well a one video using Expression Blend 4.  The main functionality of the Silverlight app was to make a call to a WCF service that returned back a collection of employee objects with data from the Employees table in Northwind’s database.  In my first few videos I was only getting a few fields of data.  In my last video I wanted to add the Photo field from the Employees table.  It seemed like an easy task but as is the case with many things it turned out to be a bit more complicated in the end.

The photo field in Northwind’s Employees table is typed as the older image data type.  My first attempt was to just read the bytes from the table and pass them directly into a byte array field that I created in my Employee class.  I used the following code:

string query = "Select EmployeeID, FirstName, LastName, BirthDate, Photo From Employees";
var cmd = new SqlCommand(query, con);
con.Open();
using (var dr = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
{
    while (dr.Read())
    {
         var emp = new Employee();
         emp.EmployeeID = dr.GetInt32(0);
         emp.FirstName = dr.GetString(1);
         emp.LastName = dr.GetString(2);
         emp.BirthDate = dr.GetDateTime(3);
         if (!dr.IsDBNull(4))
         {
             byte[] blob = new byte[(dr.GetBytes(4, 0, null, 0, int.MaxValue))];
             dr.GetBytes(4, 0, blob, 0, blob.Length);
             emp.Photo = blob;
         }
         emps.Add(emp);
     }
}

This resulted in errors when I attempted to bind to the Photo property to an Image control in the Silverlight app.  I was able to determine through debugging that the Photo field was getting bytes but the Image control just would not bind to them.  After doing a bit of Google searching I found that the Photo field in the Employees table has some 78 byte header that you are supposed to skip over.  That little knowledge nugget could have saved me an hour of frustration.  So I modified my code to the following:

using (var dr = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
{
    while (dr.Read())
    {
        var emp = new Employee();
        emp.EmployeeID = dr.GetInt32(0);
        emp.FirstName = dr.GetString(1);
        emp.LastName = dr.GetString(2);
        emp.BirthDate = dr.GetDateTime(3);
        if (!dr.IsDBNull(4))
        {
            byte[] blob = new byte[(dr.GetBytes(4, 0, null, 0, int.MaxValue))];
            dr.GetBytes(4, 0, blob, 0, blob.Length);
            using (MemoryStream ms = new MemoryStream())
            {
                ms.Write(blob, 78, blob.Length - 78);
                emp.Photo = ms.GetBuffer();
            }
        }
        emps.Add(emp);
    }
}

Alas, Silverlight was still unhappy and gave me a very scary and ambiguous error titled “Catastrophic failure”.  The following is the error in all its glory:

With a bit more Google searching I concluded that Silverlight is picky about the types of images it will work with.  I deduced from the PhotoPath field in the Employee’s table that the bytes where encoded in BMP format, on account of the file’s extension ending in .bmp (watching all those CSI episodes paid off).  I decided converting the BMP into a JPEG at the server end would be the easiest solution and came up with the following code:

if (!dr.IsDBNull(4))
{
    byte[] blob = new byte[(dr.GetBytes(4, 0, null, 0, int.MaxValue))];
    dr.GetBytes(4, 0, blob, 0, blob.Length);
    using (MemoryStream ms = new MemoryStream())
    {
        ms.Write(blob, 78, blob.Length - 78);
        Bitmap bm = (Bitmap)Image.FromStream(ms);
        using (MemoryStream msJpg = new MemoryStream())
        {
            bm.Save(msJpg, ImageFormat.Jpeg);
            emp.Photo = msJpg.GetBuffer();
        }
    }
}

That did the trick.  I was finally able to view the Northwind employee images in all their glory.

In this video I demonstrate how to create and add a value converter for a Silverlight application. The converter receives a byte array that is a JPG image from a web service call and converts the bytes into a BitMapImage that is bound to an Image control in the Silverlight control. Creating and using a value converter allows you to do the binding in XAML and reuse the conversion code.

The images are coming from Northwind’s employee table via a Web service. I had to do a bit of work on the image in the Web service to convert the BMP image, the format it was stored in the database as, into a JPG format that Silverlight could work with. Stay tuned for an upcoming blog article on the code I used to do the converting in the Web service.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Silverlight value converters are covered in our new Silverlight 4 class.

This video demonstrates how to create a simple style resource for a Silverlight application. A style resource in Silverlight is a way to create reusable properties for various controls. In this video I create a style for a TextBlock control and show how easy it is to reuse the style on other TextBlock controls.

In the video I use Expression Blend 4 RC to create and edit the style resource. This could be done in Visual Studio but you would have to do most of the work by hand in the XAML code. Blend makes the task easy to do and allows you to edit with the designer.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Styles and resources are covered in our new Silverlight 4 class.

Microsoft is coming out with several new .NET 4.0 and Visual Studio 2010 courses, including a 5-day course titled Programming in C# with Microsoft Visual Studio 2010. But, there doesn’t appear to be any corresponding Visual Basic course. It is also not clear of courses like Developing Web Applications with Microsoft Visual Studio 2010 and Developing Windows Applications with Microsoft Visual Studio 2010 will include code examples in both C# 4.0 and Visual Basic 2010.

Is there a need for Visual Basic 2010 training or is demand just so low that it’s not worth creating these courses? From our own experience, we’ve delivered C# training more than four times more often than we have delivered Visual Basic training in the twelve months.

A few other indications that Visual Basic is not used nearly as often as C#:

The following chart comes from LangPop.com, which includes a disclaimer that the results are not scientific; however, they do correspond somewhat with our own experience:

And this chart from Google Trends shows an even greater difference in popularity. The lines below track the search volume for C# and Visual Basic.

It’s certainly understandable that Microsoft would come out with a C# 4.0 course first, but will a Visual Basic course follow at all? Do you plan to get Visual Basic 2010 training for your team? If so, please let us know.

This video demonstrates how to create a simple application for exploring and testing LINQ to SQL. In the video I am using WPF as my application but it could easily be done using other project templates. I am also using the LINQ to SQL classes modeling tool to create my data classes that map to the SQL tables. This tool saves me a lot of time by not having to create custom data classes by hand.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

SharePoint is a complicated product to say the least. Throughout an organization, many different people with different roles use SharePoint in one way or another. As a training company, it’s difficult to find the right mix of courses that provide people with the specific SharePoint training they need.

We have put together this framework to help us determine what SharePoint 2010 training classes to offer so that when a potential student/client asks “what SharePoint 2010 classes are right for me?” we have an answer.

What SharePoint 2010 classes are right for me?

Which best describes your position?

• I am a programmer and will be responsible for programming using Visual Studio for customizing SharePoint applications.
  • Responsibilities:
    
    • Creating Web Parts
      
    • Data Access using SharePoint API’s
      
    • Client interface programming
      
  • COURSES:
    
    • Course 10175: SharePoint 2010 Training: Application Development (five days) (NOW AVAILABLE)
      
    • Course 10232: PRO: Designing Applications for Microsoft SharePoint 2010 (five days) (available summer 2010)
      
• I am or will be responsible for administering SharePoint sites.
  • Responsibilities:
    
    • Creating Lists and Libraries
      
    • Managing users permissions
      
    • Backing up site content
      
  • Courses
    
    • Course 10174: TS: Configuring, Managing, and Troubleshooting Microsoft SharePoint 2010 (five days) (available summer 2010)
      
• I am responsible for designing and installing SharePoint systems.
  • Responsibilities:
    
    • Installing SharePoint 2010 in a farm or as a stand-alone configuration
      
    • Creating and managing service accounts
      
    • Assigning and configuring services to various servers in a farm
      
    • Designing and deploying search solutions
      
  • Courses
    
    • Course 10231: PRO: Designing and Deploying Microsoft SharePoint 2010 (five days) (available summer 2010)
      
• I am not a developer, but I am a power user and am or will be responsible for designing SharePoint sites and pages using SharePoint Designer.
  • Responsibilities:
    
    • Design and configure Master Page files
      
    • Create custom page layouts
      
    • Advanced formatting of content
      
    • Create and configure custom workflows
      
  • COURSES
    
    • Course 50354: SharePoint 2010 SharePoint Designer (2 days)
• I am an information worker/business user.
  • Responsibilities:
    
    • Upload documents for collaboration
      
    • Creating lists, libraries, blogs etc.
      
    • Use workflows for automation
      
    • Integrate with Office applications
      
  • COURSES
    
    • Course XXXX: Office Collaboration using SharePoint 2010 (2 to 3 days)
      

      Note: This class does not exist yet. We will create it ourselves if Microsoft (or some third party) doesn’t come out with a similar course.
      

If you have a need for SharePoint 2010 training, please contact us to let us know where you fall in the above listings or if you need a customized class.

I’ve found that quite often my .NET students have never used or didn’t realize what they could use the Server Explorer tool in Visual Studio. Server Explorer is a powerful tool that can let you create and manage your databases remotely from within Visual Studio. It’s an alternative to using a full blown management tool like SQL Server Management Studio. It even has some visual editing capabilities for those who may be SQL syntax challenged or who just prefer a visual editor. This video demonstration shows how to use it for creating and editing SQL stored procedures.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

This video demonstrates how to use the ASP.NET Muliview control.  This control can be a handy alternative to passing information between multiple pages in a Web application and having to deal with state management.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

This video demonstrates how to use data binding in Silverlight 4 to data retrieved from a WCF service. This video is a continuation of my previous video post on how to link Silverlight to a WCF service. In addition to basic binding I also demonstrate how to use the GUI interface in Visual Studio 2010 to create bindings as well as format string text.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

Data Binding is covered in our new Silverlight 4 class, which is next running the week of May 24th.

This is a video that demonstrates how to create a reference to a WCF service from a Silverlight application. In addition I cover the basics of making an asyncronous call to the service and binding the results.

To view the video in full screen mode (recommended), press the “F” key on your keyboard or hover over the lower left of the player and click on full screen icon as shown in the following image:

In .NET, types defined as classes become reference types and types defined as structures become value types. The class library that ships with the .NET framework defines basic types like Int32, Int16, Boolean, char etc., as structures. More complex types in the Framework are typically defined as classes. So, what are the major differences between reference type objects and value type objects?

The Common Language Runtime (CLR) engine treats reference types and value types very differently. Value type objects are defined in the running thread’s stack memory and reference type objects are created in the managed heap with a reference pointer from the thread’s stack. I’ll illustrate with a C# example:

    1     public struct ValBox

    2     {

    3         private Int32 _width;

    4         private Int32 _height;

    5

    6         public ValBox(Int32 Height, Int32 Width)

    7         {

    8             _width = Width;

    9             _height = Height;

   10         }

   11

   12         public void Resize(Int32 Height, Int32 Width)

   13         {

   14             _width = Width;

   15             _height = Height;

   16         }

   17

   18         public override string ToString()

   19         {

   20             return String.Format("Width is {0} and" + 

                                          " Height is {1}", _width, _height);

   21         }

   22     }

   23

   24     public class RefBox

   25     {

   26         private Int32 _width;

   27         private Int32 _height;

   28

   29         public RefBox(Int32 Height, Int32 Width)

   30         {

   31             _width = Width;

   32             _height = Height;

   33         }

   34

   35         public void Resize(Int32 Height, Int32 Width)

   36         {

   37             _width = Width;

   38             _height = Height;

   39         }

   40

   41         public override string ToString()

   42         {

   43             return String.Format("Width is {0} and" +

                                         " Height is {1}", _width, _height);

   44         }

   45     }

Notice that the only difference is that RefBox is a defined as a class and ValBox is defined as a structure. The following C# code shows how I could declare and initialize instances of these two types.

    1  ValBox vb = new ValBox(10, 10);

    2  RefBox rb = new RefBox(10, 10);

Here is a simple illustration of how these two objects would be stored in memory:

The following is the complete block of C# code in a Console application’s Main method:

    1         static void Main(string[] args)

    2         {

    3             ValBox vb = new ValBox(10, 10);

    4             RefBox rb = new RefBox(10, 10);

    5

    6             ValBox vb2 = vb;

    7             vb2.Resize(15, 15);

    8             RefBox rb2 = rb;

    9             rb2.Resize(15, 15);

   10

   11             //Display the results

   12             Console.WriteLine("Example of Value Type Behavior:");

   13             Console.WriteLine("The size of vb is: {0}", vb.ToString());

   14             Console.WriteLine("The size of vb2 is: {0}", vb2.ToString());

   15             Console.WriteLine();

   16             Console.WriteLine("Example of Reference Type Behavior:");

   17             Console.WriteLine("The size of rb is: {0}", rb.ToString());

   18             Console.WriteLine("The size of rb2 is: {0}", rb2.ToString());

   19             //This line just makes the console sit and wait

   20             Console.ReadLine();

   21         }

In the above code I have declared two new variables, vb2 and rb2 and assigned them to vb and rb respectively.  In addition to that I have used the built-in method Resize to change the width and
height of vb2 and rb2. The question is what will the values of vb and rb be when they are displayed in the console. Will they match or be different?

The following is a view of the output:

As you can see the reference types have matching field values whereas the value types do not. The modified illustration shows what is going on.

When a value type object is assigned to a new variable a copy of the value type is created on the thread’s stack and all of the fields values from the original are copied over. Any changes to the new copied value type will not affect the original. When a reference type is assigned to a new variable all that is created is a new reference pointer to the original object. Any changes made through either variable will be reflected in both.

That sums up the bare bones basics of how reference types and value types consume memory and behave differently. Things can get much more interesting when value types are turned into reference types.  This is referred to as “boxing” and the reversal process is “unboxing”. Boxing and unboxing should be avoided if possible as the process, if done in excess can be rather memory and CPU expensive.  Sometimes it cannot be avoided. For this reason it is generally recommended that if you create your own custom value types you limit them to small sizes of around 16 bytes or less. Anything larger than this, especially if the object will be passed around a lot, should probably be defined as a reference type, i.e. a class.

Value types, reference types, boxing and unboxing are all covered in our new C# 4.0 class.

Today’s blog is a continuation of my last blog on globalizing “Hello World!” in ASP.NET.  In this post I want to add functionality to the Web page that allows the user to change the displayed language of the page using a drop-down list.  By default the page selects which language to display based on the language setting of the browser making the request.  This post’s example is something you might do if you had a public kiosk and wanted to allow the user to choose the display language of the page without having to configure the browser or the operating system.  Another use would be to test the local resource files of the page and make sure they are being displayed properly.

In my last post I had created the following aspx page:

    1 <%@ Page Language="C#" AutoEventWireup="true" CodeFile="Greeting.aspx.cs" 
                                Inherits="Greeting"

    2     Culture="auto" meta:resourcekey="PageResource1" UICulture="auto" %>

    3

    4 <!DOCTYPE html PUBLIC "-//W3C//DTD
                    XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    5 <html xmlns="http://www.w3.org/1999/xhtml">

    6 <head runat="server">

    7     <title></title>

    8 </head>

    9 <body>

   10     <form id="form1" runat="server">

   11     <div>

   12         <h1>

   13             <asp:Label ID="lblTitle" runat="server" Text="Greeting Page"

   14                        meta:resourcekey="lblTitleResource1" /></h1>

   15         <p>

   16             <asp:Label ID="lblPara1" runat="server" Text="Hello World!"

   17                        meta:resourcekey="lblPara1Resource1" /></p>

   18     </div>

   19     </form>

   20 </body>

   21 </html>

Along with the aspx page I had created local resource files for different language interpretations of the label control’s Text properties, specifically Dutch and Japanese.  The local resource files were stored in a folder named “App_LocalResources” off of the Web application’s root.  The following screenshot shows the layout and file names:

To allow selection of the displayed language I will add the following drop-down box to the top of the page and add the languages that I am supporting as items and the culture abbreviations as the values.

   12 <asp:DropDownList ID="DropDownList1" runat="server" AutoPostBack="True">

   13     <asp:ListItem Value="en">English</asp:ListItem>

   14     <asp:ListItem Value="nl">Dutch</asp:ListItem>

   15     <asp:ListItem Value="ja">Japanese</asp:ListItem>

   16 </asp:DropDownList>

To change the language displayed to be something different that the browser’s culture you need to set the UICulture property of the Thread building the page.  The trick is you have to do this during the early stages of the page’s life cycle.  I.e. you can’t just change it in the page’s load event.  Microsoft makes this easy though by exposing the virtual method “InitializeCulture” that you can override.  The following code is an example that overrides “InitializeCulture” and reads from the Request object to get the selected language and set the UICulture appropriately.

    1 using System;

    2 using System.Collections.Generic;

    3 using System.Linq;

    4 using System.Web;

    5 using System.Web.UI;

    6 using System.Web.UI.WebControls;

    7 using System.Threading;

    8 using System.Globalization;

    9

   10 public partial class Greeting : System.Web.UI.Page

   11 {

   12     protected void Page_Load(object sender, EventArgs e)

   13     {

   14

   15     }

   16     protected override void InitializeCulture()

   17     {

   18         if (Request.Form["DropDownList1"] != null)

   19         {

   20             String selectedLanguage = Request.Form["DropDownList1"];

   21             Thread.CurrentThread.CurrentUICulture =

   22                 CultureInfo.CreateSpecificCulture(selectedLanguage);

   23             base.InitializeCulture();

   24         }

   25     }

   26 }

Note that you cannot access the dropdown list control directly because at this point in the page’s life cycle the controls have not been initialized.  You have to get the selected value of the dropdown list from the raw Request object.

That’s it!  You now have a page that can be rendered on the fly in any language you are willing to translate.  I suppose the listbox might be a problem since it only displays choices in English.  I’ll leave that up to your own creativity to fix…

If you need to build multi-language ASP.NET applications, we can customize our ASP.NET class to cover this content for you.

Microsoft and Visual Studio make it relatively easy to create Multi-language Web pages.  The first step is to create a Web page in Visual Studio.  The only catch is that for ASP.NET to handle your language translations you have to use Web Server controls and all of your text has to be through the properties of those controls.  I.e. be prepared to use a lot of label controls.  The following is a view of the source code of a simple page that we want to be multi-lingual.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Greeting.aspx.cs" Inherits="Greeting" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head runat="server">

    <title></title>

</head>

<body>

    <form id="form1" runat="server">

    <div>

        <h1>

            <asp:Label ID="lblTitle" runat="server" Text="Hello World!" /></h1>

        <p>

            <asp:Label ID="lblPara1" runat="server" Text="HelloWorld!" /></p>

    </div>

    </form>

</body>

</html>

Notice the use of label controls instead of straight text inside the header 1 and paragraph elements.

The next step is to get Visual Studio to generate a local resource file.  This step has to be done in design view, the menu option is not available in source view.  From the Visual Studio menu select Tools-Generate Local Resource.  The result should be a new file created with the same name as the original file except with a .resx extension.  In this example it would be Greeting.aspx.resx.  This file is automatically placed into a folder named “App_LocalResources”.  The contents of the resx file for this simple web page is:

Inside the original aspx page Visual Studio has made the following changes:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Greeting.aspx.cs" Inherits="Greeting"

    Culture="auto" meta:resourcekey="PageResource1" UICulture="auto" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head runat="server">

    <title></title>

</head>

<body>

    <form id="form1" runat="server">

    <div>

        <h1>

            <asp:Label ID="lblTitle" runat="server" Text="Greeting Page"

                       meta:resourcekey="lblTitleResource1" /></h1>

        <p>

            <asp:Label ID="lblPara1" runat="server" Text="Hello World!"

                       meta:resourcekey="lblPara1Resource1" /></p>

    </div>

    </form>

</body>

</html>

Note the new attributes added to the @Page directive and the meta:resourcekey attribute added to the Server controls.  These attributes are necessary for ASP.NET to perform the magic of automatically inserting language appropriate text into these controls.

The next step is to copy the rename the resx file to as many language files that you are prepared to translate.  For example,  Greeting.aspx.nl.resx would be the name of the Dutch translated resource file.  The contents would need to be edited to something like this:

Here is another example for Japanese, make sure the resource file is named Greeting.aspx.ja.resx:

Once this is completed ASP.NET will automatically use the proper resource file based on the default language of the browser visiting the page.  That is about all there is to creating a multi-lingual “Hello World” web page.

I just got back from the SharePointPro 2010 expo held in Las Vegas from March 16-19. As always with these types of conferences I was inundated with sessions highlighting new features and demos of new coding and development techniques. So while the information was still fresh in my head, some of it escaped me mere moments after I heard it, I thought I would assemble a blog describing some of my favorite SharePoint improvements/additions.

Using Windows 7 as a Development Machine

One of my complaints about SharePoint 2007 was that you had to do all of your development work on a server operating system with SharePoint installed. This was required because all of the code you wrote had to be compiled into an assembly that was installed into the GAC of the SharePoint server. While SharePoint 2010 still wants all of your code to be compiled and deployed into the GAC you can configure the SharePoint 2010 installation to work on a Windows 7 or Vista machine.

There are a few steps you have to do before this will work. The first step is to extract the SharePoint installations files into a local folder on the machine you are going to install to.

For SharePoint Foundation 2010:

<File Path>\SharePoint /extract:<File Path>

For SharePoint Server 2010:

<File Path>\OfficeServer /extract:<File Path>

Once the install files have been extracted you then need to find the setup configuration file:

<File Path>\files\Setup\config.xml

Open the file with your favorite XML editor and add the following line inside the tag:

This should allow you to run the install onto Windows 7 or Vista and use it as your development machine. There are a few prerequisites you’ll need for both Windows 7 and Visa. For a complete list and more detailed instructions you should read the following MSDN article, http://msdn.microsoft.com/en-us/library/ee554869(office.14).aspx.

You can still use a virtual machine but SharePoint 2010 only runs on a 64 bit platform so you will have to have Hyper-V to run your virtual machine which in turn requires Server 2008 as a host OS. I personally prefer the performance of developing in a native OS.

Keep in mind that this configuration is for development purposes only. Microsoft documentation recommends that you have an additional SharePoint server running on a server OS for real deployment and testing.

New SharePoint Templates for Visual Studio 2010

SharePoint 2010 comes with a whole new list of Visual Studio templates for projects and project items. In addition to the templates Visual Studio will build and deploy your SharePoint stuff for you.  No more having to run your own extra batch files at the tail end of a build process or add-on tools to deploy your assemblies to the GAC and copy the files to the SharePoint server.

Client-side Interface That Works in Silverlight

The message I got from the conference was that Microsoft is encouraging the use of code down at the client. A perfect fit is Silverlight with its rich user experience capabilities. To accommodate this Microsoft has created a client object model that mirrors what is in the server object model. This allows you to write code that would have used to have run from the server and run it instead in the client. Some of it has already made its way into the default SharePoint pages. The end result is a richer faster user experience.

These are just a few of the enhancements coming our way with SharePoint 2010. From what I have seen it looks like developing for SharePoint 2010 is going to be much easier and satisfying.

The purpose of this post is to examine the output file of a Silverlight 4 application.  In addition to the default output I will cover a couple of options that affect how the XAP file is packaged.

When a Silverlight project is built in Visual Studio all of the files, XAML and .NET code, are compiled into a single DLL.  This DLL file is then compressed into a zip file that gets named with a .xap extension rather than the traditional .zip.  In addition to XAML and code files, graphics and media files are compiled by default into the DLL assembly as well.

One way to verify the contents of a XAP file is to rename it with a .zip and open with windows explorer and you should see at a minimum the .dll assembly file along with a .xaml manifest file.  The following image is an example.

The ExploringXapFile.dll is the main output assembly file from the following XAML and code-behind built in Visual Studio 2010.

This basic Silverlight page has just a single line of code in the code-behind file that updates the TextBlock with the contents of the TextBox.

The controls used in this XAML page are all instances of classes defined within the core assemblies that are part of the Silverlight plug-in.  For this reason there is no extra assembly files packaged inside the XAP file.

However if I add the following XAML to the page:

Dropping these tree controls onto the page in Visual Studio 2010 will also add a new namespace declaration and assembly reference:

The assembly System.Windows.Controls is not part of the base assemblies included with the Silverlight 4 plug-in.  This means that the assembly will need to be included in the XAP file as the following image illustrates:

Most of the time including this extra assembly in your XAP file would be fine.  There is an alternative though.  You can separated the System.Windows.Controls assembly out and have the client’s browser cache it locally.  This is called “application library caching”.  If the client already has a cached copy of the assembly it does not need to be downloaded again.  This would obviously decrease the amount of content that needs to be downloaded for the application to run.

To configure the Silverlight project to use library caching you right-click on the project in Solution Explorer and choose the “Properties” option.  This will open the properties tab for the project and then you check the box labeled “Reduce XAP size by using application library caching”, as shown in the following screen capture:

The result of this setting is that the System.Windows.Controls.dll file will be packaged separately in its own ZIP file.  The following screen capture is of the hosting web site’s ClientBin folder.  It’s from this folder that the client downloads the files for the Silverlight application.  The client will only download the ZIP file if it does not already have a current copy in its cache.

It is also possible to control how resources like graphics files are stored in the Silverlight applications output.  In the current example I have a logo.jpg file of the Webucator logo displayed at the top of the page using the following XAML:

The default properties of the logo.jpg file in the Silverlight application is to include it as a “Resource” which causes the folder and image to be embedded in the DLL file along with the XAML and code.  If I select the properties menu of the logo.jpg by right clicking it in Solution Explorer I get the following:

Here I have changed the default of the “Build Action” from “Resource” to “Content”.  This tells Visual Studio to compile Image folder and files within it separately from the DLL file but still within the compressed XAP file.  The following is a screen capture showing the XAP file contents with this setting:

path to the image file must also be modified in the XAML source code to the following:

Even though Visual Studio 2010 beta 2 build is complaining about the path it works fine.  What can I say, it’s beta…

The XAP file is Silverlight’s delivery mechanism for getting rich content down to the plug-in.  As I have demonstrated, you have some control over how that XAP file is packaged.  The default settings are probably sufficient in most scenarios but it’s nice to know that there is alternatives that might be more beneficial in certain situations.