You see, in Visual Studio (and that has been the same thing with MDI windows before that), they have a thing called a “Tab Group", which comes in horizontal and vertical varieties. These days the difference is illustrated in little icons at least, defining it like this:

Horizontal group (exhibit A):

+--------------------+
|                    |
+--------------------+
|                    |
+--------------------+

Vertical group (exhibit B ):

+-------+-------+
|       |       |
|       |       |
|       |       |
|       |       |
|       |       |
|       |       |
+-------+-------+

Now here’s my gripe with that: it’s the wrong way round!

In my eyes, exhibit A might be described as “a tab group with a horizontal splitter", but it is not a horizontal tab group. These things are not the same. A horizontal tab group is one where the tabs, the defining feature of a tab group, surely, are shown “horizontally", i.e. next to each other in horizontal direction. Just like exhibit B, in fact. And vice versa, of course.

I don’t know what somebody was thinking when they came up with those names, or maybe it’s just my head that works differently. It doesn’t make sense to me, in any case. And that’s the important point of this post: if you never realized that these terms might be confusing to somebody, here you are now!

One important factor in successful communication is about understanding misunderstanding – which is why, in my tweet, I was avoiding the terms “horizontal” and “vertical” as being confusing in the context. Of course the first and so far only reply I got to my tweet (and I’m not naming any names here <g> ) went “hey, do you mean vertically?” Hmpf.

Oh, and yes, according to the MS definition I mean vertically, yes. A tab group with a vertical splitter, that has been split in vertical direction, or whatever. A tab group with the tabs showing horizontally next to one another. And the same file on both sides of the splitter. Not possible, is it?

• Out-Of-Browser Szenarien
• Offline Szenarien
• Mehrfache Analytics Services gleichzeitig ohne Performanz-Einbüßen
• Designer-Unterstützung für Microsoft Expression Blend 
• A/B Testing
• SketchFlow Prototyping
• Logging und Video Experience mit Microsoft Silverlight Media Framework [2]

In der Session [1] erläutern Michael Scherotter und Alfonso Corretti die Details des neuen Frameworks zur Integration von Web Analytics Lösungen in die Silverlight-Applikationen. Eine weitere Session auf meiner Agenda.

[1] http://live.visitmix.com/MIX10/Sessions/CL24
[2] http://smf.codeplex.com/

• Domani saremo a Roma in occasione del DotNetCampus: l’agenda è molto varia e tocca un “sacchissimo” (unità di misura da poco entrata nel S.I. <g>) di argomenti interessanti. ‘nzomma, se fa ancora troppo freddo per andare in giro a caXXeggiare, potreste pensare di venirci a trovare :-)
• Il prossimo mese torneremo a Roma grazie alla ospitalità di BASTA! Italia, che anche quest’anno ci permette di organizzare un “Community After Hour” gratuito in combutta con i ragazzi di ASPItalia. 3 sessioni, 2 delle quali già in agenda e potenzialmente “rissose” giacché dedicate a temi in merito ai quali crediamo che il formato “open” possa portare grande valore aggiunto. E ricordatevi che i soci UGIdotNET hanno uno sconto sulla iscrizione all’evento diurno

March 29th - Early Adopter Program

The early adopter release will be available to a limited set of EntitySpaces customers who have a real need for some of the new or enhanced EntitySpaces 2010 features (such as Silverlight, WCF, Smart Proxies, SQLite, JSON serialization). We are looking for customers who desire to upgrade to ES2010 now and continue developing through to release. Prime candidates are new customers working on projects that haven’t shipped yet who can easily upgrade and begin working with ES2010. If you are interested in participating in our Early Adopter Program please send an email to earlyadopter@entityspaces.net with your EntitySpaces user id and how you plan to use EntitySpaces 2010. Not everyone who sends an email will be chosen to participate. Again, we are looking for users who are really going to use this version for development. We are seeking about 20 users to participate and they will be hand picked based on the email we receive explaining how ES2010 will be used. For example, we are interested in Windows Forms, ASP.NET, Silverlight, and so on, in other words, a good cross section of development. Current forum participation will also help in being chosen (active users).

Keep in mind that EntitySpaces 2010 will not support .NET 2.0, it’s .NET 3.5 and forward. We are unsure at this point if .NET 4.0 assemblies will be included in the Early Adopter Program.

April 19th  – Public Beta (customers only)

We are planning on only one beta. This beta will be available to all customers. We realize that the beta window looks short here but this release will have passed all of our unit tests and will have been pretty heavily used by those participating in the Early Adopter Program.

April 29th – Official Release

This is our official release. The EntitySpaces 2010 Trial version will also be available as well for the general public.

From Mobile Devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with Medium Trust requirements, a Silverlight/WCF application, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 200k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net]]> Mike Griffin 3/11/2010 10:29:58 PM http://feedproxy.google.com/~r/bugsquash/~3/up9RNNc9AnY/low-level-solrnet.html I recently got a question about how to handle multi-faceting in SolrNet, a nice feature of Solr that can be very useful to the end-user. eBay uses a kind of multi-faceting interface.
If you know nothing about Solr or SolrNet, read on, this article isn't so much about Solr as API design.

The Solr wiki has an example query with multi-faceting:

q=mainquery&fq=status:public&fq={!tag=dt}doctype:pdf&facet=on&facet.field={!ex=dt}doctype

For those of you that are not into Solr, this is just a regular URL query string that is passed to the Solr endpoint. The final URL looks like this (modulo encoding):

http://localhost:9983/solr/select/?q=mainquery&fq=status:public&fq={!tag=dt}doctype:pdf&facet=on&facet.field={!ex=dt}doctype 

And this is how you represent this query in the SolrNet object model:

var solr = ServiceLocator.Current.GetInstance<ISolrOperations<Document>>(); 
ISolrQueryResults<Document> results = solr.Query("mainquery", new QueryOptions { 
    FilterQueries = new[] { 
        Query.Field("status").Is("public"), 
        new LocalParams {{"tag", "dt"}} + Query.Field("doctype").Is("pdf") 
    }, 
    Facet = new FacetParameters { 
        Queries = new[] { 
            new SolrFacetFieldQuery(new LocalParams {{"ex", "dt"}} + "doctype") 
        } 
    } 
});

We build object models like this one because they're programmable, objects and methods can be programmatically combined to build (or compose) our intention. Like Hibernate's Criteria API.

Opposed to this is the string, and most of the time we hate it because it's opaque, it doesn't have any syntactical meaning within our object-oriented code. It has no programmability, no composability. We use very generic classes to build strings, like StringBuilders or StringWriters, which don't convey any syntactical information about what we're actually doing. If we need to extract information from a string, we have to write a parser, which is not a trivial task. But the string also has its advantages: it's naturally serializable (or should I say already serialized), it can be more readable and more concise. And those are some of the reasons why Hibernate also provides the HQL API. You might be thinking that this dichotomy of objects and strings is really a matter of serialization and deserialization, but I'm talking about human-readable strings here, whereas a serialized format is frequently for machine consumption only.

So if we already know what the query string is, how can we simplify the chunk of code above? Thanks to IoC, we can easily tap into some of SolrNet's "internal" components without worrying about what dependencies they need:

Func<string, string, KeyValuePair<string, string>> kv = (k, v) => new KeyValuePair<string, string>(k, v); 
var connection = ServiceLocator.Current.GetInstance<ISolrConnection>(); 
var xml = connection.Get("/select", new[] { 
    kv("q", "mainquery"), 
    kv("fq", "status:public"), 
    kv("fq", "{!tag=dt}doctype:pdf"), 
    kv("facet", "on"), 
    kv("facet.field", "{!ex=dt}doctype"), 
}); 
var parser = ServiceLocator.Current.GetInstance<ISolrQueryResultParser<Document>>(); 
ISolrQueryResults<Document> results = parser.Parse(xml); 

ISolrConnection is just a wrapper over the HTTP request, we give it the querystring parameters and get Solr's XML response, then we feed the response to the parser component and voilà, we have our results.

And since it's just a regular HTTP request, we can go even lower:

using (var web = new WebClient()) { 
    var xml = web.DownloadString("http://localhost:9983/solr/select/?q=mainquery&fq=status%3Apublic&fq=%7B!tag%3Ddt%7Ddoctype%3Apdf&facet=on&facet.field=%7B!ex%3Ddt%7Ddoctype");
    var parser = ServiceLocator.Current.GetInstance<ISolrQueryResultParser<Document>>(); 
    ISolrQueryResults<Document> results = parser.Parse(xml); 
} 

I'll leave it to you to decide which one to use. Like the choice between HQL and Criteria, sometimes you might prefer one over the other depending on the context. Just keep in mind that these components' interfaces are not as stable as the "really public" documented interfaces, they might have breaking changes more often.

It's been a many months since the last release of WikiPlex, but its only because there hasn't been a lot of churn recently.  I've very happy where WikiPlex is at, and it continues to be a very… (read more)

The installer has encountered an unexpected error installing this package. This may indicate a problem with the package. The error code is 2738.

C:\Windows\System32\regsvr32 vbscript.dll

I can download the SharePoint CP and continue my work now. :)

• New site-wide design
• Redesigned Home page and Getting Started sections which streamline the experience for those who are new to ASP.NET
• Revised and updated content areas for both ASP.NET Web Forms and MVC
• Reviewed, re-categorized, and where appropriate, archived tutorial and video content. That was a pretty major undertaking, as some of that content had been around since ASP.NET 2.0

As you’d expect, Scott Hanselman has a great overview of what’s changed site-wide, but I’d like to highlight a few areas I was most involved with – the MVC Content area and a major update to the Community Projects / Open Source page.

ASP.NET/MVC changes

The ASP.NET MVC section was the new kid on the block on the ASP.NET website, so the asp.net/mvc page had less of a visual change than many of the other top-level pages. A lot of the work was in streamlining and prioritizing content, so you can (hopefully) find what you want faster, and there are new video introductions like Scott’s How Best To Learn ASP.NET MVC.

Here’s what it used to look like – content links on top, blog posts on the bottom, book links on the right.

In addition to cleaning up and updating the top content, we merged in the top asp.net/mvc/learn content now, and moved the blog content to the community page. This should increase the content relevance and point you towards more video / tutorial content by topic.

We some substantial changes to asp.net/mvc/learn. The previous page hit you with a wall of text and links, and the sub-pages were more of the same. It was a lot of information, but it wasn’t really categorized or prioritized in a way that helped you find what you were looking for. I reviewed literally hundreds of pages of content (video and tutorial) to categorize, pick the top content to feature on top level pages, and find outdated content that should be archived.

Here’s how the asp.net/mvc/learn page used to look:

Now that we’ve got the categories links on the asp.net/mvc page, they link to specific focus areas, like this asp.net/mvc/fundamentals page:

Keeping in mind that ASP.NET MVC 2 is due out soon, you should expect more changes here. For instance, I’ve been working hard on a new tutorial project with Scott Guthrie that will be finished soon, and I’ll be publishing a series of videos and tutorial articles covering that.

The new Open Source / Community Projects Page

Honestly, I’m most excited about one page in the site: the Open Source ASP.NET projects page. I got to run with this one, gathering input from a lot of open sourcey folks at Microsoft, compiling tons of links and project descriptions, and working with project owners when they didn’t have a published “Twitter pitch” description of their site published.

This page is not beautiful – it’s a long list of links and text. We’ve got some future changes to the site that will help us with the presentation, but as it is now, I’ll admit that it’s not a beautiful webpage.

And yet, it’s a thing of beauty. It made my day to see this kind of thing on Twitter: “Wow, an official Microsoft website listing open source tools for .NET. Didn’t think I’d see the day.” There’s a great open source community around ASP.NET open source, and it’s great to get the word out. This kind of thing is what the ASP.NET community is all about.

Yes, this kind of effort is fraught with peril. There are tons of .NET open source projects out there, how do we manage the list, adding relevant projects and keeping them updated as they change names every week (oh, you silly open source folk, you)? I’m still figuring that out. I was warned this would be a challenge, and I accept it wholeheartedly, because it’s important. The alternative – not doing the page because it’s hard – is much worse.

Let me know if I missed any that you think are important. I can’t add every project to the list, or it’ll grow large and useless, but I do want to make sure we capture a good sample.

Note: I put a lot of work into this page, but it wouldn’t have been part of this release without Terri Morton’s help. She really saw the value in it and helped push it through when it really could have slipped from this release – thanks, Terri!

Awesome? Awesomer.

Is the site perfect? No, it’s not. But I hope you’ll agree that it’s a lot better. We’ve got a lot more planned for this year, and this is the first step.

Sometimes in order to work with Open XML we need a little help from other tools.  In this post I am going to describe  a fairly simple solution for marking up PowerPoint presentations so that they can be used as templates and processed using the Open XML SDK.

Add-ins are tools which it can be hard to find information on.  I am going to up the obscurity by adding a Ribbon button.  For my example I am using Visual Studio 2008 and creating a PowerPoint 2007 Add-in project.  To that add a Ribbon Visual Designer.  The new ribbon by default will show up on the Add-in tab.

Add a button to the ribbon.  Also add a WinForm to collect a new name for the object selected.  Make sure to set the OK button’s DialogResult to OK. In the ribbon button click event add the following code.

ObjectNameForm dialog = new ObjectNameForm();

Selection selection = Globals.ThisAddIn.Application.ActiveWindow.Selection;

dialog.objectName = selection.ShapeRange.Name;

if (dialog.ShowDialog() == DialogResult.OK)

{

    selection.ShapeRange.Name = dialog.objectName;

}

This code will first read the current Name attribute of the Shape object.  If the user clicks OK on the dialog it save the string value back to the same place.

Once it is done you can retrieve identify the control through Open XML via the NonVisualDisplayProperties objects.  The only problem is that this object is a child of several different classes.  This means that there isn’t just one way to retrieve the value.  Below are a couple of pieces of code to identify the container that you have named.

The first example is if you are naming placeholders in a layout slide.

foreach(var slideMasterPart in slideMasterParts)

{

    var layoutParts =  slideMasterPart.SlideLayoutParts;

    foreach(SlideLayoutPart slideLayoutPart in layoutParts)

    {

        foreach (assmPresentation.Shape shape in slideLayoutPart.SlideLayout.CommonSlideData.ShapeTree.Descendants<assmPresentation.Shape>())

        {

            var slideMasterProperties =

                from p in shape.Descendants<assmPresentation.NonVisualDrawingProperties>()

                where p.Name == TokenText.Text

                select p;

            if (slideMasterProperties.Count() > 0)

                tokenFound = true;

        }

    }

}

The second example allows you to find charts that you have named with the add-in.

foreach(var slidePart in slideParts)

{

    foreach(assmPresentation.Shape slideShape in slidePart.Slide.CommonSlideData.ShapeTree.Descendants<assmPresentation.Shape>())

    {

        var slideProperties = from g in slidePart.Slide.Descendants<GraphicFrame>()

            where g.NonVisualGraphicFrameProperties.NonVisualDrawingProperties.Name == TokenText.Text

            select g;

        if(slideProperties.Count() > 0)

        {

            tokenFound = true;

        }

    }

}

Together the combination of Open XML and VSTO add-ins make a powerful combination in creating a process for maintaining a template and generating documents from the template.

    The San Francisco International Asian American Film Festival, one of my most favorite film festivals, is kicking off tomorrow. Here are the Vietnamese-related films:

The Fading Light/Theo Huong Den Ma Di
http://filmguide.festival.asianamericanmedia.org/tixSYS/2010/films/1030

Unidentified Vietnam No.18
http://filmguide.festival.asianamericanmedia.org/tixSYS/2010/films/1101

A Village Called Versailles
http://filmguide.festival.asianamericanmedia.org/tixSYS/2010/films/1103

Voices
http://filmguide.festival.asianamericanmedia.org/tixSYS/2010/films/1120

I am very much looking forward to Versailles, since I missed to see that at the Vietnamese International Film Festival, and it has been much talked about.

Cheers,
Minh T. Nguyen.

adplus -hang -p <PID> -o path to file 

http://support.microsoft.com/kb/286350

Partial Application

In a nutshell, partial application of a function is when you pass in only some of the parameters and get a function back that can accept the remaining parameters:

# define a simple function
function test {
    param($a, $b, $c);
    "a: $a; b: $b; c:$c"
}

# partially apply with -c parameter
$f = merge-parameter (gcm test) -c 5

# partially apply with -c and -a then execute with -b (papp is an alias)
& (papp (papp (gcm test) -c 3) -a 2) -b 7

# partially apply the get-command cmdlet with -commandtype
# and assign the result to a new function
si function:get-function (papp (gcm get-command) -commandtype function)

This is by no means a complete implementation of a partial application framework for powershell. The merge-parameter function (aliased to papp) currently only works with the default parameterset and does not mirror any of the parameteric attributes in the applied function or cmdlet. I'm not saying it couldn't do that, but this is purely a proof of concept. The module is listed below and is also available from PoshCode at http://poshcode.org/1687

# save as functional.psm1 and drop into your module path
Set-StrictMode -Version 2

$commonParameters = @("Verbose",
                      "Debug",
                      "ErrorAction",
                      "WarningAction",
                      "ErrorVariable",
                      "WarningVariable",
                      "OutVariable",
                      "OutBuffer")

<#
.SYNOPSIS
    Support function for partially-applied cmdlets and functions.
#>
function Get-ParameterDictionary {
    [outputtype([Management.Automation.RuntimeDefinedParameterDictionary])]
    [cmdletbinding()]
    param(
        [validatenotnull()]
        [management.automation.commandinfo]$CommandInfo,
        [validatenotnull()]
        [management.automation.pscmdlet]$PSCmdletContext = $PSCmdlet
    )
    
    # dictionary to hold dynamic parameters
    $rdpd = new-object Management.Automation.RuntimeDefinedParameterDictionary

    try {
        # grab parameters from function
        if ($CommandInfo.parametersets.count > 1) {
            $parameters = $CommandInfo.ParameterSets[[string]$CommandInfo.DefaultParameterSet].parameters
        } else {
            $parameters = $CommandInfo.parameters.getenumerator() | % {$CommandInfo.parameters[$_.key]}
        }        
                
        $parameters | % {
            
            write-verbose "testing $($_.name)"
                                    
            # skip common parameters        
            if ($commonParameters -like $_.Name) {                                  
                
                write-verbose "skipping common parameter $($_.name)"
                
            } else {
                
                $rdp = new-object management.automation.runtimedefinedparameter
                $rdp.Name = $_.Name
                $rdp.ParameterType = $_.ParameterType
                
                # tag new parameters to match this function's parameterset
                $pa = new-object system.management.automation.parameterattribute
                $pa.ParameterSetName = $PSCmdletContext.ParameterSetName
                $rdp.Attributes.Add($pa)
                
                $rdpd.add($_.Name, $rdp)
            }
            
        }
    } catch {
    
        Write-Warning "Error getting parameter dictionary: $_"
    }
    
    # return
    $rdpd
}

<#
.SYNOPSIS
    Function that accepts a FunctionInfo or CmdletInfo reference and one or more parameters
    and returns a FunctionInfo bound to those parameter(s) and their value(s.)
.DESCRIPTION
    Function that accepts a FunctionInfo or CmdletInfo reference and one or more parameters
    and returns a FunctionInfo bound to those parameter(s) and their value(s.)
    
    Any parameters "merged" into the function are removed from the available parameters for
    future invocations. Multiple chained merge-parameter calls are permitted.
.EXAMPLE

    First, we define a simple function:
    
    function test {
        param($a, $b, $c, $d);
        "a: $a; b: $b; c:$c; d:$d"
    }
    
    Now we merge -b parameter into functioninfo with the static value of 5, returning a new
    functioninfo:
    
    ps> $x = merge-parameter (gcm test) -b 5
    
    We execute the new functioninfo with the & (call) operator, passing in the remaining 
    arguments:
    
    ps> & $x -a 2 -c 4 -d 9
    a: 2; b: 5; c: 4; d: 9
    
    Now we merge two new parameters in, -c with the value 3 and -d with 5:
    
    ps> $y = merge-parameter $x -c 3 -d 5
    
    Again we call $y with the remaining named parameter -a:
    
    ps> & $y -a 2
    a: 2; b: 5; c: 3; d: 5
.EXAMPLE

    Cmdlets can also be subject to partial application. In this case we create a new
    function with the returned functioninfo:
    
    ps> si function:get-function (merge-parameter (gcm get-command) -commandtype function)
    ps> get-function
    

.PARAMETER _CommandInfo The FunctionInfo or CmdletInfo into which to merge (apply)
parameter(s.) The parameter is named with a leading underscore character to prevent
parameter collisions when exposing the targetted command's parameters and dynamic
parameters. .INPUTS FunctionInfo or CmdletInfo .OUTPUTS FunctionInfo #> function
Merge-Parameter { [OutputType([Management.Automation.FunctionInfo])] [CmdletBinding()]
param( [parameter(position=0, mandatory=$true)] [validatenotnull()] [validatescript({
($_ -is [management.automation.functioninfo]) -or ` ($_ -is [management.automation.cmdletinfo])
})] [management.automation.commandinfo]$_Command ) dynamicparam { # strict mode compatible
check for parameter if ((test-path variable:_command)) { # attach input functioninfo's
parameters to self Get-ParameterDictionary $_Command $PSCmdlet } } begin { write-verbose
"merge-parameter: begin" # copy our bound parameters, except common ones $mergedParameters
= new-object 'collections.generic.dictionary[string,object]' $PSBoundParameters #
remove our parameters, leaving only target function/CommandInfo's args to curry in
$mergedParameters.remove("_Command") > $null # remove common parameters $commonParameters
| % { if ($mergedParameters.ContainsKey($_)) { $mergedParameters.Remove($_) > $null
} } } process { write-verbose "merge-parameter: process" # temporary function name
$temp = [guid]::NewGuid() $target = $_Command # splat our fixed named parameter(s)
and then splat remaining args $partial = { [cmdletbinding()] param() # begin dynamicparam
dynamicparam { $targetRdpd = Get-ParameterDictionary $target $PSCmdlet # remove fixed
parameters $mergedParameters.keys | % { $targetRdpd.remove($_) > $null } $targetRdpd
} begin { write-verbose "i have $($mergedParameters.count) fixed parameter(s)." write-verbose
"i have $($targetrdpd.count) remaining parameter(s)" } # end dynamicparam process
{ $boundParameters = $PSCmdlet.MyInvocation.BoundParameters # remove common parameters
(verbose, whatif etc) $commonParameters | % { if ($boundParameters.ContainsKey($_))
{ $boundParameters.Remove($_) > $null } } # invoke command with fixed parameters
and passed parameters (all named) . $target @mergedParameters @boundParameters if
($args) { write-warning "received $($args.count) arg(s) not part of function." } }
} # emit function/CommandInfo new-item -Path function:$temp -Value $partial.GetNewClosure()
} end { # cleanup rm function:$temp } } new-alias papp Merge-Parameter -force Export-ModuleMember
-Alias papp -Function Merge-Parameter, Get-ParameterDictionary 

Have fun[ctional]!

Yesterday we created our first method in the MongoDbProvider, our implementation of BlogProvider. We created a few supporting classes, but we don’t have test for those classes. We recognize that we went a little bit too far in our coding. We got carry away and we started to implement a little bit more than needed to make the test pass.

So let’s fix that. First we need to see our first test passing. We run it expecting to fail to save and load the post but we have a different Exception thrown.

If we look at the code we notice that we made a big mistake in the Mongo class. We declared a _server private field but we are initializing a local server variable.
So when calling Disconnect on _server inside the Dispose method we get the NullReferenceException.
Let’s write a test to reproduce that bug at the unit level and see what else we can fix in that class.

Looking at it we discover a few dependencies that can be brake. First we create an IMongoMapperFactory interface and we make MongoMapperFactory to implement it.
There is another dependency, the name of the database to use. We made both parameters for the constructor inverting the dependencies.

          
  1:         public MongoDb(IMongoMapperFactory

mongoMapperFactory, string dbName) 

          
  2:         {



          
  3:             _mongoMapperFactory = mongoMapperFactory;



          
  4:             _dbName = dbName;



          
  5:         }

        

We also changed the Insert method:

          
  1:         publicvoid Insert<TEntity>(TEntity

entity) 

          
  2:         {



          
  3:             var document = _mongoMapperFactory.GetMapper<TEntity>().Map(entity);



          
  4:             Db(db=> db.GetCollection(entity.GetType().Name+"Docs").Insert(document)); 

          
  5:         }

        

Notice that the private Db method now takes an Action<Database>

          
  1:         privatevoid Db(Action<Database>

action) 

          
  2:         {



          
  3:             using (var

server = getServer()) 

          
  4:             {



          
  5:                 var db = server.getDB(_dbName);



          
  6:                 action.Invoke(db);



          
  7:             }



          
  8:         }



          
  9: 



          
 10:         private Mongo

getServer() 

          
 11:         {



          
 12:             var server = new Mongo(); 

          
 13:             server.Connect();



          
 14:             return server; 

          
 15:         }

        

And the newly created getServer() helper method to clean up the code. We also made some changes on the query method but I will leave that for the next post.

Our passing test result indicates some success.

Next: Mapping from Document to Entity and back.

If you can?t see what is written in the HTC ad to the right, click on the image.  What is displayed is a cross-correlation of several points of analytics data.  Before I jump right in and start explaining each point, think about what is going on with this ad.  This is by no means just some simple ad, there are a number of things going on here.

First data point.  Sprint & HTC, or whoever it is that put this ad together, has retrieved my listening favorites from Pandora.  Just looking at the bands listed shows that to be self evident.  This also seems to be the most obvious piece of data they could have collected about me, since I am logged into Pandora.  This is probably achieved by some web services or other API that Pandora provides advertisers.

The second data point is not immediately noticeable.  I am still at a loss to explain where they retrieved this data point.  What is it?  Concert dates for bands.  Each of the bands listed in the HTC app that is displayed is a coming show.  Matter of fact, it almost seemed like they had shown me my own HTC, except I don't own one.  :)

Now my location data, I am suspecting probably came from Pandora too, but it is the third point regardless.  All together the ad utilizes geo-positional location, my Pandora music preferences, and pulls local concerts from another source (maybe a Pandora listing too?).  This is a perfect use of preferences to display things that are truly relevant to me.

In addition, they may have just helped to sell me on a new phone for my personal line.  I am up for a replacement and anything that runs Google Droid seems cool, but I?ll admit, with the sneak peaks at Windows 7 Mobile that I've seen and the proposed ability to use Silverlight ? I WILL BE switching from the iPhone when that is released.

private static IEnumerable<T> Flatten<T>(IEnumerable<T[]> data)

{

    return from r in data from c in r select c;

}

Then, checking to make sure the data was valid, was easy:

var flattened = Flatten(data);

bool isValid = !flattened.Any(s => String.IsNullOrEmpty(s));

You could even use method grouping and reduce the validation to:

bool isValid = !flattened.Any(String.IsNullOrEmpty);

We are bringing back the administrator’s blog for Geekswithblogs.net as a place to get information for what is going on with GWB. Couple reasons we are doing this. One, I post a lot of information on my blog that is not Geekswithblogs.net related. Most the time it isn’t even developer related and I know I need to work on that too, but in an effort to keep the signal much higher than the noise, we are moving the information over there. The blog URL is http://geekswithblogs.net/administrator. The other reason we are doing it is I am not the only member of the GWB staff. So please subscribe to that blog and let us know what you think about Geekswithblogs.net and how we can make the site better.

http://geekswithblogs.net/administrator

Freude herrscht! :-)

[1] http://www.microsoft.com/silverlight/partner/directory/

Last week while I was working on my open source project WeBlog, I built an HTTP Handler to serve up images. I started using an HTTP Handler for images because I needed a mechanism to prevent bandwidth leeching. The only bad thing about using an HTTP handler for images is that you end up with some pretty ugly URLS. In my case the URL ended up looking like this:

/Image.axd?image=sample.png

Luckily, my friend Ron noticed my new HTTP Handler and mentioned that I could have accomplished the same thing with a controller action that returned a FileResult instead. After a bit of investigation, I realized that Ron was absolutely right. I deleted my HTTP Handler and replaced it with this code, which was added to the Home Controller:

private string GetContentType(string filename) {
    FileInfo file = new FileInfo(filename);            
    switch (file.Extension.ToUpper()) {
        //images
        case ".PNG" : return "image/png";                                
        case ".JPG" : return "image/jpeg";                    
        case ".JPEG": return "image/jpeg";                    
        case ".GIF" : return "image/gif";                    
        case ".BMP" : return "image/bmp";                    
        case ".TIFF": return "image/tiff";
        default:
            throw new NotSupportedException("The Specified File Type Is Not Supported");
    }            
}

public FileResult GetImage(string id) {
    string path = Path.Combine(Engine.GetImageDirectory().FullName, id);            
    return base.File(path, GetContentType( path ) );
}

Since this code resides in my Home controller I would need to use the URL like “/Home/GetImage/sample.png” to display an image. Admittedly this URL is still a big ugly, so I decided to use a custom route to clean it up. The new custom route is named “Images” and is mapped it to the Home controller’s GetImage method. Here is the entry used in the global.asax file:

routes.MapRoute("Images",
    "Images/{id}",
    new { controller = "Home", action = "GetImage", id = "" });

Now I can display images by using the following URL:

”/Images/sample.png”

To the end user, this looks like a traditional file path. However, in reality there is no “Images” folder in the root directory. “Images” is just the name of the route being used. In reality, the image files are actually stored in the App_Data/Images folder.

By using a FileResult object with MVC you not only get a pretty URL but you also get a lot of flexibility on where you want your images to reside. You can store images anywhere you want and the URL will never need to change!

It’s a just-in-time unit testing coach that looks at your code as you type and looks for common unit testing errors.

Or, you can just watch this movie:

SOA/REST/M/Oslo

• SOA in a Nutshell - A new JP Morgenthal’s post “The Busy Executive’s Service Oriented Architecture Reference Guide” is a great starting point for gaining a quick understanding of what SOA is without getting too deep into technology jargon and hype
• Don Box Discusses SOAP, XML, REST and M - In this interview from QCon San Francisco 2009, Don Box discusses the history of SOAP, XML, XML Schema, RELAX NG, SOAP and WSDL, REPL, opinions on REST, REST at Microsoft, coexistence of REST and WS-*, the M programming language, M and DSLs, M versus XML/XML
• Is OData the Ubiquitous Language for Application Collaboration? - The Open Data Protocol (OData) specification opens up possibilities to a lot of interesting collaborative use-cases and scenarios. Some of which are highlighted by Douglas Purdy, Pablo Castro and Jon Udell.
• ActAs in WS-Trust 1.4 - Pablo Cibraro talks about a new feature in WS-Trust 1.4;  new feature called as “ActAs” for addressing common scenarios where an application needs to call a service on behalf of the logged user or a service needs to call another service on behalf of the original caller.

There exists an entrenched belief that there's only one way to develop with WebForms, i.e. rely on the crunch of view state, postbacks, session, etc. I beg to differ. You can write cleaner, cohesive, more testable code, and I intend to prove it.

At my session, we will

• talk about what it takes to write highly cohesive, loosely coupled code
• see what Inversion of Control (IoC) and Dependency Injection (DI) are all about
• look at appropriate ways of using an IoC container

If accepted, I also plan on giving this talk at the Utah Code Camp on March 27 and Richmond Code Camp on May 22. If you are "in the area," please stop by. ;)

http://www.wintellect.com/CS/blogs/jlikness/archive/2010/02/23/top-10-silverlight-myths-and-the-facts-to-bust-them.aspx

Similarly, here is another googd article on why  Why HTML 5 Won’t Kill Flash or Silverlight