Visual Studio Tip: Write a Property with Just a Name and a DataType

Sometimes auto-implemented properties won't do the job, and you need a full property declaration; for instance, if you want to include a call to NotifyPropertyChanged in your property's setter or if you want a read-only property in Visual Basic. However, just because you need a full property, you don't have to type all the required code in.

In C#, just type in the definition for the property's backing field. A property called LastName might have this as its backing field:

string lastName;

To create the property from the field, just right-mouse click on the declaration and, from the Refactor menu, select Encapsulate Field. Visual Studio will pop up a dialog box that will let you name the property and set some options on it (and you may not even have to do that much -- for my example, the dialog will default the property name to LastName, with an initial uppercase letter).

In Visual Basic, just type "pro" and press the Tab key twice (once to complete the keyword "Property" and the second time to trigger inserting the Property code snippet). Visual Studio will write your property with a backing field, a setter, and a getter. Type in your backing field's name and, when you press the Tab key again, you'll be moved to the backing field's data type. After setting the data type, press the Tab key one last time to move to the Property name and enter it. Everything else is taken care of for you.

Not all code snippets are as obvious as the property snippet. If you want Visual Studio to write the skeletons of your constructors, for instance, type ct and press the Tab key twice. Visual Studio will write a default constructor in your project's language and then position your cursor inside the constructor. Since I keep switching between C# and Visual Basic, I find this snippet especially useful: I don't have to pay attention to the differences in the languages.

Posted by Peter Vogel on 06/11/2013 at 1:16 PM0 comments


A Best Practice for Authenticating Users in ASP.NET MVC 4

If your site has even one or two actions where access is restricted to particular users, the smart thing to do is to restrict access to all the actions on your site and then selectively permit access to those actions that all users are allowed to request. That way, an error of omission (forgetting to make a method available) simply prevents users from accessing some action.

Unfortunately, by default ASP.NET MVC works exactly the opposite way: all actions are accessible to all users unless you specifically restrict access by applying the Authorization action filter to the method. Under this scenario, an error of omission (forgetting to put an Authorize attribute on a method) allows all users access to the action. It's literally the worst thing that can happen in a secure environment: unauthenticated and unauthorized access to a resource that should have been secured.

Global Filters provided a solution to this by allowing you to apply the Authorize attribute to all of your action methods, locking non-authenticated users out of your actions by default. You can then selectively override that setting by applying the Authorize attribute to individual methods, specifying specific roles and users authorized to use that action. That works, unless you have some action methods that don't require authentication, methods intended to be accessible to the general public. In that scenario, you can't use Global Filters to secure all of your action methods -- until ASP.NET MVC 4.

Implementing the best practice is possible in ASP.NET MVC 4 with the new AllowAnonymous action filter. The first step is to use the Global Filters in the FilterConfig class in the App_Start folder to apply the Authorize attribute to every action method:

public class FilterConfig
{
  public static void RegisterGlobalFilters(GlobalFilterCollection filters)
  {
    filters.Add(new AuthorizeAttribute);
  }
}

The next step is to selectively allow access to actions that don't require authentication by decorating them with the AllowAnonymous attribute:

[AllowAnonymous]
Public ActionResult Get()
{

Posted by Peter Vogel on 06/05/2013 at 9:03 AM0 comments


A For ... Each Extension for LINQ

A lot of the time, when I write a LINQ statement, I follow it with a For ... Each loop that processes each item in the query:

Dim db As New NorthwindModel
Dim ords = From o In db.Orders
           Where o.OrderDate > Date.Now
           Select o

For Each Ord As Order In ords
  '…do something with each selected order
Next

It made sense to me to create an extension method that would (a) attach itself to any LINQ query, and (b) run that For ... Each loop on each item returned from the LINQ query, like this:

Dim db As New NorthwindModel
Dim ords = (From o In db.Orders
            Where o.OrderDate > Date.Now
            Select o).ForEach(Sub (o)
				'…do something with each selected order)

This extension method accepts a lambda expression with the code to execute for each item. I also want my extension method to work with any type of object that comes out of a collection (extension methods automatically deduce the datatype of any collection they're used on). The declaration for my method begins like this:

Public Module PHVExtensions
    <Extension()>
    Public Sub ForEach(Of T)…

The first parameter passed to my method has to be the datatype of the class that I want my method to attach itself to -- in this case, anything that implements the IEnumerable interface. That IEnumerable class (some collection) will be automatically passed to my extension method through this parameter. Extending my declaration to support that gives this code:

Public Module PHVExtensions
    <Extension()>
    Public Sub ForEach(Of T)(coll As IEnumerable(Of T),…

The second parameter passed to my method will be the lambda expression that accepts a single parameter (an item from the collection). Since I'm using a lambda expression that doesn't return a value, I declare that parameter as an Action with its single parameter typed using my placeholder T. Here's the full code for declaring my extension method:

Public Module PHVExtensions
    <Extension()>
    Public Sub ForEach(Of T)(coll As IEnumerable(Of T), 
                               todo As Action(Of T))

    End Sub

End Module

Within my extension method, I simply loop through the collection passed in the first parameter and call the Action passed in the second parameter. As I call the Action, I pass in each item from the collection. The code inside my extension looks like this:

For Each itm As T In coll
  todo(itm)
Next
After doing all this work, I discovered that Igor Ostrovsky had already written this method along with a whole bunch of other useful LINQ extension methods, all in C#. You should check them out. I wish I had before I spent the time writing this code.

Posted by Peter Vogel on 05/31/2013 at 9:03 AM0 comments


Free Tool: Minify Text Files on the Fly with Chirpy

The faster you download your Web application's various text files (.CSS, .js), the faster your page appears to your users. One of the best things you can do is minify those files: remove whitespaces, tabs, meaningful names, and everything else that makes code easier for human beings to read. If you've upgraded to ASP.NET 4.5, you can use its bundling features. But if you haven't upgraded, minifying your files is a pain -- unless you have Chirpy.

Chirpy is a free Visual Studio add-in that you can download  and install to Visual Studio. With Chirpy installed, your JavaScript files will be minimized whenever you save them. All you have to do is to assign your file a new extension.

For instance, giving your file the extension .gct.js will cause your file to be minimized using the Google Closure Tools. The minimized version of your file appears as a "code behind file" in Solution Explorer. Similarly, changing the file extension on your CSS files will cause them to be automatically minimized.

There's more: Chirpy will also translate DotLess CSS files into plain old CSS files (and then minify them). If you're willing to work with Chirpy's config file, Chirpy will also combine files to reduce the number of files you need to download. It's cheaper and easier than upgrading to ASP.NET 4.5.

Posted by Peter Vogel on 05/29/2013 at 1:16 PM0 comments


Configure Code Analysis in Visual Studio

I like well-written code, and I especially like it when I've written it. But I don't always live up to my own expectations. So I've used various tools (FxCop, CodeRush, ReSharper) to give me some objective feedback on the quality of my code. Starting with Visual Studio 2010, Microsoft built the latest version of their tools into Visual Studio: Visual Studio 2012 Ultimate (and up) and Visual Studio 2012 Professional (and up). From Visual Studio's Analyze menu, you can select Run Code Analysis on individual projects or on your whole solution.

The code analysis tools will report on whether your code reflects best practices, based on a set of Microsoft's rules. You should realize, however, that just because Microsoft has a specific rule, it doesn't mean that you should write your code according to that rule.

For instance, Microsoft expects all of its projects to use the CLSCompliant attribute. This attribute causes the compiler to check for issues that would prevent your code's external API from being compatible with other .NET Framework code.

For instance, it's perfectly OK in C# to have two public methods with the same name but with different upper and lower case letters (e.g. Update() and uPDATE()). However, those method names would be indistinguishable in Visual Basic, which is why they would violate the CLSCompliant attribute.

However, you probably don't need the CLSComplaint attribute because (a) you're a single language shop, and (b) you probably wouldn't do anything that violates the CLSCompliant attribute anyway (I mean, really: Update and uPDATE?)

It's important, therefore, from the Analyze menu to select the Configure Code Analysis choice and pick the right rule set for you. The Microsoft All Rules choice is almost certainly not the choice you want. Instead, select the <Choose Multiple Rule Sets> option and check off the rule sets that appeal to you. This will let you, over time, remove the rule sets that flag issues you're not interested in.

If you're really committed, consider adding and removing rules from the rulesets themselves. To do that, from the File menu select Open | File and navigate to the folder that the ruleset files are kept in (For my installation of Visual Studio 2012, that's C:\Program Files (x86)\Microsoft Visual Studio 11.0\Team Tools\Static Analysis Tools\Rule Sets\). Opening a ruleset file in Visual Studio will allow you to check off which rules in the ruleset you want to keep and which you want to ignore.

Posted by Peter Vogel on 05/28/2013 at 1:16 PM0 comments


Use Enumerated Values with Bit Flags to Handle Multiple Options

If your code uses a set of options and you don't use enumerated values, you can end up writing opaque code like this which passes an unexplained "magic number" to a method:

cust.Update(1)

With enumerated values, your code becomes easier to read because you can pass a named value:

cust.Update(UpdateOptions.Deferred)

Some applications need a set of options that can be combined in a variety of ways. In that scenario, a favorite developers' trick is to have each bit in a Byte represent one of the options. By using values that are powers of 2 and logical Ors, a developer can set individual bits in the Byte; using those same values against the Byte, along with logical Ands, a developer can check which bits in a Byte are set. Bringing in enumerated values makes working with bit flags easier to both read and write.

First, you need to override the default integer values for enumerated values to set the enumerated values to powers of 2, as in this enumeration:

<Flags>
Public Enum UpdateOptions
   Deferred = 1
   Audited = 2
   Transacted = 4
End Enum

To use these enumerated values with the Update method to specify both the Deferred and Audited options, you would Or together the enumerated values. The Visual Basic code looks like this (in C#, you would use the | operator instead of the Or):

cust.Update(UpdateOptions.Deferred Or  UpdateOptions.Audited)

Inside the Update method, to accept the Byte created by Oring together the options and to see if a particular option has been set, you use this code in Visual Basic (in C#, use the & operator instead of And):

Private Sub Update(Options As Byte)
If Options  And UpdateOptions.Deferred Then

You don't need the Flags attribute I put on my enumeration, but it does simplify debugging. The Flags attribute causes the ToString method to generate a useful result when used on a Byte that's been cast to the type of the enumeration. This example casts the Options variable to my UpdateOptions type, and then calls the result's ToString method:

Private Sub Update(Options As Byte)
Debug.WriteLine(CType(Options, UpdateOptions).ToString())

Because I used the Flags attribute on the UpdateOptions enumeration, the output is the informative "Deferred, Audited"; without the Flags attribute, the output would have been the less helpful "3".

Posted by Peter Vogel on 05/07/2013 at 1:16 PM0 comments


Free Yourself with a Dependency Injection Container

I'm now doing a column for MSDN magazine about how design patterns help developers solve typical business problems. The column is called "Patterns in Practice", but it could just as easily have been called "Thinking with Objects." As I was writing this month's Patterns in Practice column, I was thinking about how much easier my life has become since I've started using Inversion of Control (IoC)/Dependency Injection Containers. But when, as a consultant, I work with other developers, I find that these tools aren't all that common.

The issue is that, once you start thinking in terms of "What objects would make it easy to solve this problem?", you can end up with a few, very complicated objects. A better solution is to have lots of very simple objects that you can instantiate as you need them. With this approach, you end up with many variations on a single class, with each of those variations designed to do a great job of handling a specific problem.

The problem is that dealing with those objects can be a nightmare. If, for instance, you have three different Customer classes (each designed to handle one kind of customer), you can end up with three different variable declarations:

Dim  custp As PremiumCustomer
Dim  custOrd As OrdinaryCustomer
Dim  custDb As Deadbeat

Using inheritance or interfaces lets you make all the variations on a class look alike. The practical result is that you can declare one variable to work with all the varieties of the class. If all the Customer classes inherit from one class or implement the same interface, you can declare a single variable to work with any Customer object. Here's the only variable declaration you need if all Customer classes implement the same interface, ICustomer:

Dim  cust As ICustomer

The problem is the New statements; those statements have to reference a specific class:

cust  = New PremiumCustomer
cust  = New OrdinaryCustomer
cust  = New PremiumCustomer

What a Dependency Injection Container does is eliminate those New statements. Instead, you load the container with the objects your application needs. When you want a class, you just turn to the container and ask for it. You can even specify criteria to choose which object you want. Code like this works with Microsoft's Unity container, for instance, to find an object that implements the ICustomer interface and is associated with the string "Premium":

cust  = DependencyContainer.Resolve<ICustomer>("Premium")

Really, these tools solve a ton of problems and can completely change the way you think about objects when solving problems.

Posted by Peter Vogel on 04/30/2013 at 1:16 PM0 comments


Don't Create Pages in SharePoint; Use User Controls

Because the Master Page for your SharePoint site is kept in the hive (and because Visual Studio isn't smart enough to follow the MasterPageFile attribute that points to the Master Page in the hive) when creating a page in Visual Studio, you can't switch to Design View. For those of you with a great grasp of HTML that may not be a problem. Because of my shaky grasp of HTML and CSS, when I work in Source View I'm frequently surprised at what shows up in the browser when I view my page.

There are workarounds for this problem (copying your site's Master Page into your project and setting/resetting your page's MasterPageFile to point to the local copy, for instance). Lately, however, I've been using a hint from my friend Patrick Haggerty (who wrote Learning Tree's SharePoint Development course). When I create a page, I don't add controls directly to the page. Instead, I create a User Control and add my controls to it. I then add my User Control to the appropriate Content control on the page I'm creating. When I'm creating a User Control, I always have both Design View (which I like) and Source View (when I need it). Until Visual Studio gets smarter (and Visual Studio 2012 hasn't), this is the best solution I've got.

Posted by Peter Vogel on 04/22/2013 at 1:16 PM0 comments


Free Tool: Try Out SQL Queries and Explore Databases with QueryExpress

As an independent consultant, I move from one client's computer to another. Because of that, I frequently find myself on computers where I need to browse a database but don't have a copy of SQL Server Management Studio installed. If you want a quick replacement for Management Studio, try QueryExpress. It's so small and downloads so quickly that you'll think it hasn't download at all. QueryExpress also requires no installation: just drop it on your desktop and double-click its icon to run it.

QueryExpress isn't a complete replacement for Management Studio by any means, but it gives me everything I need: a text window for entering SQL statements, a TreeView of all of the databases on the server (with their tables, stored procedures, and functions) and a GridView of any query results.

There's some stuff missing that I wish was there: QueryExpress won't scan for databases for you to connect to, so I have to know what my server and database engine names are; and the undo in the text window only goes back one step. But, to compensate for that, QueryExpress works with SQL Server, Oracle or any OLE DB compatible database.

If you want something more powerful that's still free, you can take a little longer and install Query ExPlus, which builds on Query Express.

Posted by Peter Vogel on 04/15/2013 at 1:16 PM0 comments


Customize Visual Studio Menus

There are probably lots of items on the Visual Studio menus and toolbars that you never use: Why not get rid of them? The odds are also good that there are items on the Visual Studio menus that you use frequently but are buried on some submenu. For instance, I want to know why the Views menu is cluttered up with windows I never use like Team Explorer (most of my clients don't use Team Foundation Server) and Properties (I always use F4). And why is the Immediate Window (which I use all the time) buried on the Other Windows menu off the Debug menu?

Why not set up Visual Studio to work the way you do? Removing the items you don't want is ridiculously easy: From the Tools menu, select Customize and, in the Customize dialog, click on the Commands tab. In the dropdown list at the top of the dialog, select the Menu bar you want to customize (e.g. View or View | Other Windows). Then find the menu items you never use and delete them. Finding the menu you want to delete isn't always obvious, though; the Team Explorer menu choice appears on the list as TfsTeamExplorer.

Adding the items you do want is only slightly more complicated. Still in the Customize dialog, after selecting the menu you want to add to, click on the Add Command button. This will display a list of available commands (on the right) organized by the menu (on the left) that the commands normally appear on. So, to add the Immediate View menu item to the View menu (where it belongs), first select the Debug menu in the left column. Then, when the list of commands on the right refreshes, select the Immediate menu item and click OK.

And: Don't Worry! If you delete something that you wish you'd kept, you can always add it back. Or, if things go horribly wrong, just click the Reset button on the Customize dialog to get back to the original menus.

There's an added benefit here: Job Security. If no one can figure out how your copy of Visual Studio works, it makes you that little bit harder to replace.

Posted by Peter Vogel on 04/05/2013 at 1:16 PM0 comments


Measure Performance with the Stopwatch Class

I like it when my code runs faster, but I don't want to work at it (if my application is running too slow, my time is usually better spent enhancing my data access rather than tweaking code). But if I do rewrite any code to make it run faster, I want to know that I made a difference. This has led me, after all these years, to the System.Diagnostics.Stopwatch class.

To use the Stopwatch class, just call its StartNew method, run your test, then call its Stop method. You can extract the elapsed time from the Stopwatch's ElapsedMilliseconds property then display it or write it to a log file. This example puts the result in a TextBox:

Dim  sw As System.Diagnostics.Stopwatch 
sw  = System.Diagnostics.Stopwatch.StartNew()
…something  to test…
sw.Stop()
Me.TextBox1.Text  = String.Format("Elapsed time: {0} ms", timer.ElapsedMilliseconds)
There are methods on the StopWatch class to reset the timer (so you can do another test) or restart the timer (so you can continue the current test). You can also get the elapsed time in Ticks or, for long running tests, as a TimeSpan object with hours, minutes, and (horrors!) days.

Posted by Peter Vogel on 03/21/2013 at 1:16 PM0 comments


Free Visual Studio Tool: Brace Completer

When I work in Visual Basic and add an If statement, Visual Studio writes the End If statement; If I add a Class declaration, Visual Studio adds the End Class statement. Why, then, when I work in C# and I type an open brace, doesn't Visual Studio write the closing brace?

In fact, C# will stubbornly mark my line as an error until I do add the closing brace (often hiding some real error). When you do finally type the closing brace in C#, Visual Studio formats the code -- that's got to be harder than adding the brace. That's why, whenever I type an opening brace, I immediately type the closing brace to reduce my chances of having a mismatched brace. Having Visual Studio add the brace would fit right in with my standard practice.

The Brace Completer extension does what I want: when I type an opening brace and hit the Enter key, Brace Completer adds the closing brace, lets Visual Studio format my code according to my settings, and then puts my cursor on the line following the opening brace.

If you're not happy with the default behavior, you can configure the utility from the Tools/Options/Environment/Brace Completer menu choice. Brace Completer does the right thing for C#, C/C++, CSS, and JavaScript; and if you're feeling brave, it's willing to support any other language known to Visual Studio that you might select in the Options dialog. You can also configure Brace Completer to insert the closing brace as soon as you type the opening brace, if you're one of those people who occasionally want to keep everything on one line (and, when you do finally hit the Enter key, you'll get the default formatting expected).

It doesn't seem like a big deal, but I like it very much. I know that it's only saving me one keystroke, but that's one keystroke every time I use a brace. I don't know what that is over a day, month or year, but I bet it's a ton of keystrokes. And, sure, there may come a time when I'll wish that Brace Completer hadn't added the closing brace -- but it hasn't happened yet.

You can find Brace Completer in the online section of Visual Studio's Tools/Extensions and Addins.

Posted by Peter Vogel on 03/18/2013 at 1:16 PM3 comments


Upcoming Events

.NET Insight

Sign up for our newsletter.

I agree to this site's Privacy Policy.