Coding Powers

Facebook Developer Toolkit Explained at CNUG

2007-11-20T04:33:27Z

I just finished presenting to the Chicago .NET User Group on Facebook Development using the Microsoft stack. I focused primarily on the Facebook Developer Toolkit for obvious reasons (it is just what I know). The session covered an overview of the Facebook API and the Facebook Platform. We then talked in depth about using the Facebook Developer Toolkit to leverage the Facebook API and to write Canvas pages hosted within the Facebook Platform. Thanks to my colleague Jonathan Schuster who did the code demos and saved me a bunch of prep time. I was also able to demo leveraging Silverlight 1.1 on a Facebook IFrame Canvas page.

This is part of the deck where I described an overview of the Facebook Platform.

If you are new to the Facebook Platform, I'd recommend the recording we made of the session (linked at the end of this post) or check out the interview we did on Thirsty Developer

The turn out was good. I think we had 40+ people and most were new to Facebook development. It was fun to introduce this platform to a new group of .net developers. If you are interested in the presentation, the slides, demos and a video of the presentation can be accessed at clarityTV.

Facebook Developer Toolkit Version 1.3 Released

2007-11-20T04:32:17Z

My thanks go out to my colleague Jonathan Schuster, who took over support of the Facebook Developer Toolkit for the past few weeks. He was able to push his way through a bunch of enhancements and bug fixes that the users have been waiting very patiently for.

This release marks a good milestone for the Toolkit as the majority of known issues with the support of Canvas applications are solved. In my opinion, the canvas support is now very solid and will really ease the learning curve for new developers who want to leverage the toolkit.

One of the big features of Release 1.3 is support for the compact framework. Many thanks to Peter Foote who dedicated a bunch of time to work on these features. For those of you interested, the release contains the following items.

Thanks to all of the people who have kept this project alive as I was pulled away. Pretty cool. We have had close to 500 downloads already. I am hoping to re-engage and help add support for new things that Facebook is releasing.

Hosting Vista File Previews in Managed Code

2007-07-26T21:14:00Z

As part of my work on the Coding4Fun Developer Kit 2008, I created a WinForm control encapsulating the flow to display file previews. The host is dependent on an improved version of Stephen Toub's framework, originally published here. My enhancements were basically to make the COM wrapper classes public so that they can be used by the Managed PreviewHandlers and also by my Preview Handler Host. The source for this project including the updated framework, Stephen's sample preview handlers, my host control and a sample application using the host control are available here. Also, they can be downloaded from the codeplex project for the Coding4Fun Developer Kit 2008.

A couple of quick notes before I describe how the managed preview handler host works.

For any of this to work, the C4F.DevKit.PreviewHandlerFramework.dll needs to be installed in GAC.
Also, this host will work with all non-managed preview handlers and any managed preview handlers that were built against the PreviewHandlerFramework mentioned above. Any Managed Preview Handlers that were compiled using Stephen's original framework or another method will not work with this host.

To host the results generated by any registered file preview handler in managed code, the PreviewHandlerFramework’s COM Wrappers are leveraged. In addition, part of this host needs to look up the preview handler that is currently registered with a particular file extension. To accomplish this, the PreviewHandlerHost leveraged the registry code from Stephen Toub’s Preview Handler Association Editor (http://blogs.msdn.com/toub/archive/2006/12/14/preview-handler-association-editor.aspx). With the code to find the registered handler in hand, we constructed a control to implement the preview handler Data Flow as shown below (all of this code is part of PreviewHandlerHost project, PreviewHandlerHostControl.cs):

Declare an object that is the PreviewHandler (this will be cast to different COM Interfaces as needed)
Unload any existing previews before generating a new preview
- Call Unload of IPreviewHandler Interface (dDefined in PreviewHandlerFramework as a wrapper to existing COM interface)

Visual C#

private object _comInstance = null; 
private void GeneratePreview() 
{ 
if (_comInstance != null) 
{ 
((IPreviewHandler)_comInstance).Unload(); 
}

Visual Basic

Private _filePath As String 
Private Sub GeneratePreview() 
If Not _comInstance Is Nothing Then 
CType(_comInstance, IPreviewHandler).Unload() 
End If

Build a RECT struct using the bounds of the visible area where the preview handler can draw. In this case, that is the full bounds of the PreviewHandlerHostControl

Visual C#

RECT r; 
r.top = 0; 
r.bottom = this.Height; 
r.left = 0; 
r.right = this.Width;

Visual Basic

Dim r As RECT 
r.top = 0 
r.bottom = Me.Height 
r.left = 0 
r.right = Me.Width

Find the CLSID of the preview handler registered for the file extension of the file using registry lookup. This is typically done by looking in the registry under HKEY_CLASSES_ROOT\%file_extension%\shellex\{8895b1c6-b41f-4c1c-a562-0d564250836f}. This Registry key will have a value pointed to the Class ID (CLSID) of the COM registration of the registered preview handler. For more information about how preview handlers can be found in the registry, see this article.
Create an instance of the preview handler using Reflection and the CLSID found in the registry.

Visual C#

Type comType = Type.GetTypeFromCLSID(new Guid(handler.ID)); 
_comInstance = Activator.CreateInstance(comType);

Visual Basic

Dim comType As Type = Type.GetTypeFromCLSID(New Guid(handler.ID)) 
_comInstance = Activator.CreateInstance(comType)

Call the appropriate initialize for the create preview handler (either passing in a stream or filepath)
- If the preview handler is a stream previewhandler, using a COM IStream Wrapper to handle Stream marshalling to COM

Visual C#

if (_comInstance is IInitializeWithFile) 
{ 
((IInitializeWithFile)_comInstance).Initialize(_filePath, 0); 
} 
else if (_comInstance is IInitializeWithStream) 
{ 
if (File.Exists(_filePath)) 
{ 
StreamWrapper stream = new StreamWrapper(File.Open(_filePath, FileMode.Open)); 
((VSExpressDevPack.PreviewHandlerFramework.IInitializeWithStream)_comInstance).Initialize(stream, 0); 
} 
else 
{ 
throw new Exception("File not found"); 
} 
}

Visual Basic

If TypeOf _comInstance Is IInitializeWithFile Then 
CType(_comInstance, IInitializeWithFile).Initialize(_filePath, 0) 
ElseIf TypeOf _comInstance Is IInitializeWithStream Then 
If File.Exists(_filePath) Then 
Dim stream As StreamWrapper = New StreamWrapper(File.Open(_filePath, FileMode.Open)) 
CType(_comInstance, VSExpressDevPack.PreviewHandlerFramework.IInitializeWithStream).Initialize(stream, 0) 
Else 
Throw New Exception("File not found") 
End If 
End If

Call SetWindow on the PreviewHandler, passing in a handle to the control and the bounds (RECT created earlier)

Visual C#

((IPreviewHandler)_comInstance).SetWindow(this.Handle, ref r);

Visual Basic

CType(_comInstance, IPreviewHandler).SetWindow(Me.Handle, r)

Call DoPreview on the PreviewHandler

Visual C#

((IPreviewHandler)_comInstance).DoPreview();

Visual Basic

CType(_comInstance, IPreviewHandler).DoPreview()

If you are interested in more information, the zip file included with this project has all of the source and a document describing a walkthrough of using this control. Additionally, the Coding4Fun Developer Pack 2008 Vol.1 Codeplex project has all the info and will also have any fixes/enhancements.

Coding4Fun Developer Kit 2008 Vol.1 Beta Released on Codeplex

2007-07-26T21:13:00Z

Recently, I have been spending most of my time helping put together the Coding4Fun Developer Kit that was released today on Codeplex. This is a Kit put together by Microsoft to open up many of the new and powerful APIs avaiable in Vista and Visual Studio 2008 to enable simple programming interfaces that can be used from managed code.

This developer kit contains .net wrappers and sample projects for the following Vista APIs

Bluetooth
Contacts
Digital Sound Recording
Messaging/Email
Picture Sharing
Picture Acquisition
Power Management
Preview Handlers
Feeds
Desktop Search

I made two big contributions to this developer kit. The first was building the Preview Handler Wrapper. This Wrapper included enhancing the managed preview handler framework built by Stephen Toub and published in the January Edition of MSDN Magazine. In addition, I wrote a managed preview handler host, to enable displaying any preview handler within a .net winform application. Watch for my next post describing, Hosting File Previews In Managed Code. My other contribution to the project was pulling the various projects together and building the installer. I used WIX. It was a tedious process at times, but ultimately pretty effective. I promise to write another post detailing my experience with WIX and what I did to put this installer together.

Check out the codeplex site for the Coding4Fun Developer Kit 2008 vol.1. Definitely some cool and interesting stuff.

SQL 2005 Performance Tuning using DMVs - Part 4 of 7 - I/O Health

2007-07-06T20:28:32Z

In my previous 3 posts in this series, I went through an introduction to Dynamic Management Views and an in depth look at how DMVs can be used to analyze and pinpoint CPU bottlenecks. In today's post we will take a look at using DMVs for analyzing I/O Health and pressure.

You can use the following DMV query to find currently pending I/O requests. You can execute this query periodically to check the health of I/O subsystem and to isolate physical disk(s) that are involved in the I/O bottlenecks.

SELECT 
    database_id, 
    file_id, 
    io_stall,
    io_pending_ms_ticks,
    scheduler_address 
FROM    
    sys.dm_io_virtual_file_stats(NULL, NULL)t1
INNER JOIN
       sys.dm_io_pending_io_requests as t2
ON    t1.file_handle = t2.io_handle

If you find, that you regularly have a high number of pending I/O requests, you can use the following query to determine which SQL batches use the most I/O.

SELECT TOP 5 
    (total_logical_reads/execution_count) as avg_logical_reads,
    (total_logical_writes/execution_count) as avg_logical_writes,
    (total_physical_reads/execution_count) as avg_phys_reads,
     Execution_count, 
    statement_start_offset as stmt_start_offset, 
    st.[text], 
    qp.query_plan
FROM sys.dm_exec_query_stats  qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) st
CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) qp
ORDER BY 
 (total_logical_reads + total_logical_writes) Desc

If you are troubleshooting blocked I/O realtime, you can use dm_tran_locks and dm_waiting_tasks to determine what sql is blocking and what is waiting.

SELECT 
    t1.resource_type,
    'database'=db_name(resource_database_id),
    'blk object' = t1.resource_associated_entity_id,
    t1.request_mode,
    t1.request_session_id,
    t2.blocking_session_id     
FROM 
    sys.dm_tran_locks as t1
INNER JOIN 
    sys.dm_os_waiting_tasks as t2
ON 
    t1.lock_owner_address = t2.resource_address and
    t1.request_session_id = t1.request_session_id

The last thing to check when analyzing I/O is the utlization of tempDB. You can use dm_db_file_space_usage to determine the amount of space that is being used in tempdb by user_objects, internal_objects and the version_store.

SELECT
    SUM (user_object_reserved_page_count)*8 as user_objects_kb,
    SUM (internal_object_reserved_page_count)*8 as internal_objects_kb,
    SUM (version_store_reserved_page_count)*8  as version_store_kb,
    SUM (unallocated_extent_page_count)*8 as freespace_kb
FROM sys.dm_db_file_space_usage
WHERE database_id = 2

That's it for this edition, in the next installment we will look at finding Problem Queries.

The code from this post is available here.

Facebook Developer Toolkit Version 1.2 Released

2007-07-06T20:09:08Z

I have been spending most of time working on the Facebook Developer Toolkit and monitoring our codeplex site. Things have been going pretty, the response has been pretty positive and the help from the other site contributors has been great. We even just became the 10th most popular project on CodePlex. Which is a pretty cool accomplishment and pretty impressive company.

Today, we released Version 1.2 of the Toolkit.

Included in this release are:

Refactored FacebookService

Added AsyncFacebookService

Refactored Parsers and Entities into their own directory and namespace

Added improved photo api

Added Canvas Base pages to Facebook.WebControls

Added Canvas samples to Facebook.WebControls

Added IFrame Ajax sample

Added IFrame Silverlight Example

Updated to new notifications API *INTERFACE CHANGE*

Updated PublishStory and PublishAction interfaces *INTERFACE CHANGE*

Updated CreateAlbum interface to return created Album *INTERFACE CHANGE*

Added SetFBML override taking in userid

Added small and big picture url and bitmap to photo and user

Added GetFriendsNonAppUsers method

The major change is the Canvas base pages, these should help new developers solve the riddle of building Facebook Canvas applications.

Thanks to everyone who helped with code and feedback. I think we continue to make good progress on this project. You can download the release or documentation here.

SQL 2005 Performance Tuning using DMVs - Part 3 of 7 - Alleviating CPU Pressure

2007-07-02T21:53:46Z

This is the third installment on my series on using Dynamic Views to help with SQL 2005 performance tuning. The previous post on Identifying CPU Pressure can be found here.

After identifying that a database is cpu constrained, the next step is to find out what is using all the cpu. The first step is to identify the SQL batches that are using the most CPU. To find these batches, you use dm_exec_query_stats and join to dm_exec_sql_text to get the actual SQL statement. The following query will yield the top 10 (currently cached) sql statements for cpu utilization.

SELECT 
    derived_table.total_cpu_time,
    derived_table.total_execution_count,
    derived_table.total_cpu_time/derived_table.total_execution_count as cpu_per_execution,
    derived_table.number_of_statements,
    Plans.query_plan
FROM    
(
SELECT TOP 10 
    SUM(qs.total_worker_time) as total_cpu_time, 
    SUM(qs.execution_count) as total_execution_count,
    COUNT(*) as  number_of_statements, 
    qs.plan_handle
FROM 
    sys.dm_exec_query_stats qs
GROUP BY qs.plan_handle
ORDER BY SUM(qs.total_worker_time) desc) derived_table
CROSS APPLY sys.dm_exec_query_plan(plan_handle) as Plans
order by derived_table.total_cpu_time/derived_table.total_execution_count desc

Another common cause of CPU over-utilization on a database server is query optimization time. If you take periodic snapshots of the dm_exec_query_optimizer_info DMV, you can get a good idea of the amount of time spent optimizing. The other way to look at optimization time is to examine how often queries are recompiled. The following SQL is useful for this examination:

--To examine queries that recompile often,
--plan_generation_num indicates the number of times 
--the query has recompiled. 
--The following sample query gives you the top 10 stored procedures 
--that have been recompiled.

SELECT top 10
    sql_text.[text],
    sql_handle,
    plan_generation_num,
    execution_count,
    dbid,
    objectid 
FROM 
    sys.dm_exec_query_stats a
    CROSS APPLY sys.dm_exec_sql_text(sql_handle) as sql_text
WHERE
    plan_generation_num >1
ORDER BY plan_generation_num DESC

Another common cause of high CPU database server is queries that require parallel processing. You can use a combination of dm_exec_requests, dm_os_tasks and dm_exec_sessions to find all active requests utilizing parallel processing.

SELECT 
    r.session_id,
    r.request_id,
    MAX(ISNULL(exec_context_id, 0)) as number_of_workers,
    r.sql_handle,
    r.statement_start_offset,
    r.statement_end_offset,
    r.plan_handle
FROM 
    sys.dm_exec_requests r
INNER JOIN sys.dm_os_tasks t on r.session_id = t.session_id
INNER JOIN sys.dm_exec_sessions s on r.session_id = s.session_id
WHERE 
    s.is_user_process = 0x1
GROUP BY 
    r.session_id, r.request_id, 
    r.sql_handle, r.plan_handle, 
    r.statement_start_offset, r.statement_end_offset
HAVING MAX(ISNULL(exec_context_id, 0)) > 0

Alternatively, you can just identify all cached plans that allow parallel execution.

SELECT 
    p.*, 
    q.*,
    cp.plan_handle
FROM 
    sys.dm_exec_cached_plans cp
CROSS APPLY sys.dm_exec_query_plan(cp.plan_handle) p
CROSS APPLY sys.dm_exec_sql_text(cp.plan_handle) as q
WHERE 
    cp.cacheobjtype = 'Compiled Plan'
    AND p.query_plan.value('declare namespace p="http://schemas.microsoft.com/sqlserver/2004/07/showplan";
        max(//p:RelOp/@Parallel)', 'float') > 0

This should help you identify and address the causes of high CPU usage. Next installment will take a look at identifying I/O bottlenecks. You can download the source for these examples here.

Silverlight 1.1 on Facebook Canvas Page using ASP.NET and Facebook Developer Toolkit

2007-06-27T22:29:00Z

A couple weeks ago, working with Microsoft we delivered the facebook developer toolkit to help developers write Facebook applications using .net. Since then, we created a codeplex project to help keep the toolkit up to date and relevant. It has been fun, and the response/involvement from the community has been great.

Yesterday, I spent some time working on how to build canvas pages leveraging the toolkit. A canvas page is a page that is accessed directly within facebook.com and the result is integrated into the user experience on facebook. These canvas pages were a major part of the new F8 facebook platform. For more information, check out the Facebook Developer documentation. Anyway, after struggling with the flow of authentication and application adding, I finally got it working and created 2 new canvas base pages (one for FBML type and one for IFrame). I posted on codeplex about the changes here. I also posted some very simple Canvas page examples for both FBML and IFrame.

Now that I had a good framework in place for building the canvas page, I wanted to see if I could get a Silverlight control with Facebook context showing up in my IFrame canvas page. From past experience, I knew there were some major obstacles.

Some namespaces used in the Facebook.dll (wrapper to the API) are not supported in Silverlight namespace. Most notably: System.XML, System.Web.
Silverlight 1.1 Alpha does not support cross domain posts.
It will be tough to manage the facebook login process from the Silverlight control, since we can not show the facebook hosted login page.

With this in mind, I had a plan. And after a frustrating day, just got a Silverlight control showing on a canvas page with some facebook context. Here's how.

Added a new webservice (SilverlightService.asmx) to my ASPNETPlatformSamples web site. This webservice is a proxy used by the silverlight application to call facebook
Updated the ASPNETPlatformSamples web.config to support the web service.
Added a ScriptService attribute to SilverlightService to enable it to support JSON calls

Added WebMethod GetFriends wrapping the FacebookService.GetFriends(), this method needs to take the 4 parameters that comprise a facebook session, so that calls can maintain context.

[System.Web.Script.Services.ScriptService]
public class SilverlightService : System.Web.Services.WebService
{
    Facebook.Components.FacebookService _fbService = new Facebook.Components.FacebookService();


    [WebMethod]
    public UserJSON[] GetFriends(string api, string secret, string session, string userid)
    {

Created a stripped down version of the Facebook.Entity.User class that is serializiable by JSON. JSON can't serialize enums or subclasses. So, for this I just stripped them out. This is called UserJSON and is currently just a member of my ASPNETPlatformSamples web site.

In the GetFriends WebMethod, converted Collection of Users returned from Facebook call to Array of JSON compatible users.

        Collection<Facebook.Entity.User> friends = _fbService.GetFriends();
        UserJSON[] x = UserJSON.ConvertFacebookUserArray(friends);
        return x;

Created a new Canvas page (IFrame\Silverlight.aspx), alongside to my other IFrame canvas samples

Added a placeholder for the Silverlight control and 4 hidden fields to store the facebook context.

<head>
    <title>Silverlight Project Test Page </title>
    
    <script type="text/javascript" src="Silverlight.js"></script>
    <script type="text/javascript" src="CreateSilverlight.js"></script>
</head>

<body>
<form id="Form1" runat="server">
<asp:HiddenField ID="hidAPI" runat="server" />
<asp:HiddenField ID="hidSecret" runat="server" />
<asp:HiddenField ID="hidSession" runat="server" />
<asp:HiddenField ID="hidUser" runat="server" />
    <div id="SilverlightControlHost" >
        <script type="text/javascript">
            createSilverlight();
        </script>
    </div>
</form>

Added code in code-behind to populate hidden fields (so they can be accessed by silverlight control).

public partial class _Default : CanvasIFrameBasePage 
{
    private const string FACEBOOK_API_KEY = "c559128010f3edee33796fd4205361c2";
    private const string FACEBOOK_SECRET = "85887d1c9a8334e5059742468a5400ee";

    new protected void Page_Load(object sender, EventArgs e)
    {
        base.Api = FACEBOOK_API_KEY;
        base.Secret = FACEBOOK_SECRET;
        base.Page_Load(sender, e);
        hidAPI.Value = this.FBService.ApplicationKey;
        hidSecret.Value = this.FBService.Secret;
        hidSession.Value = this.FBService.SessionKey;
        hidUser.Value = this.FBService.UserId;

    }
}

Created a new silverlight project using Orcas called SilverlightWebServiceClient
Added a web reference to the above WebService
Added code in page_loaded event handler of xaml code behind to call the GetFriends method on the WebService to retrieve an array of friends.
Then simply wrote text to a textblock with the count that was found.
I then needed to add a Silverlight Reference into the ASPNETPlatformSamples. This essentially copies the .xaml from the Silverproject, and the compiled .xaml.cs into a ClientBin folder of the web site project so they can be accessed from within the website.
You can see it in action, by going to my IFrame canvas sample. After logging in and adding the application, you should have a Silverlight demo link which will show the Silverlight page.

I checked the updated c# code for ASPNETPlatformSamples and a new project for the Silverlight Control into the codeplex site.

Now we need to build some cool Silverlight canvas apps. If anyone has better ways to do this, I'd be interested in learning about them.

Next up, Silverlight in FBML Canvas page.

SQL 2005 Performance Tuning using DMVs - Part 2 of 7 - Identifying CPU Pressure

2007-06-13T13:57:00Z

In the my first post on DMVs, I gave an introduction to Dynamic Management Views and talked about some of the tuning activities that DMVs make easier. I also gave my top 10 DMV list.

In this installment, I am going to review how DMVs can be used to analyze CPU utilization on a machine running SQL Server.

Identifying if a System has CPU Pressure

Prior to DMVs, the typical approach to checking whether a server was experiencing CPU bottlenecks was to use the Processor Queue Length performance counter. This counter should typically be near 0 for systems not experiencing CPU pressure.

This approach is still valid, but is not necessarily a good measure for a server used for SQL Server. To see why this is the case, we must examine SQL Server Execution Model.

SQL Server uses a User Mode Scheduler (UMS) to control the execution of SQL Server user requests (SPIDs or session_ids). The UMS manages the execution of SQL Server requests (without returning control to Windows). So when SQL Server gets its time slice from the Windows scheduler, the SQL Server UMS manages what user requests are run during this time.

In a 4-proc scenario, there will be 4 User Mode Schedulers, one for each CPU. Each UMS uses a number of constructs (queues, lists and worker threads) to govern execution. At any given time, each UMS will have at most a single running thread, a runnable queue of requests that are
waiting for CPU, a waiter list (for resources such as IO, locks, memory), and a work queue (user requests that are waiting for worker threads).

Whenever the current running thread needs I/O it is moved to the wait list. When this occurs, the next request from the runnable queue is started. When the thread needing I/O completes, it is moved back to the end of the runnable queue.

The time waiting for a resource is shown as Resource Waits. The time waiting in the runnable queue for CPU is called Signal Waits. In SQL Server 2005, waits are shown in the Dynamic Management View (DMV), sys.dm_os_wait_stats. In this DMV, high Signal Wait % indicates a CPU constraint.

The query to measure cpu pressure using sys.dm_os_wait_stats is as follows:

SELECT     
    sum(signal_wait_time_ms) AS signal_wait_time_ms,
    cast(100.0 * sum(signal_wait_time_ms) / sum (wait_time_ms) as numeric(20,2)) as '%signal (cpu) waits',
    sum(wait_time_ms - signal_wait_time_ms) as resource_wait_time_ms,
    cast(100.0 * sum(wait_time_ms - signal_wait_time_ms) / sum (wait_time_ms) as numeric(20,2)) as '%resource waits'
FROM 
    sys.dm_os_wait_stats

You can also monitor the SQL Server schedulers using the sys.dm_os_schedulers view to see if
the number of runnable tasks is typically nonzero. A nonzero value indicates that tasks have to wait for their time slice to run; high values for this counter are a symptom of a CPU bottleneck. You can use the following query to list all the schedulers and look at the number of runnable tasks.

SELECT 
    scheduler_id,
    current_tasks_count,
    runnable_tasks_count
FROM
    sys.dm_os_schedulers
WHERE  
    scheduler_id < 255

That's it for this installment, see you next time as we find out how to determine the likely causes of the CPU pressure we just identified.

SQL 2005 Performance Tuning using DMVs - Part 1of 7

2007-06-12T06:47:00Z

A few months ago, I researched and put together an internal presentation on one of the more interesting features in SQL 2005 (Dynamic Management Views). This topic is not quite as cutting edge now as it was when I researched it. But, I think it is still useful to blog what I found. First off, thanks to Kim Tripp at SQL at www.sqlskills.com. I first became interested in this topic when watching some of her webcasts. I also found many of my good samples of DMV useage from some of her posts.

I am going to break this up into parts, this first part is just an intro.

Microsoft made a big effort with SQL Server 2005 to make the server more transparent to administrators and developers. The result is DMVs, which should make database tuning and maintenance easier.

“DMVs can expedite the diagnosis process by eliminating the need to generate and analyze physical dumps in most cases. DMVs provide a simplified and familiar relational interface for getting critical system information. This information can be used for monitoring purposes to alert administrators to any potential problems. Or, the information can be polled and collected periodically for detailed analysis later.”

DMVs are very useful in diagnosing different SQL performance problems. I will go into more specifics with the future posts here. But in general, you will find great resources for looking into any of the following:

Resource Bottlenecks
- CPU
- Memory
- I/O
TempDB Bottlenecks
Slow Queries
- Bad Plans
- Missing Indexes
- Blocking
Index Fragmentation

Here is a good list of the Naming Conventions of the DMVs that are available:

CLR Related
- dm_clr_
Database Related
- dm_db_
Execution Related
- dm_exec_
Full Text Search Related
- dm_fts_
Index Related
- dm_db_index_
- dm_missing_index_
SQL OS Related
- dm_os_
I/O Related
- dm_io_
Query Notifications Related
- dm_qn_
Replication Related
- dm_repl_
Service Broker Related
- dm_broker_
Transaction Related
- dm_tran_

After playing around with all the DMVs I could find, I put together a list of my 10 favorites:

dm_exec_query_stats – performance stats of all queries
dm_exec_sql_text – returns exact sql for entire batch given a sql handle
dm_exec_query_plan – return query plan for entire batch given a plan handle
dm_db_index_usage_stats – displays how often each index is used, show Read Seeks, Read Scans, Write Seeks and Write Scans
dm_db_index_physical_stats – replace DBCC SHOWCONTIG used to check index fragmentation
dm_db_index_operational_stats – use to check for index contention and blocking
dm_os_wait_stats – Used to determine the types of waits (signal or resource that are occurring)
dm_os_waiting_tasks – Used to help identify blocking
dm_tran_locks – Used to help indentify blocking
dm_os_performance_counters – Query Access to SQL Server Performance counters

The last thing I wanted to cover in this initial post, was just methods for writing queries to identify the DMVs and their types. Some DMVs are actual views, while others are tabled valued functions. Again, thanks to Kim Tripp for most of this knowledge.

Download a script for identifying DMVs and syntax to querying each here

Mixed Authentication- ASP.NET Forms and IIS 6.0 Windows Integrated

2007-06-12T05:41:00Z

Recently I was working on a website that needed to leverage both Integrated Windows and Forms Authentication. The idea is that this website has some users that are on Active Directory and should be able to gain access without being challenged from credentials when they are logged into the domain. Additionally, these users should be allowed to enter their AD credentials and access the site if they access the site remotely (while not logged in to AD). This is all handled by IIS Integrated Windows Authentication. However, for our situation we also have users who are not in AD at all and need to access the site. We preferred to not create AD accounts for these users just to permit access to the site. The solution we wanted was try windows integrated, if it fails, use forms authentication. This problem will go away with the integrated pipeline of IIS 7.0 (more on this with a later post). But, in IIS 6.0 this problem proved very tough to solve.

After doing some research, we found this article. http://msdn2.microsoft.com/en-us/library/ms972958.aspx. This was a great article and provided the basic approach to the solution.

To summarize

Set site to use Forms Authentication
Set web.config authorization to deny anonymous users
You need to set one page in your web application to use Windows Integrated Authentication (this was a revelation to me, setting one page to different IIS authentication than others in same app). In this case we call it WinLogin.aspx
1. In this page, capture the Request Variable "LOGON_USER" and then call FormsAuthentication.RedirectFromLoginPage.
2. This allows you to mimick a forms logon for the windows user.
Set Forms loginUrl to page from step 3
Handle Windows Integrated failures. Add a custom handler for 401 errors, and in the static HTM page. Use a javascript function to forward to the real ASP.NET forms login page (WebLogin.aspx).

6. Update web.config to allow anonymous access of WebLogin.aspx.

7. Redirect to original requested URL

This was very helpful and got us a solution that solved most problems. However, we quickly ran into one problem that we couldn't live with. For IE users who did not have our site as a "Trusted Site", Windows Integrated would popup a login dialog prompting for credentials prior to our custom 404 provider. So, our non AD users would have to press cancel on this to get to our login form. Just not acceptable.

Some more research brought us to another great post that ultimately gave us they framework for our solution. The article that we used to help us solve this problem is here http://glazkov.com/blog/credentials-screening/.

We were not able to get his exact implementation working, and ended up changing the code quite a bit. But, the essence of the approach is exactly as described in that post (and the subsequent updates).

The short explanation of how this works is:

Create an HTTPModule to handle incoming requests
In this module, emit a javascript function to try to load the page that is setup as requiring Windows Integrated.
Back in the module, check the LOGON_USER server variable. (If javascript succeeded in accessing that file, this variable will be populated)
Continue with redirect

The key to the solution that solves the original problem is the javascript load of the page set to require Windows Integrated Authentication. What this accomplishes is pre-empting the load of this page that IIS will do and allows our code (in the handler) to respond the results of the check prior to IIS potentially popping up a dialog.

The last thing we needed to do was simply added AD integration into the weblogin form. So, we could still allow AD users who access the site without being logged into the domain use the domain credentials. I will discuss this in my next post. The code I am posting with this blog does not have the AD integration on the login page itself. (As it will take more work for me to factor that out into a digestable snippet).

You can download a sample here.

CNUG Silverlight Presentation

2007-06-12T04:48:00Z

Our CTO, Jon Rauschenberger, and I did a presentation on Silverlight at the Chicago .NET User Group last week. Jon presented the slides and I did a few technical demos. The first demo included a simple introduction to Expression Blend and Media support. The second demo included some programming Silverlight with .NET examples including HTML integration, POX, JSON WebServices, Proxy WebServices and some simple XAML constructs.

The session was very well attended. And we had some good discussions around the Silverlight architecture and where it really fits into the Microsoft development stack. If you are interested in learning more about Silverlight, we recorded the session. The recording and resources (deck and demos) are available here. http://www.claritycon.com/claritytv/

Facebook Developer Toolkit Codeplex project

2007-06-12T04:44:00Z

We started a CodePlex project to help keep the Facebook Developer Toolkit up to date and relevant. The project can be found here http://www.codeplex.com/FacebookToolkit. Currently, I am working through some of the issues that have been identified and packaging up Version 1.1. I am open to any and all help that anyone wants to contribute to the codeplex project.

Should be fun and a good way to make sure the community is able to voice problems and get updated builds. Thanks to Microsoft for the support and commitment to this project.

Facebook Developer Toolkit Released

2007-05-29T22:27:44Z

The Facebook Developer Toolkit that I have been working on the past month or so was just released on the Visual Studio Express Website at http://msdn.microsoft.com/vstudio/express/showcase.... This toolkit should really help improve the programming experience of using the Facebook API using Microsoft tools (like C# and VB.net). Below is a summary of all the features available in the toolkit. The toolkit is completely open source and has all code available in both C# and VB.net

Facebook API Wrapper

The Facebook.dll is a wrapper to the Facebook API. In our opinion, this is a more complete wrapper than the client libraries available in other languages. In our wrapper, we have created strongly typed objects for all Facebook entities. This will greatly simplify the programming experience of anyone using the Wrapper. Developers accessing the API through the FacebookService component within our Facebook.dll will not need to understand the Facebook Authentication model or know how to work with the XML returned from the calls. All of this is abstracted from the developer, as shown below. (This sample assumes you already have an instance of FacebookService)

Visual C#

using System.Collections.Generic; 
using System.Collections.ObjectModel; 
...

Collection<User> friends = FacebookService1.GetFriends(); 
if(friends.Count > 0) 
{ 
     string firstFriendName = friends[0].Name;
}

VB.Net

Imports System.Collections.Generic 
Imports System.Collections.ObjectModel 
… 
Dim friends As Collection(Of User) = FacebookService1.GetFriends() 
If friends.Count > 0 Then
     dim firstFriendName as string = friends(0).Name
End If

Infinite Session Support

One other interesting feature of the Facebook API is infinite sessions. Infinite sessions is a concept that Facebook introduced to try to simplify the login process for third party applications. In this case, when a user logs in to an application they can specify that the application can use their credentials forever (without redirecting to the Facebook login page). In order to take advantage of this feature, an application needs a way to identify a user and associate them with their known Facebook Session identifier. If an application has knowledge of who the user is and tracked their session key from previous Usage. The application can set the UserId and SessionKey properties on the FacebookService component before making any api calls. If this is done and the session/user combination is valid, the application will avoid further login attempts.

Windows and Web Controls

Another feature that is included in the Facebook Developer Toolkit are controls for simplifying Web and Windows Development. These controls are installed in the Visual Studio Toolbar (in all editions of Visual Studio 2005) and allow the developer to simply drag the control from the toolbar to the form or webform. After the controls are added, the developer must just set the relevant control property with data retrieved using the FacebookService component described above. The controls themselves contain very simple User Interfaces but demonstrate how to build controls for these environments and good practices for leveraging the FacebookService data. The Controls that are available are:

Friend List (Web and Windows)
User Profile (Web and Windows)
Photo Album (Web and Windows)
Friend Map (Windows only)
Event List (Windows only)

Windows Presentation Foundation

The Facebook Developer Toolkit also includes a sample application showing how the FacebookService can be leveraged from a Windows Application using Windows Presentation Foundation (WPF). The application is an animated rolodex, providing a visual display of a user's Facebook friends. This application was developed by my colleague, Kevin Marshall. It is a pretty cool sample and demo of some of the more compelling features of WPF. Unfortunately, currently devlopers can not access the contact information for Facebook user's, so the Rolodex can only display generic user data rather than more useful information like address, phone number or email address.

LINQ and Orcas

The last sample included in the Facebook Developer Toolkit is a sample application showing how the FacebookService can be leveraged from LINQ. This application is called Friend Finder. It shows how you can use LINQ on top of the data returned from the FacebookService to provide ordering, filtering and paging. This sample was coded by another colleague, Jerry Brunning and also shows a lot of the cool new langauage features available in Visual Studio codename "Orcas".

Documentation

The documetation included with the Facebook Developer Toolkit is pretty comprehensive. It contains Code Snippets, Class Definitions and a Quick Start Guide. You will have a link to the documentation in you Start Menu after installing and also it is available at c:\program files\coding4fun\facebook.

I hope everyone has fun trying out the toolkit, and let me know if you run into any problems.

ASP.NET 2.0 Script Callbacks for Web Page AutoRefresh

2006-04-06T19:52:00Z

Recently I was working on a website requires client refresh when state changed on the server. We wanted to implement this without posting the page back to the server constantly. The solution to this problem was to implement an out of band call (AJAX) to the server from a javascript timer. This call can then check with the server if a post back should be done to refresh the system.

To implement the out of band call, I used asp.net 2.0 script callbacks. Script callbacks uses XmlHTTP to communicate with the server, and instead of the rs.htm and rs.asp file (like older techniques used to us) ASP.Net 2.0 uses the a script-library named CallBackManager.

The client makes the call of a client-side method that will use the CallBackManager. The CallBackManager creates the request to an .aspx page on the server. The server processes the page and its events and makes the call of the sever-side function. The CallBackManager then parses the server response and make the call to a callback method located on the client-side. The CallBackManager must know the name of the client-side callback method. The CallbackManager must know which method it should call on the client-side. This is accomplished by using the GetCallBackEventReference method of the page. With this method we could also specify which method the CallbackManager should call if the server throws an exception.

Let’s examine the code elements that are used to make this work.

The System.Web.UI.ICallbackEventHandler must be implemented for using callback events.

<%@ page language="C#" %>
<%@ implements interface="System.Web.UI.ICallbackEventHandler" %>

The Code Behind for the page implementing ICallbackEventHandler must implement one method – RaiseCallbackEvent- to make the callback work. This method takes one argument which will contain the data from the client, and return a string value back to the client. In my case the RaiseCallbackEvent checks if state on the server has changed (compared to the state in Session for this user). If so, the client's view of the application should be refreshed. _returnFromServer is a private member variable of the codeBehind file that is set and used to return values to the client javascript method.

    public void RaiseCallbackEvent(string eventArgs)
    {
        if (Global.IsStateChagedChanged((int)Session["clientState"])
            {
                  this._returnFromServer = "Do Postback";
            }
            else
            {
                this._returnFromServer = "";
            }
    }

The next step is to set a reference within the CodeBehind to the client script that will be called back. This is accomplished using the GetCallbackEventReference method. This method has 3 overrides, in this case the following signature is used.

         public string GetCallbackEventReference(
            Control control,
            string argument,
            string clientCallback,
            string context,
            string clientErrorCallback)

The following code uses the GetCallbackEventReference to specify the client-side callback methods and the control that implements ICallbackEventHandler. In this example it’s the current page that has implemented the ICallbackEventHandler. So the current page object is passed to the method. When the server-side method has been executed the ClientCallback method on the client-side will be executed. If the servers throw an exception, the ClientErrorCallback will be executed on the client-side. The arg and ctx are names of the arguments of the client-side event that calls the server-side method. This code is part of the Page_Load for the page.

     string src = Page.ClientScript.GetCallbackEventReference(
          this,
            "arg",
            "ClientCallback_Refresh",
            "ctx",
         "ClientErrorCallback_Refresh",
            false);

The code above provides the needed client reference for the loaded page. In addition to this, the page needs to provide a javascript function that can be executed from the client to execute the call to the server. This is done using the RegisterClientScriptBlock function as shown here.

    string mainSrc = @"function CheckRefresh(arg, ctx)
          { " + src + "; }";

      Page.ClientScript.RegisterClientScriptBlock(
          this.GetType(),
        "CheckRefresh",
        mainSrc,
        true);

The RegisterClientScriptBlock above will generate in the rendered html to the client:

      function CheckRefresh(arg, ctx)
      {
         WebForm_DoCallback('__Page',arg,ClientCallback_Refresh,ctx,ClientErrorCallback_Refresh,false);
      }

This __doCallback method takes five arguments, the current page, the argument value sent into the RaiseCallbackMethod, the client-side callback method, the context value that will be sent to the client-side callback method, and the last argument is the client-side method that will be triggered if the server throws an exception.

The last piece of code needed in the code-behind is a simple accessor method that provides access to member variable set during RaiseCallbackEvent that is used to return the result to the client scripts. The GetCallbackResult is used for this.

        public string GetCallbackResult()
        {
            return this._returnFromServer;
        }

With all the code in place in the code-behind, we need some simple javascript on the page to initiate the call back by executing the server generated CheckRefresh and checking the results. In this case, the timer method is executed every 10 seconds using the javascript function SetInterval(10000).

      function CheckRefresh_Timer()
      {
          myMessage.hide()
          CheckRefresh("", "");
      }

      function ClientCallback_Refresh( result, context )
      {
          // initiate a postback to refresh data
          if(result == "Do Postback")
          {
              __doPostBack('ctl00$pageMainColumn$lbStateChange','');
          }
         }

      function ClientErrorCallback_Refresh( error, context )
      {
        //log or ignore error
      }

Notice that when state changes, the page submits to the server via a button. This allows a specifically targeted postback(ie. Fire a button event handler and the page_load with IsPostback = true) to the server rather than a general page refresh. This is done by declaring an “invisible” button. The code below shows the declaration of the button.

         <div style="visibility:hidden;">
        <asp:LinkButton ID="lbStateChange" runat="server" OnClick="lbStateChange_Click" >state change</asp:LinkButton>
        </div>

The last important concept with respect to Script Callbacks is the execution of page_load. It is important to understand that the page_load of the page implementing the CallBackEventHandler is executed with Page.IsPostback = true each time a client calls back. Therefore, it is vital to ensure that this code path executes the smallest amount of code possible.

Overall, this seemed much more complicated that it actually was. It is just a matter of putting all the pieces together. The result is a client experience that can remain in synch with the server without disrupting general navigation and site usage.