Tips & Tricks

How to Setup a Windows 2008 R2 SNTP/NTP Server

Brian Chavez — Mon, 21 Dec 2009 08:06:52 GMT

Gee, setting up an SNTP/NTP server in Windows is not intuitive.

The good news is: When configured correctly, you can use the Windows Time (W32Time) service as an SNTP/NTP server for both windows and non-windows SNTP/NTP clients.

Here's how to do it:

Click Start, click Run, type regedit, and then click OK.
Locate and then click the following registry entry:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time\Config\
In the right pane, right-click AnnounceFlags, and then click Modify.
In the Edit DWORD Value dialog box, under Value data, type 5, and then click OK.
Enable NTPServer.
1. Locate and then click the following registry subkey:
  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\
  Services\W32Time\TimeProviders\NtpServer\
2. In the right pane, right-click Enabled, and then click Modify.
3. In the Edit DWORD Value dialog box, type 1 under Value data, and then click OK.
Exit Registry Editor.
At the command prompt, type the following command to restart the Windows Time service, and then press ENTER:
net stop w32time && net start w32time

This should get you setup with minimal registry hack impact.

Tips

Make sure W32Time is set to Automatic startup mode.
Make sure UDP 123 is allowed through your firewall.
Use this InternetTime program to help you debug connectivity to your SNTP/NTP server.

internettime.zip

Hope that helps,
Brian Chavez

Upgrading SubText, IIS7, Windows 2008

Brian Chavez — Wed, 14 Jan 2009 02:42:41 GMT

Bit Armory, Inc. has decided to finally make the move to IIS7 for production. Let's hope it goes well.

First Impressions:

Performance seems a little better
Better ASP.NET MVC support
Easier Setup

I did have a problem with Subtext and IIS 7 yelping back an error:

"System.Web.HttpException: Request is not available in this context"

Thanks to Lance Fisher, the fix was easy, simply set "Classic .NET AppPool" in Manage Web Site > Advanced Settings ... should do the trick.

Hope that helps!

Brian Chavez

Enterprise Library Validation MessageTemplate Tokens

Brian Chavez — Thu, 28 Aug 2008 23:48:13 GMT

I always forget... pulled from MSDN with my notes added in italics:

Understanding Message Template Tokens

Custom message templates can contain tokens. The validator replaces these tokens with values before it adds the resulting message to an instance of the ValidationResult class. Tokens are represented by using the strings {0}, {1}, {2}, and so on within the message template strings. All validators provided by the Validation Application Block use the first three tokens {0}, {1}, and {2} for the same purposes. Different validators may also understand additional tokens, beginning with {3}. The following table describes tokens {0}, {1}, and {2}.

Token	Description
{0}	This token represents the value of the object that is being validated. Although it can be useful to show the original value as a part of the validation message, you must be careful to avoid injection attacks by escaping any characters that can be used to attack the system that conveys the message to the user. In simple terms: returns "ObjectBeingValidatedFullTypeName+Field"
{1}	This token represents the key of the object that is being validated. When the validator is attached to a member of a type such as a property or a field, the key is set to the member name. When the validator is attached to an object, the key is null and the token is replaced by an empty string. In simple terms: returns "Field" name being validated
{2}	This token represents the tag that is specified on the validator instance. If no tag is supplied, the token is replaced by an empty string. In simple terms: returns contents of [Validator Tag="foo"] property defined in the attribute.

Token

Description

{0}

This token represents the value of the object that is being validated. Although it can be useful to show the original value as a part of the validation message, you must be careful to avoid injection attacks by escaping any characters that can be used to attack the system that conveys the message to the user.

In simple terms: returns "ObjectBeingValidatedFullTypeName+Field"

{1}

This token represents the key of the object that is being validated. When the validator is attached to a member of a type such as a property or a field, the key is set to the member name. When the validator is attached to an object, the key is null and the token is replaced by an empty string.

In simple terms: returns "Field" name being validated

{2}

This token represents the tag that is specified on the validator instance. If no tag is supplied, the token is replaced by an empty string.

In simple terms: returns contents of [Validator Tag="foo"] property defined in the attribute.

Fluent C Sharp Language Extension Helpers - Part 1

Brian Chavez — Thu, 28 Aug 2008 23:08:47 GMT

So, I found myself doing a lot of for( int i = 0; i < n; i++ ){} stuff lately. So, I've decided to try something new. I've started a small collection of "Fluent Helpers" that alleviate a lot of the verbosity in C#.

About 28 characters (including spaces) for a simple for loop to do some constant iteration.

for( int i = 0; i < n, i++){

About 18 characters to do this (no pun intended):

Do.This( 5, () =>{

Here's an example:

   51             Do.This( 5,
   52                     () =>
   53                         {
   54                             Console.Write( "Hello " );
   55                             Console.WriteLine( "World!" );
   56                         }
   57                 );

Prints:

Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

Now that feels much better on my hands, and looks much cleaner too, IMHO. Here's the simple implementation for Do.This:

   42     public static class Do
   43     {
   44         public static void This(int times, Action what)
   45         {
   46             for( int i = 0; i < times; i++ )
   47             {
   48                 what();
   49             }
   50         }
   51     }

I've already started a little library of these small syntax helpers I've collected. If you have any suggestions, please share!

-Brian Chavez

Understanding ScriptResource and WebResource in ASP.NET

Brian Chavez — Mon, 28 Jul 2008 11:11:56 GMT

Here are some common questions about ASP.NET and web resources:

What is a web resource?
How do I get my embedded scripts to be delivered by ScriptResource.axd handler?
How do I get my embedded scripts to be delivered by WebResource.axd handler?
What is the difference between ScriptResource.axd and WebResource.axd?

First, let's tackle the first question. What is a web resource and why would you use such a thing?

Web Resources

A web resource is a file embedded in an assembly. This file can either be a JavaScript file or a BMP, or any other emendable type of resource in an assembly. Just take a look at System.Web and all the embedded resources that are defined:

You'll notice there are both, Images and Scripts. There's even some html! So, web resources (at an assembly level) can be composed of just about anything you want.

How do you define Web Resources?

Meet the [WebResource] attribute. You define web resources by using the WebResource attribute. The WebResourceAttribute acts as an access marker to allow resource handlers to find your resources. The first parameter to WebResource is the name of the web resource, the second parameter is the ContentType.

[WebResource(
webResourceName
    Type: System.String
    The name of the of Web resource.
,
contentType
    Type: System.String
    The type of resource, such as "image/gif" or "text/javascript".
)]

Once you have your [WebResource] defined in your assembly, the next step is to mark the file you want embedded as an "Embedded Resource" in Visual Studio.

Working with Assembly Resources

There are two basic ways to getting at your assembly resources loaded on your ASP.NET web page. ScriptResource.axd and WebResource.axd.

Using WebResource.axd

Generally, you'll want to use WebResource.axd when you are dealing with binary resources. Things like emendable images or other types of media. You can use WebResource for serving out JavaScript files but there is a better alternative. However, if you're stuck in ASP.NET 2.0 land with out Microsoft AJAX, then WebResource.axd is your only option to serve out your embedded assembly resources. To make your assembly resources available on your ASP.NET page, simply use:

  104  //Uses WebResource.axd
  105  this.Page.ClientScript.RegisterClientScriptResource( 
  106     typeof(SwfObject), "ProjectBase.Web.Scripts.swfobject.js" );
  107 
  108  string urlToFunnyWebResourceUrl =
  109     this.Page.ClientScript.GetWebResourceUrl(
  110     typeof(SwfObject), "ProjectBase.Web.Images.Header.gif" );

urlToFunnyWebResourceUrl is the the actual absolute path to your webresource. So you could potentially use it to link to an image or script. ClientScript.Register* are generally reserved for loading JavaScript. It's pretty straight forward, pass in the typeof(Control) that's requesting the resource, and the full name to the assembly resource. The result of these calls will generate URLs to WebResource.axd.

Using ScriptResource.axd

As I mentioned earlier, there is a better alternative for loading your JavaScript assets if you're working with ASP.NET AJAX. Using ScriptResource.axd handler actually has some interesting features. Some features include:

Automatically GZip/Compressing your scripts over HTTP for delivery.
Dynamically resolving Release/Debug scripts based on build parameters. This is useful, if you keep two types of the same script: one for debug, and one packed for release.
Can be used for Non-MsAJAX Framework script assets such as jQuery.

The ScriptManager object is how we can get our embedded JavaScript into our page using ScriptResource.axd:

  112  //Uses ScriptManager.axd
  113  ScriptManager.RegisterClientScriptResource(
  114     this, typeof(SwfObject), "ProjectBase.Web.Scripts.swfobject.js" );

The calling semantics are pretty much the same as the previous calls to WebResource.axd, the only difference is that we are passing in this instance of the control that wants to register the script. The effect of calling this method results in scripts being loaded from ScriptResource.axd.

That's it! Happy coding! I'll probably add some more tips on this post if I come across any.

Brian Chavez

The ParseChildren PersistChildren and PersistenceMode.InnerProperty

Brian Chavez — Mon, 28 Jul 2008 06:49:49 GMT

After a while of non-web control development, ParseChildren and PersistChildren attributes are important attributes to remember when trying to get the desired results your looking for in the Visual Studio designer.

So, this post should clear up (and serve as a reminder for me) how and why these attributes are important. Let's explore what these two attributes are used for. Let's start with ParseChildren.

The [ParseChildrenAttribute]

The ParseChildren Attribute is probably, the most important attribute you should pay attention to when developing web controls. It's actually used by the ASP.NET Parser and ControlBuilder object to figure out how to parse the ASP.NET code you write. Visual Studio also uses this attribute to figure out what valid sub-controls and components are allowed within the contents of a server control.

Let's say, I want to create an AggregateFeeds control that displays an aggregate list of RSS feeds.

A Basic and Boring Control Syntax

You'll notice that the RssResource is the only available option that is allowed as a child from the AggregateFeeds control. Here's the code behind the AggregateFeeds control:

  113     [
  114     ParseChildren(
  115         typeof(RssResource),
  116         DefaultProperty = "Feeds",
  117         ChildrenAsProperties = true
  118         )
  119     ]
  120     public class AggregateFeeds : Control
  121     {
  122         public AggregateFeeds()
  123         {
  124             this.Feeds = new RssFeedCollection();
  125         }
  126         public RssFeedCollection Feeds
  127         {
  128             get;
  129             private set;
  130         }
  131         protected override void Render(HtmlTextWriter writer)
  132         {
  133             this.Feeds
  134                 .ForEach( rssRes => writer.Write( rssRes.Url ) );
  135         }
  136     }
  137 
  138     public class RssFeedCollection : List<RssResource>
  139     {
  140 
  141     }
  142 
  143     public class RssResource
  144     {
  145         public string Url { get; set; }
  146     }

The ParseChildren attribute on AggregateFeeds tells the ASP.NET, that any children within the AggregateFeeds control should be typeof(RssResource). ChildrenAsProperties=true let's ASP.NET know that it should STOP parsing server controls with "runat=server", and switch to instantiating objects into the properties of the ArggregateFeeds control. DefaultProperty says, that the results of the parsed objects should go into the default property Feeds.

Syntax Goodness With InnerProperty

The previous example was great, it's simple and get's the job done. But let's say, the requirements have changed, our control is growing, and we need to allow more customization, and extensibility for the consumers of our AggregateFeeds control.

Let's clean up the markup and allow our developers to create markup like this:

To get this type of syntactical behavior, check out the code below:

  113     [
  114     ParseChildren(
  115         ChildrenAsProperties = true
  116         )
  117     ]
  118     public class AggregateFeeds : Control
  119     {
  120         public AggregateFeeds()
  121         {
  122             this.Feeds = new RssFeedCollection();
  123         }
  124 
  125         [PersistenceMode(PersistenceMode.InnerProperty)]
  126         public RssFeedCollection Feeds
  127         {
  128             get;
  129             private set;
  130         }
  131         [PersistenceMode(PersistenceMode.InnerProperty)]
  132         public AggregateSettings Settings
  133         {
  134             get;
  135             private set;
  136         }
  137         protected override void Render(HtmlTextWriter writer)
  138         {
  139             this.Feeds
  140                 .ForEach( rssRes => writer.Write( rssRes.Url ) );
  141         }
  142 
  143     }
  144 
  145     public class AggregateSettings
  146     {
  147         public int TimeOut { get; set; }
  148         public bool CacheResults { get; set; }
  149     }
  150 
  151     public class RssFeedCollection : List<RssResource>
  152     {
  153 
  154     }
  155 
  156     public class RssResource
  157     {
  158         public string Url { get; set; }
  159     }

Notice, we've removed DefaultProperty and typeof(RssResource) from ParseChildren attribute. We're no longer working with a simple control that has simple children objects that need to be parsed, we're now working with a complex control with more than one property that we're setting in the markup, so we've removed the "default" stuff. The syntactical magic happens with PersitanceMode attribute on the properties. PersistanceMode.InnerProperty allows us to specify our cool <Feeds> and <Settings> tags. How does Visual Studio know what members are available? It does so by Reflection.

Get fancy, more than one child type

Also, I want to point out, suppose, we want to support multiple types of Feed objects. We could use an enum in RssResource, or we could use inheritance to achieve the following:

All we would have to do is simply mark RssResource as an abstract class. Then, subclass for each type.

  156     public abstract class RssResource
  157     {
  158         public string Url { get; set; }
  159     }
  160     public class MediaRss : RssResource
  161     {
  162 
  163     }
  164     public class ITunesRss : RssResource
  165     {
  166 
  167     }

Again, I'm just showing that it's possible, but following my mantra of "less code, less maintenance," I'd use an enum to describe the type of rss feed on RssResource.

Where is [PersistChildren]?

Nowhere! Is PersistChildren attribute needed? No, it's not a required attribute to create your custom control. The PersistChildrenAttribute only provides designer support for your control with Visual Studio and has no "processing" affect in ASP.NET, but remember ParseChildren does.

I'm a source-view only guy. I really don't remember the last time I've used the Visual Studio "Design View", it's a waste, crashes all the time, so I've pretty much given up on it. Besides, "Design View" is for n00bs anyway. Just kidding! If you plan on using the Design View, then you'll probably need your PersistChildren attribute...

In general, PersistChildren and ParseChildren are exclusive complementary attributes to describe the same semantic operation. The rule of thumb goes:

If ParseChildren(true), then PersistChildren(false).

If ParseChildren(false), then PersistChildren(true).

Following the PersistChildren guideline above should keep your code out of trouble. But again, I wouldn't use PersistChildren only until you actually need it. Less code, less maintenance.

Here's a nice list of attributes you should consider when writing your custom controls:

http://wdevs.blogspot.com/2007/10/attributes-to-consider-applying-when.html

Hope that helps! Happy coding!

Brian Chavez

NAnt Addin for Visual Studio (VS) 2008

Brian Chavez — Mon, 14 Jul 2008 00:39:12 GMT

I've finally committed and upgraded VS 2008. Fortunately, everything has gone pretty smooth. Third party tooling support for VS 2008 is now reasonable, ReSharper, Code Rush, all now are supporting 2008. But one of my favorite helper tools is NAntAddin developed by Netlogics Software. It's quick and easy to execute specific NAnt tasks in the window. Unfortunately, it doesn't support 2008 out of the box.

However, after playing around with the AddIn file, I was able to get NAntAddin working with VS 2008.

Here's how to do it:

Download the latest version.
Unzip and copy the addin files and folder to:

On Vista:
\Users\%UserName%\Visual Studio 2008\Addins

On XP:
\My Documents\Visual Studio 2008\Addins

Note: If you don't see an "Addins" folder in, then create one under "Visual Studio 2008".
Next, open the NAntAddin.Addin file with your favorite text editor, and edit the <version> value to 9.0 as shown below:

Now start Visual Studio 2008, and you should have NAntAddin up and running!

Your final directory structure should look like the following:

Happy coding!

Brian Chavez

BadImageFormatException Errors

Brian Chavez — Wed, 30 Apr 2008 00:22:22 GMT

I've been playing with Lua Programming/Script Language and LuaInterface, because I have a need for embedding a scripting language in one of our projects. Unfortunately, when trying to run one of the test case applications that came with LuaInterface, I was presented with a nice error shown below:

Anytime, you run a .NET application, the operating system reads the PE header information of the executable to help setup the process environment. In my case, TestLua.exe was being setup and ran in x64 mode with an x64 runtime and failed to P/Invoke Lua's native 32-bit DLL.

Solution

In general, there are two main ways we can explicitly tell the operating system to load and use 32-bit process environments:

For applications and assemblies that you can not recompile:

Set the 32-Bit flag in the PE header.

For example, since the 32-bit flag in TestLua.exe was not set, I forced 32-bit mode by setting the 32-bit flag using CorFlags.exe:

Start "Visual Studio SDK Command Prompt" and execute:
CorFlags.exe /32bit+ TestLua.exe

For applications and assemblies that you can recompile:

Recompile using the "Target Platform" settings as illustrated here.

In practice, if you do low-level COM, P/Invoke, Win32 stuff, you'll probably need to set these 32-bit flags for your applications; however, if your application purely lives in the managed world, you won't need to do anything!

Vista Explorer Annoyances and Enhancements

Brian Chavez — Wed, 13 Feb 2008 20:08:40 GMT

You might think this is a post about add-ons to Vista's Windows Explorer, but actually, it's a post about how to remove features in Vista's Explorer to make it actually usable and tolerable to work with.

Enhancement #1

Vista Explorer has the most annoying ability to "sniff folders" and try and guess what the file types are in your folder. If .png, .jpg, or other image related file types exist in your folder, Explorer will switch to a "thumbnail/Large Icon" view, even though you've explicitly set a view to "apply to all" folders. Here's how to get rid of the annoying behavior.

http://www.vistax64.com/tutorials/70819-windows-explorer-folder-view-settings.html

Enhancement #2

Vista Explorer forgets size & location. Make Vista Explorer remember the size of the explorer window.

http://jtbworld.blogspot.com/2007/04/remember-vista-windows-explorer-window.html

Enhancement #3

Segoe UI is the most annoying font in the world. Change it here:

http://steve.fsxtreme.com/blogs/2008/01/16/say-no-to-segoe-and-cleartype-on-vista/

Seriously, the Windows Shell Team did a terrible job with Vista and they all need a few basic lessons on usability...

The Bit Armory Visual Studio Theme

Brian Chavez — Sat, 02 Feb 2008 04:01:52 GMT

I recently upgraded to Vista 64-bit, and got hooked on the eye candy. So, I decided to pimp out my IDE with my company's color theme. :) Still working on some of the colors, but looks pretty good huh? Any suggestions? I'm thinking I should tone down the save/modify color tracks near the line numbers so it fits in more....