My script accepts a domain, resolves the IP(s) used in DNS, runs an HTTP Get on the host name and / or hostname with WWW.  It returns a status code, the AbsoluteURI.  This is handy when you are processing 100's of domains trying to determine if they are valid.  PS - One of my favorite features is the EmulateDig option.   DIG is my favorite tool for DNS stuff. Thanks Joel!

#Here is the script

param
(
# [String] $DNSConfigFileList = $(throw "Please specify the external text file of domain names to lookup"),
#Sample Syntax
 #.\Get-DNSLookup.ps1 www.iislogs.com C:\Temp\Log.txt 192.168.1.40
 [String] $Domain = $(throw "Please specify the domain to lookup"),
 [String] $DNSLogFileAndPath = $(throw "Please specify the path where you want results logged"),
 [String] $DNSServer = $(throw "Please specify the DNS Server used for performing external queries. i.e It has to be an ip address, not server name")
)

#Example of using a text file of domain names
#$DomainList = Get-Content C:\Temp\CompleteList.txt

function Log-Information
{

 param
 (
  $Information
 )

 Add-Content $DNSLogFileAndPath $Information
}

function Get-DNSRecords
{
 param
 (
  $Domain,
  $DNSQueryResult
 )
 if($DNSQueryResult.Error.Length -ne 0)
 {
  Log-Information "There was an error with $($Domain)"
 }
 
 $DNSPublicationCount = $DNSQueryResult.Answers.Count
 if($DNSPublicationCount -eq 0)
 {
  $IsProblem = $true
  Log-Information "$($Domain):DNSPublicationCount is zero"
 }
 else
 {
  $arrIPs = "$($Domain)"
  for($i=0; $i -lt $DNSPublicationCount; $i++)
  { 
   
   $DNSIPA = $DNSQueryResult.Answers[$i].Record
   $DNSIPB = $DNSIPA.Address.IPAddressToString
   
   if($DNSIPA.Address.IPAddressToString -ne $null)
   {
    $arrIPs += ",$($DNSIPB)"
   }  
  }
  
  $WebResult = Get-WebResponse $Domain
  Log-Information "$($arrIPs),$($WebResult)"
 } 
}

function Get-WebResponse
{
 param
 (
  [string]$URL
 )

 #Try the host name first
 try
 {
  $Request = [System.Net.WebRequest]::Create("http://$URL")
  $Response = $request.GetResponse()
  $RequestStream = $response.GetResponseStream()
  $ReadStream = new-object System.IO.StreamReader $requestStream
  $Results = $readStream.ReadToEnd()
  $ReadStream.Close()
  $Response.Close()

  $AbsoluteUri = $Response.ResponseUri.AbsoluteUri
  $StatusCode = $Response.StatusCode.value__
  return "$($StatusCode),$($AbsoluteUri)"
 }
 catch
 {
  #Try with the WWW domain
  try
  {
   $Request = [System.Net.WebRequest]::Create("http://www.$URL")
   $Response = $request.GetResponse()
   $RequestStream = $response.GetResponseStream()
   $ReadStream = new-object System.IO.StreamReader $requestStream
   $Results = $readStream.ReadToEnd()
   $ReadStream.Close()
   $Response.Close()

   $AbsoluteUri = $Response.ResponseUri.AbsoluteUri
   $StatusCode = $Response.StatusCode.value__
   return "$($StatusCode),$($AbsoluteUri)"
  }
  catch
  {
   return "$($StatusCode),$($AbsoluteUri)"
  }  
 }
}

function Clear-DNSCache
{
 $command = "c:\Windows\System32\dnscmd.exe /clearcache"
 Log-Information "running command:$command"
 Invoke-Expression $command
}

#Load the PoshNet Get-DNS snapin
#Make sure to download Poshnet CMD from
# http://huddledmasses.org/powershell-dig-nslookup-cmdlet/ 
#You need to install before running this script

Add-PSSnapIn PoshNet

#Clear DNS Cache on the server, assuming it's local to the machine running the script
#The DNS service is assumed to be run local

Clear-DNSCache

#Loop through the domains on the
#foreach($Domain in $DomainList)
#{
# $DNSQueryResult = Get-Dns -Name $Domain -DnsServers $DNSServer
# Get-DNSRecords $Domain $DNSQueryResult
#}

#Run a single query against one domain

$DNSQueryResult = Get-Dns -Name $Domain -DnsServers $DNSServer
Get-DNSRecords $Domain $DNSQueryResult

Write-Host "Done"

Please be aware that:

1. I am not an expert in statistics by any stretch of imagination
2. Ditto for numerical methods
3. I have made only a handful of very basic tests

Having said that, the function *seems* to be working so I hope it will help somebody .

Our MonoTouch Book is out.  It was great working with Chris Hardy, Craig Dunn, Martin Bowling, and Rory Blyth on this book.  With this book, you'll be able to use your existing knowledge of .NET

A Word About Apple SDK License #3.3.1

I recently started working on my (long long overdue) master's thesis, and naturally I came to LaTeX for typesetting. As a LaTeX newbie*, I was pleased to find out that compiling LaTeX is just like compiling any program: there's a bunch of source code files (.tex) and resources (.bib, .sty, images) which you feed to preprocessors and compilers to yield a dvi/ps/pdf document. TeX is actually a turing-complete language, and LaTeX is a macro collection and a preprocessor for TeX.

There's even an online package repository!

And since writing LaTeX has so many similarities with writing code, even if you're just writing text and using existing LaTeX macros and not developing your own, some of the development practices can be applied here as well, like a build system, refactoring to keep the document manageable, version control, and continuous integration.

Continuous integration is nice not only because it asserts that the document is valid (yes, you can screw up TeX documents), but also you automatically get the resulting PDF as a build artifact. You could even hook a diff step in the process, to make reviews easier.

But finding a public continuous integration server is hard, not to mention one with a LaTeX distribution installed. Luckily, LaTeX compilation can be delegated to a remote server, thanks to CLSI (Common LaTeX Service Interface). So all the integration server has to do is forward a compilation request to the CLSI server when it detects changes in the VCS.

The arrow directions in the graphic indicate information flow, and the numbers order the actions.

How you implement this depends on what the integration server supports. For example, if it's Windows you can send a manually assembled compilation request (it's a simple XML) with a JScript script.

You can also use a CLSI server as a replacement for a local LaTeX installation. In that case you have to send the actual .tex file contents instead of just an URL, wrapped in a CLSI XML compilation request. I wrote a simple CLSI client in F# to do this, so a compilation script looks like this:

I'm using git and github for version control and ScribTeX's CLSI server, which is the only public CLSI server I have found so far. Kudos to ScribTeX for that! It's very fast (even faster than compiling locally!) and open source.

If you just want an online editor with integrated revision control and preview, check out ScribTeX's editor.

Also worth checking out is LaTeX Lab, a very cool open source, online LaTeX editor for Google Docs, by the same guy that developed CLSI (Bobby Soares).  It's currently on a preview release but it's very usable.

* Actually, I did use LaTeX several years ago, but I did so through LyX, which combines LaTeX with WYSIWYG, so I didn't really learn LaTeX.

• Name oder IP-Adresse des Remote-Servers
• auszuführendes Command
• Credentials (abweichend vom TFS-Service-Account)

[BuildActivity(HostEnvironmentOption.All)]
public sealed class StartProcessOnRemoteMachine : CodeActivity
{
    [RequiredArgument]
    public InArgument<string> Command
    {
        get;
        set;
    }

    [RequiredArgument]
    public InArgument<string> RemoteMachine
    {
        get;
        set;
    }

    [RequiredArgument]
    public InArgument<string> Username
    {
        get;
        set;
    }

    [RequiredArgument]
    public InArgument<string> Password
    {
        get;
        set;
    }

    [RequiredArgument]
    public InArgument<string> Domain
    {
        get;
        set;
    }
}

private static void ExecuteProcessOnRemoteMachine(string remoteMachine, string username, string password, string domain, string commandLine)
{
    ConnectionOptions connectionOptions = new ConnectionOptions();
    connectionOptions.Authority = "ntlmdomain:" + domain;
    connectionOptions.Username = username;
    connectionOptions.Password = password;
    connectionOptions.Authentication = AuthenticationLevel.Default;
    connectionOptions.Impersonation = ImpersonationLevel.Impersonate;
    connectionOptions.EnablePrivileges = true;

    ManagementScope managementScope = new ManagementScope(string.Format(@"\\{0}\ROOT\CIMV2", remoteMachine), connectionOptions);
    managementScope.Connect();

    ManagementPath managementPath = new ManagementPath("Win32_Process");
    ManagementClass processClass = new ManagementClass(managementScope, new ManagementPath("Win32_Process"), new ObjectGetOptions());
    ManagementBaseObject inParams = processClass.GetMethodParameters("Create");
    inParams["CommandLine"] = commandLine;

    ManagementBaseObject outParams = processClass.InvokeMethod("Create", inParams, null);
}

protected override void Execute(CodeActivityContext context)
{
    string startProcessCommand = context.GetValue(this.Command);
    string remoteMachine = context.GetValue(this.RemoteMachine);
    string username = context.GetValue(this.Username);
    string password = context.GetValue(this.Password);
    string domain = context.GetValue(this.Domain);


    ExecuteProcessOnRemoteMachine(remoteMachine, username, password, domain, startProcessCommand);
}

I pointed @tareqsartawi to @toddbaginski’s post Which SharePoint 2010 Site Template Is Right For Me? and while Todd does go over the templates and gives a brief rundown of them, there’s not a lot of meat to what you get with each template.

So for Tareq (and anyone else who’s out there) here’s a more detailed breakdown of the site templates in SharePoint 2010.

This is part 1 of a four-part post as I got past the 2 hour mark and decided I would call it quits with the initial templates. I’ll follow it up with additional posts to complete all of the template descriptions and notes (and link everything together to make it a happy-happy-joy-joy world we live in).

Note, this is a list of the templates you get with SharePoint Server 2010. For SharePoint Foundation 2010, you’ll only find a subset of what you see here (but there’s nothing Foundation has that Server doesn’t). Also there are some templates that will only appear after activating certain site or site collection features. I’ll cover some of those in a bonus post later. Clear as mud?

Creating Sites

When you create a new site you’ll see the new create dialog like the one below (there’s a regular HTML version but you really want to install Silverlight on your client to get the rich UI experience).

Each category along the site lets you filter down the template selections and selecting any template gives a brief description to give you an idea of what the template is about.

Here’s the rundown on what’s available out of the box (and what is covered in what blog post):

• Blank & Custom
• Blank Site (This Post)
• Personalization Site (Part II)
• Collaboration
• Team Site (This Post)
• Document Workspace (This Post)
• Group Work Site (This Post)
• Enterprise Wiki (This Post)
• Content
• Document Workspace (This Post)
• Blog (This Post)
• Document Center (Part II)
• Publishing Site (Part II)
• Publishing Site with Workflow (Part II)
• Enterprise Wiki (This Post)
• Visio Process Repository (Part II)
• Data
• Records Center (Part II)
• Meetings
• Basic Meeting Workspace (Part IV)
• Blank Meeting Workspace (Part IV)
• Decision Workspace (Part IV)
• Social Meeting Workspace (Part IV)
• Multipage Meeting Workspace (Part IV)
• Search
• Basic Search Center (Part II)
• Web Databases
• Assets Web Database (Part III)
• Charitable Contributions Web (Part III)
• Contacts Web Database (Part III)
• Issues Web Database (Part III)
• Projects Web Database (Part III)

There’s some duplication above in the categories but out-of-the-box you get 23 templates (3 new site templates, 5 new site templates based on Access databases). For more details about what’s been added, removed, and updated as far as templates go please see Todd’s original post.

Select a template, enter a title and a url, and click Create and you’re off to the races. If that’s all you need you can be creating sites in no time. Each template has it’s share of not only a look and feel, but also what content is pre-loaded on the site and in some cases, what features are activated as a result of creating that site which light up the site and offer the user some options. For the most part any feature on the system can be applied to any site so it almost doesn’t matter what template you start with, but there are some exceptions and we’ll note them as we go along.

If you want a little more control when you create your site, clicking on More Options brings up a second dialog that lets you enter, well, more options:

The options are the same no matter what template you choose and I couldn’t find any way to build something that would you let amend options here. Would be nice in the future. The only real advantage here is that you can break permissions on the site before it gets created and use the top link bar from the parent site (which is turned off by default for new sites). Any of these can be done after the site is created anyways.

Note that these dialogs appear in a popup when you select Create Site from the Site Actions menu. If you go the route of Site Settings > Site Administration > Sites and Workspaces then click Create you’ll see this screen in the browser (not a popup):

This is the more traditional screen you might be used to from 2007. The templates and choices are all the same and this screen offers changing all options, much like the More Options dialog from above. How you create your sites is up to you, typical SharePoint there are just several routes to get to the same path.

Alright, let’s get down and dirty with each template.

Blank Site

“A blank site for you to customize based on your requirements.”

The core of any SharePoint site, the blank site. So simple and elegant yet devoid of any content. Basically a site you can turn into anything by lighting it up with features. Personally when we build “applications” in SharePoint this is the template we start with. The big difference from the “Blank” site template you got in 2007 is that this one really is blank and doesn’t come pre-loaded with a SharePoint logo dropped on your “blank” site like 2007 did.

Team Site

“A site for teams to quickly organize, author, and share information. It provides a document library, and lists for managing announcements, calendar items, tasks, and discussions.”

This template is perhaps one of the most used since SharePoint started using templates. Most everyone uses SharePoint for collaboration so this is one of the original collaboration tools out there. In 2010 many things are the same as they were in the 2007 Team Site template. You still have a Shared Documents library, a Calendar has been created, a Task list and a Team Discussion discussion board is here. With 2010 there are some major changes though that make it arguably a better collaborative environment it ever was.

First off everything is a wiki. Keep remembering that. Everything is editable. Remember when you created that first Team Site in 2007 and you wanted to start editing the page but found out you had to drop a content editor web part on the page, open up the right text editor, type something in, then click a few buttons to see what it all looked like? That’s not collaboration. That’s just plain painful.

The Team Site template, along with others, treats any page as a content page. Just click edit and start typing content. Want a picture on your site? Drop a media web part on it and upload it to the automatically created Site Assets library while you edit. Collaboration has never been as simple as this.

Getting back to the template itself, you’ll notice a few new libraries created. There’s a new Site Assets library which allows you to upload media (pictures, video, audio) to the site and use it on pages via the Media Web Part. There’s a Site Pages library that contains all your pages (including the home page) so as you create new content, just drop it in here. The Announcements, Calendar, Links, Tasks, and Discussions you got in 2007 are still created, they’re just not visible on any page so you’ll have to either add them yourself or use the Quick Launch to access them.

Note that the Getting Started section that’s added to the site is just content. It’s not a list behind it, it’s just HTML content that you can edit, delete, or use.

Document Workspace

“A site for colleagues to work together on a document. It provides a document library for storing the primary document and supporting files, a tasks list for assigning to-do items, and a links list for resources related to the document.”

The document workspace is pretty cheesy and basically a carry-over from 2007. It was always intended to be a site where you would collaborate around a single document (aggressively) and I always thought it would well in a publishing environment. Create the document, everyone works on it, there are discussions around it and tasks assigned to take care of parts of it.

There were even facilities in Word to attach the document to a workspace (or create the workspace) when you saved the document. However say in the last 5 years I have yet to create a site with this template, other than demos (and this blog post). Perhaps it could still work for say a manuscript with multiple authors or a manual or training guide but I think 2010 has more to offer with Document Sets than to use this aging template.

At least they got the Announcements web part on the home page.

Group Work Site

“This template provides a groupware solution that enables teams to create, organize, and share information quickly and easily. It includes Group Calendar, Circulation, Phone-Call Memo, the Document Library and the other basic lists.”

If you remember 2007, there was an after-market release called Group Workspace Board. It was a Microsoft template and offered the ability to essentially create an in/out board site. Trouble is that it didn’t work very well, service packs sometimes broke it (or the server) and it was never upgraded. Well, it’s back (although I’m sure they rebuilt it from scratch so pay no attention to the comments above). Basically the Group Work Site is a uber-enhanced blank site with some content added (after all, isn’t that what *all* sites are?).

The Group Board is a pretty slick template and centers around a group calendar, which is really just a normal calendar but the regular Event content type has been removed and replaced with two new content types for 2010, Schedule and Reservations and Reservations. Basically if you’re looking to use SharePoint for a reservation system (reserving fleet vehicles, meeting rooms, books, or anything you want to track) then this template might work for you. At the very least, create one to see how the Group Calendar is setup and you can rebuild your own in your own site. It’s a nice Content Type that probably deserves its own post as there are a lot of great features you can get out of it.

Note that because the Group Calendar is really just a Calendar, you can connect it to Outlook but if you’re looking to use SharePoint as a meeting reservation system tied into the resources available in Outlook (like you might today) you’ll be out of luck. The two are not connected but they use the same terms so you might get confused over using them for the same purpose.

Enterprise Wiki

“A site for publishing knowledge that you capture and want to share across the enterprise. It provides an easy content editing experience in a single location for co-authoring content, discussions, and project management”

Remember everything is a wiki? Good. You’re still reading. Well, everything is a wiki but there’s still a template with the name Enterprise Wiki. I guess sticking “Enterprise” in front of something makes it that much more important?

The Enterprise Wiki is pretty much what you got in 2007 when you created a Wiki site. The old Wiki site template is gone and this stands in it’s place. Even though you can edit any page on a site, this template is specifically setup for building a wiki. While it can’t compete with Wikipedia, Confluence, or any of the *real* enterprise wiki’s out there it’s a nice place for putting together group notes about a subject. You could put together a blank site and just keep creating pages but then there’s the navigation element and having to deal with inserting hyperlinks onto pages, etc. The Wiki template stays true to the (albeit weird non-standard) Wiki mark-up SharePoint established in 2007 and lets you cheerfully link pages together with a simple [[My New Page]] mark-up.

In addition to what we already had in 2007, there are some new features that light up the Enterprise Wiki template. Namely ratings and categories. The rating system is the same that’s built into 2010 but it’s embedded on each page template along with a category picker. This allows you, after adding content to a larger site, be able to navigate content by popularity or categories (configured through the managed metadata services).

While the mark-up hasn’t changed much, a wiki page is just like any other page in SharePoint so you can embed pictures, video, tables, web parts, and SharePoint lists right onto the page. This makes the experience of building out a knowledge base using the Enterprise Wiki a more palatable experience and lets you be a little more creative without being overly constrained.

Blog

“A site for a person or team to post ideas, observations, and expertise that site visitors can comment on.”

Blogs are like wikis in SharePoint. They’re just OK and better than editing content editor web parts, but still fall short of a full blown blogging engine like dasBlog or WordPress. However in 2010 things have got a little better (don’t get too excited, I said a “little” better).

Overall the presentation is cleaner, looking more like a blog like we traditionally know it. Permalinks are native now and overall the blog template sucks a little less than 2007. Instead of editing the blog page right on the site, you’re forced to edit in a popup window with a diminished rich text editor. You can still insert images and video but it’s a little less seamless when you edit blog posts this way. Still the basics are there, categories and comments, RSS feeds and the ability to edit your blog from a blogging tool like Windows Live Writer or even Microsoft Word (and publishing from Word while giving an uneasy odd feeling, sucks a little less than it did).

While things are better than their 2007 counterparts you might still want to look at the Community Kit for SharePoint – Enhanced Blog Edition or customize the existing blog template if you want to focus on blogs in your organization. There are a lot of features in SharePoint 2010 that are native that really should be stock with the blog template. Why can’t I rate blog entries? Where are the tagging features? These things can all be done relatively easy even from the browser with no coding required. Just remember to save the template and make it available to your users (time for an Enterprise Blog template anyone?).

Wrap-up

Well, that’s it for now to get the ball rolling. Let me know your thoughts. Hope that gets things going and helps out. More templates to come later! Enjoy.

Today we released Version 6.2 of the VG.net vector graphics system. Changes include:

• Visual Studio 2010 support.
• The new Center Selection button, in the Drawing Toobar, pans the designer surface to center the selected Elements.
• Double-clicking on a Group makes it the Active Group. When a Group is active, double clicking on the background deactivates the Active Group.
• You can now make a nested Group the Active Group. The Group can be nested to any depth. Formerly, you could only make a top-level Group the Active Group.
• Keyboard shortcuts for zooming and panning.
• Use the new PixelSnapMode property, in the RenderAppearance class, to increase the clarity of thin lines, or the edges of rectangles, by snapping points to pixel coordinates. PixelSnapMode values:
  • None
  • Absolute: points are snapped to pixels by rounding absolute coordinates.
  • VectorCenter: a new, unique type of snapping. The Element's Center is snapped to a pixel point. Vectors from the Center to each point are then snapped to a pixel boundary. By snapping vectors rather than points, a small Shape improves its clarity and symmetry.
  • BoundsAbsolute: the upper left and lower right corner of the Element's Bounds are snapped by rounding their absolute coordinates. Interior points in a Polyline or Path are not snapped.
• Visual Basic versions of some samples.
• The ThemedRobot and ThemedRobotVB samples, in the Extras package, demonstrate how to use Groups, Rotation transformations, and TransformationReference settings to create a segmented robot arm.
• Bug fixes.

Below are screenshots illustrating PixelSnapMode for small Shapes. First we created Shapes, all the same dimensions, then we zoomed out so the Shapes were no longer naturally aligned on pixel coordinates. From the left to the right, the following PixelSnapMode values were used: None, Absolute, Vector Center. Blown-up versions of the same images are on the second row.

Notice how the VectorCenter PixelSnapMode keeps all small shapes at a consistent size, even though they are positioned at fractional pixel distances from one another. PixelSnapMode has no real benefit for Ellipses or Arcs; it is best for Shapes containing some straight lines. It is useful for larger Shapes as well. Below we show the effect of PixelSnapMode on larger Shapes. On the left is None, on the right is VectorCenter:

Debugging is as easy as any ordinary ps1 script file:

All functions in backing module reflect the same signature as those found on MSDN. This means that you go to MSDN documentation on providers to learn about how to write the corresponding script.

Current Release PSProvider 0.4

Samples and Templates

• See Documentation

Roadmap

0.1

• ContainerCmdletProvider support through "ModuleBoundProvider" provider
• Demo provider included navigating a Hashtable
• Can be debugged in the debugger of your choice: console, ISE, PowerGUI.

0.2

• NavigationCmdletProvider support
• Providers rename to ContainerScriptProvider and TreeScriptProvider
• Container Sample & Tree Template modules
• Supports: Clear-Item, Copy-Item, Get-Item, Invoke-Item, Move-Item, New-Item, Remove-Item, Rename-Item, Set-Item

0.3

• IContentCmdletProvider support
• New Commands: New-ContentReader, New-ContentWriter implement IContentReader, IContentWriter
• Adds support for: Add-Content, Clear-Content, Get-Content, Set-Content

0.4 (Current Release)

• IPropertyCmdletProvider support
• Adds support for: Clear-ItemProperty, Copy-ItemProperty, Get-ItemProperty, Move-ItemProperty, New-ItemProperty, Remove-ItemProperty, Rename-ItemProperty, Set-ItemProperty

0.5

• Dynamic Parameter support

0.6

• Security Interfaces
• Adds support for: Get-ACL, Set-ACL

http://psprovider.codeplex.com/

The release notes show what's new, so I won't repeat that here. Overall, I'm feeling pretty good about how it's coming along. I spent a lot of time fleshing out admin functionality, which is about the least exciting thing, but it's a lot easier to exercise the app when you can change stuff via the UI instead of poking around a database.

I would like to have a beta version out in September, and if my spare time continues to be available at the same rate, and my baby boy is happy and healthy (and sleeping in the evenings), I think there's a reasonable shot at it happening. I can see an RC even coming shortly after even. Remember the goal is to get to feature parity with v8.x first, and then go further.

• The WCF Client Side Proxy Patch is included (it was not included with 2010.1.0720.0)
• The namespace "Proxies" was hard coded in the client proxy template, this was fixed.
• The “char” modified column count error has been fixed.
• The case sensitive bug when returning columns with a different case than defined in the actual table error has been fixed.

The Trial version is still 2010.1.0720.0

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 300k. 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 7/25/2010 9:15:48 PM http://odetocode.com/Blogs/scott/archive/2010/07/25/notes-on-templates-and-data-annotations-in-mvc-2.aspx Brad Wilson has an excellent series of 5 blog posts on model metadata and templates you can use to get started with templates and metadata in ASP.NET MVC 2. Here are a couple notes I've made around some of aspects that commonly confuse developers (including me, it seems).

1. Although most of the metadata attributes live in the System.ComponentModel.DataAnnotations namespace, there are a few exceptions. If you aren't seeing something you need in Intellisense, then try adding System.ComponentModel (for the popular DisplayName attribute) and System.Web.Mvc (for the popular HiddenInput attribute).

2. Some of the confusion around data annotations exists because the MVC runtime doesn't recognize every data annotation attribute built into .NET. For example, using [Editable(false)] is tempting, but you'll find it doesn't have any impact in model binding, validation, or templating. The built-in templates respect 7 data annotation attributes:

• DisplayColumn
• HiddenInput
• UIHint
• DataType
• DisplayFormat
• ScaffoldColumn
• DisplayName

3. There are two additional attributes the default model metadata provider will consume:

• ReadOnly
• Required

However, the built-in templates do not make use of the information from these attributes. For example, you can apply [ReadOnly(true)] to a property, but you'll find the default templates in use by helpers like Html.EditorForModel will still show a textbox input for the user to enter a value. If you want to get rid of the input with EditorForModel you'll need a custom template, or you'll need to use [ScaffoldColumn(false)].

Note the default model binder does respect the ReadOnly attribute, so it won't move a value into a property with [ReadOnly[false)]. Also, the built-in validation logic respects the Required attribute. These attributes definitely have value in an MVC app, but they won't influence the UI rendered by the default templates.

The one drawback that I can see is when the client needs to perform small & frequent BLOB updates.  Rather than writing to SQL Server data files, FILESTREAM writes to the file system.  Locating, creating, updating, deleting files outside of the SQL Server data files do come at a cost.  So some consideration as to the size & frequency of BLOB data would need to be made.

There are a few ways to enable FILESTREAM (SQL Server Configuration Manager, SQL Server Management Studio properties of the connected instance, and via TSQL scripting).  Personally I was only able to get it to work by using the SQL Server Configuration Manager.  Apparently installing Visual Studio/SQL 2005 can screw up FILESTREAM features of SQL 2008…  Anyway, here’s the basic FILESTREAM access levels which you’ll need to understand when enabling it.

FILESTREAM access levels:
a) 0 = Disables FILESTREAM support for this instance.
b) 1 = Enables FILESTREAM for Transact-SQL access.
c) 2 = Enables FILESTREAM for Transact-SQL and Win32 streaming access.

I created a script which enables FILESTREAM for the SQL Instance, then it enables it for my “testdb” database.  It auto-detects where your database’s data/log files reside and then creates a directory in there for FILESTREAM objects.

   1:  USE [master];

   2:  GO

   3:  DECLARE @filestream_access_level SMALLINT;

   4:  SELECT @filestream_access_level = CONVERT(SMALLINT, SERVERPROPERTY('FilestreamEffectiveLevel'));

   5:   

   6:  IF @filestream_access_level <> 2

   7:  BEGIN

   8:      EXEC sp_configure filestream_access_level, 2;

   9:      RECONFIGURE WITH OVERRIDE;

  10:  END;

  11:  GO

  12:   

  13:  USE [testdb];

  14:  GO

  15:  IF NOT EXISTS (SELECT * FROM sys.filegroups AS fg WITH (NOLOCK) WHERE name = 'testdb_FILESTREAM')

  16:  BEGIN

  17:      --add a file group and indicate that it will contain FILESTREAM objects

  18:      ALTER DATABASE testdb ADD FILEGROUP testdb_FILESTREAM CONTAINS FILESTREAM;

  19:  END;

  20:  GO

  21:  IF NOT EXISTS (SELECT * 

  22:      FROM sys.filegroups AS fg WITH (NOLOCK) 

  23:          INNER JOIN sys.database_files AS df WITH (NOLOCK) ON fg.data_space_id = df.data_space_id 

  24:      WHERE fg.name = 'testdb_FILESTREAM'

  25:          AND df.name = 'testdb_FILESTREAM')

  26:  BEGIN

  27:      DECLARE @path NVARCHAR(MAX), @sql_statement NVARCHAR(MAX);

  28:      SELECT @path = mf.physical_name FROM sys.master_files AS mf WITH (NOLOCK) WHERE mf.name = 'testdb' AND mf.type_desc = 'ROWS';

  29:      SELECT @path = SUBSTRING(@path, 1, LEN(@path) - CHARINDEX('\', REVERSE(@path))) + '\testdb_FILESTREAM';

  30:   

  31:      --tell the file group where the FILESTREAM objects should be stored

  32:      SELECT @sql_statement = N'ALTER DATABASE testdb ADD FILE (NAME = ''testdb_FILESTREAM'', FILENAME = ''' + @path + ''') TO FILEGROUP testdb_FILESTREAM;';

  33:   

  34:      EXEC sp_executesql @statement = @sql_statement;

  35:  END;

  36:  GO

At this point I was ready to design a table in SQL Management Studio with a FILESTREAM column.  A FILESTREAM column is actually a varbinary(max) column with the FILESTREAM attribute.  Well, the table designer in SQL Management Studio does not support specifying the FILESTREAM attribute.  You have to script it.

Here’s some rules which you’ll need to adhere to when creating FILESTREAM columns.
1) The table can have multiple FILESTREAM columns, but they must all be in the same FILEGROUP.
2) If you don’t specify the FILESTREAM_ON clause, the default FILEGROUP will be used.
3) The table must have a uniqueidentifier column with the ROWGUIDCOL attribute.  It cannot contain NULL values and must have either a UNIQUE or PRIMARY KEY single column constraint.

   1:  USE [testdb];

   2:  GO

   3:  IF NOT EXISTS (SELECT * FROM sys.tables AS t WITH (NOLOCK) WHERE t.name = 'Document' AND t.type = 'U')

   4:  BEGIN

   5:      CREATE TABLE dbo.Document (

   6:          DocumentID INT IDENTITY PRIMARY KEY,

   7:          DocumentGUID UNIQUEIDENTIFIER NOT NULL ROWGUIDCOL UNIQUE DEFAULT NEWID(),

   8:          Document VARBINARY(MAX) FILESTREAM NULL

   9:      )  ON [PRIMARY];

  10:  END;

  11:  GO

In my next post, I will show .NET streaming capabilities with the new FILESTREAM features in SQL 2008.

made a few changes this time – had an excersice about doing automated builds and CI, removed rhino mocks and added a bunch of other frameworks (FakeItEasy, JustMock and others) and various other small things.

at the last day of the course, I asked each person on the most important thing they learned, and something that surprised them during the course.

here’s the list we made:

•How to practice TDD

•Isolation frameworks abilities, differences and categories

•Difference between test and production code standards

•Pay attention to requirements

•TDD is doable, also in legacy

•Simple tests

•Legacy code refactoring is hard

•Better unit tests

•It’s not hype

•Reviewing is easier than thought

•Pair programming is productive

•How to refactor and test legacy

•Power of manual fakes

•Tdd makes testable code

•Tests as specs

•How to write fast tests, productively with tdd

•RTM tests are harder than you think

•Spec and Interface based development

•Code gets written differently

•Incremental work, simply

•Lots of different ways to do the same concept

•How to handle statics

•Different people are different

•Brownfield is tough to tdd

A quick note to those giving F# talks or running events: If you would like listed here please don’t hesitate to contact me via the email link at the top of the page.  I’d love to help you help others to learn F#.

Events

Nashville Geek Lunch 11:30 AM Next Tuesday (7/27/2010)

Articles

Tomas Petricek’s The Duality of Object and Event references

In this article, I'll talk about an interesting example of duality that (to my best knowledge) wasn't described by anyone before. The two dual structures are references between objects in a normal program and references between events in a reactive application.

Marius Bancila’s Resources for the F# Presentation at Ronua Roadshow

The program that I shown exhibits traits of both functional (for computing the fractal) and object oriented (for displaying the fractal) paradigms.

Neil Carrier’s A Two-Instruction Virtual RISC

One of my favorite hobbies is building really tiny virtual computers. The experience has even paid off a time or two when I needed to create a compact domain-specific language (DSL).

Neil Carrier’s F#'s Little-Known (?) and (?<-) Operators

These two operators work similar to the C/C++ “stringizing” pre-processor operator. That is, they convert non-string code (limited to simple identifiers in the case of F#) into strings according to the following translation patterns:

Julien Ortin’s Arbitraging bookmakers with F#

The principle is rather simple.  Take the best quotes for each outcome, and process.  If the sum of 1/quote_i is less than one, an arbitrage opportunity exists.  The amount to bet on each outcome is 100/quote.

Vladimir Matveev’s Tricky late binding operators

F# Dynamic and DynamicAssignment operators are not as simple as they appear ex facte. Most popular sample of their usage is something like this:

Vladimir Matveev’s Playing with WebSharper

As a sample we’ll make simple StickyNotes application. Web design is not my primary and favorite skill, so I'll omit cross-browser compatibility and bind all styles to Firefox.

Naveen Srinivasan’s Using F# to Automate Reading–The Morning Brew

I like to try and automate most of the stuff . So I thought why not write a script that reads the Morning Brew feed, filter the excluded content that I am not interested in and open the urls before I come in.

Steve Gilham’s Building PartCover 4 on Vista

Following on from earlier in the week, I pulled the current trunk from SourceForge, and set about building it then putting it to work on some F# code which had caused an earlier version (the most recent available at the end of last year) to balk.

Gert-Jan van der Kamp’s Using a DataReader like a list in F#

This article demonstrates a technique how you can write recursive algorithms in F# using a Reader instead of a list, so you don't have to load all your data into memory first.

Steve Jenson’s Building F# on Mac OS X

Joe says his team at Microsoft runs into these issues often with users and was kind enough to walk me through the steps to get F# running on the mac.

I'm almost finished. I only have to implement the 'Notes' and 'Import from Camera' features. I can't test the Import/OCR yet because the emulator doesn't support the WebCam, bummer. I hope i can test it on a device soon.

Cheers,

Fons

Simply setting the form and any controls to be Double Buffered doesn’t do the trick because the .DoubleBuffered property works at a control level, not the form level. 

There is a fix for this that automatically enables double-buffering at the form level and on down.  This works by setting the WS_EX_COMPOSITED flag in the Form.CreateParams.ExStyle property.  Just drop the following code into form:

protected override CreateParams CreateParams

{

    get

    {

        // Activate double buffering at the form level.  All child controls will be double buffered as well.

        CreateParams cp = base.CreateParams;

        cp.ExStyle |= 0x02000000;   // WS_EX_COMPOSITED

        return cp;

    }

} 

This fix works relatively well, but WS_EX_COMPOSITED flag causes a couple of side effects:

• The Maximize, Minimize and Close buttons don’t animate on Windows XP.
• Resizing a control-heavy form feels very laggy because everything is being double-buffered.
  

The trick to fix both issues, it turns out, is the same, though very hacky.  The idea is to turn off the WS_EX_COMPOSITED flag right after the form is loaded and thus turning the form-level double-buffering off. So replace the above code with the following:

int originalExStyle = -1;

bool enableFormLevelDoubleBuffering = true;

protected override CreateParams CreateParams

{

    get

    {

        if (originalExStyle == -1)

            originalExStyle = base.CreateParams.ExStyle;

        CreateParams cp = base.CreateParams;

        if (enableFormLevelDoubleBuffering)

            cp.ExStyle |= 0x02000000;   // WS_EX_COMPOSITED

        else

            cp.ExStyle = originalExStyle;

        return cp;

    }

} 

So the pieces are in place: when enableFormLevelDoubleBuffering is set to false, we’ll have to get the System.Windows.Forms.Form object to call the CreateParams method and, in doing so, reset the ExStyle flag.  But how can we get the app to call CreateParams? 

For reasons I don’t know, simply calling the following does the trick:

this.MaximizeBox = true;

Yes, did I mention, it was hacky?  So let’s create a method that does all the work:

private void TurnOffFormLevelDoubleBuffering()

{

    enableFormLevelDoubleBuffering = false;

    this.MaximizeBox = true;

}

And we should call this method after the form has loaded in the Shown event:

private void frmMain_Shown(object sender, EventArgs e)

{

    TurnOffFormLevelDoubleBuffering();

}

And that’s how we roll.

Imagine, for a second, you have a server sided JavaScript interpreter built right into a Content Management System. It should have full access to the entire Server sided API’s, depending on security requirements of course. You could literally treat source code as content. That is what this post is about.

If you have ever created a module for DotNetNuke you probably have spent (wasted) countless hours mucking around with Visual Studio, IIS, the file system, packaging, deploying, etc. It didn’t matter if they were the most complex modules, or a simple Hello World module. In the end you probably have come to the conclusion that there just has to be an easier way of doing this.

Enter Dynamo.. (Sorry for the lame name…)

Essentially Dynamo is a DotNetNuke Module which uses Jint under the covers.

Dynamo allows you to completely skip Visual Studio, the debugger, IIS, deployment, packaging, etc... Install this single module and open your DNN installation to the world of dynamic language interpretation.

Since DotNetNuke is a content management system, Dynamo brings your source code directly into the DNN UI. It allows you to create code, on the fly, and manage that code within DNN itself.

A screenshot might help clarify…

As you might not be able to interpret from the above screen shot, this is a server sided scripting language built right into DotNetNuke. In the Scripting Window you edit your script and either Preview or Save it. Notice the fancy syntax highlighting, just no intellisense. When viewing the module it will interpret and render the script at the server side. So the above example produces:

The echo method will emit text to the output container directly. Anything return’ed out of the function will also get slapped into the output container automatically. So you can either use a StringBuilder to append up your content, or just echo content directly. Watch out for Page.Response.Write, it will emit the content at the top of the page; which is consistent with ASP.NET’s rendering.

Examples

Another real world example would be to reproduce (at a very rudimentary level) the Feedback Module which ships with DotNetNuke. Here is the code block:

   1:  echo("<div valign='top'><fieldset><legend>Provide Feedback</legend>");

   2:  echo("Your Email:<br /><input type='text' name='fromemail'><br />");

   3:  echo("Subject:<br /><input type='text' name='subject'><br />");

   4:  echo("Body:<br /><textarea name='body' rows='10' cols='50'></textarea><br />");

   5:  echo("<input type='submit' value='Send Feedback'><br />");

   6:  echo("</fieldset></div>");

   7:  if(Page.IsPostBack) {

   8:  var fromemail = get("fromemail");

   9:  var subject = get("subject");

  10:  var body= get("body");

  11:  if(fromemail!="" && subject!="" && body!="") 

  12:  return DotNetNuke.Services.Mail.Mail.SendMail(fromemail, "toemail@localhost", "", subject, body, "", "", "", "", "", "");

  13:  else

  14:  return ""

  15:  }

  16:  else {

  17:  return "";

  18:  }

So you should first notice that Dynamo does not support context switching between plain HTML and Code Blocks. Everything is a code block. If you want to emit HTML, you must do something like:

echo("<div valign='top'><fieldset><legend>Provide Feedback</legend>");

Mixing HTML and code is a nice-to-have in the ole product roadmap for the project.

Next you will notice the code itself is a slight mix with JavaScript syntax and .NET Types. The interpreter has the ability to mix each and interpret it accordingly. This also includes being able to call into the DotNetNuke API library as well. It’s important to note that we are using an interpreter and NOT using Reflection.Emit(). Thus we are just fine within Medium Trust.

What else can Dynamo do? Here is a short list of tested scenarios:

1. Consumes RSS Feeds (uses RSS.NET)
2. Full Database CRUD
3. Full Access to the DNN API, including but not limited to Portals/Tabs, Modules, Users, etc..
4. Emitting custom JavaScript and CSS (into the Head tag, or CSS inline)
5. Detecting PostBack’s
6. File I/O
7. Rendering files (into the interpreter, and getting the results)
8. Twitter Timeline
9. Page caching

Your options you have are literally limitless.

Debugging

Since DotNetNuke is Web Based it would be extremely hard difficult to get stuff like intellisense and full step by step debugging working. I don’t have the time right now, but you never know with a future version of the product.

For now, I have the ability to “Show Debugger Details”, in the Edit Script control, when you hit Preview. It literally will emit debug information at each step of the code as it interprets it. I did a simple dump of the Current Statement and the locals available.

With that said I don’t block any exceptions and do bubble them up to the UI, so if you do have issues they will very obvious.

Source Code Versioning

Most professional software developers do use some sort of Source Control software. Right now the tool does NOT have anything built in to help with this. I would love to add this at the very least to the product backlog. Eventually I would love to get to it…

Security

The source code itself contains the line of code which completely disabled all security validations. You can do some serious damage with this. If this bothers you, you should do one of two things:

1. Find the line: JintEngine.DisableSecurity(); Remove it, recompile and redeploy to your server

2. Don’t use this package version in production.

Getting started

There are two methods for you to get started; the easiest method would be to use the prepackaged module installation file here. Download it, and install it into your Development DNN Installation site. The module’s name is “Dynamo” and should be available for you to drop on a page.

The more difficult method would be to grab the source code, and compile it. This would be the method you would need to take in order to re-enable the Security (See the Security section above). This is what I use when building/testing the module itself. So if you need to make other fundamental changes you will need to do this as well.

I would recommend you reset your references to the DotNetNuke specific DLL’s out of your actual bin folder for DotNetNuke. Once you have it building, I personally just use xcopy deployment to the website’s bin and DesktopModules folder and refresh the browser. Debugging can easily be done by setting the breakpoint and attaching VS.NET to w3wp.exe.

As announced here. From the description:

This template includes:

• Work Item Types
  • Sprint
  • Product Backlog Item
  • Bug
  • Task
  • Impediment
  • Test Case
• Reports
  • Release Burndown
  • Velocity
  • Sprint Burndown
  • Build Success Over Time
  • Build Summary
  • Test Case Readiness
  • Test Plan Progress
• SharePoint Project Portal

Below are screenshots of the Sprint Burndown and Release Burndown reports included with the template.

• Download Process Template
• Online Documentation

(All images in this blog post: Copyright by Microsoft Corp.)