Ensure HTML Forms Are Closed with the Using Block and BeginForm

In your Views, you can get the BeginForm helper to not only write out the open tag for your HTML form, but to write out your form's end tag. The trick is to call BeginForm as part of a Using block. The code looks like this, in Visual Basic:

@Using Html.BeginForm(...parms...)
  @Html.EditorFor(...
  ...rest of form...
End Using

This C# code does the same thing:

@using (Html.BeginForm(...parms...))
{
  @Html.EditorFor(...
  ...rest of form...
}

At the end of the Using block, the compiler will automatically call the Dispose method of the class the BeginForm uses. That Dispose method will politely add the end form tag to your page, so you'll end up with something like this:

<form action="...rest of the attributes...>
  <input type="text"...
  ...rest of form...
</form>

As you can see, the Using block also creates a structure in your View that you can slip all of your form elements inside.

Posted by Peter Vogel on 01/28/2016 at 10:56 AM0 comments


Hiding Methods from IntelliSense

Believe it or not, there are times when you have a member in your class that you don't want to appear in the class's IntelliSense lists.

In a column earlier this month I talked about how to have your class work with the .NET Framework support for formatting strings (things like "{0:G}," for example). By the time I had finished implementing this feature, my sample class had a method that no developer would ever call -- the method would only be called by .NET Framework components.

Because my method will never be called by a developer, it doesn't make a lot of sense to have that method cluttering up the class's IntelliSense list. To stop that method from appearing in the class's IntelliSense list, I could decorate the method with the EditorBrowsable attribute, passing the enumerated value EditorBrowsableState.Never. Here's the method from that column with the attribute applied to it:

<EditorBrowsable(EditorBrowsableState.Never)>
Public Function ToString1(format As String, formatProvider As IFormatProvider) As...

The trouble is, other than suppressing this ToString method, I literally cannot think of any other case when I'd want to use this attribute (after all, if I wanted a developer to stop using the method, I'd decorate it with the Obsolete attribute).

I suppose you could use the two attributes together: one to hide the method so a developer won't know about it while keeping the method in the class so old code would run; the other attribute to generate compile time warnings about how existing code should stop using the method. But that sure seems like a lot of work to invest in something you don't want people to use.

Posted by Peter Vogel on 01/21/2016 at 10:34 AM0 comments


Combining LINQ Queries (or, When to Call ToList)

LINQ with Entity Framework has become so common that, when I'm looking at a client's code I'm finding some pretty scary-looking LINQ queries running against Entity Framework. Since I'm a big fan of Really Obvious Code (ROC) -- ROC Rocks! -- I hate having to parse out these queries to try and figure out what the query is doing (and what's wrong with it).

You might be tempted to write a comment to explain the query (but I don't like that, either).

The right answer is to break down your complicated query into several smaller, easily readable queries that build on each other. While this isn't a particularly complicated example, these two queries find all of the people whose last name is "Vogel" and work for PH&VIS:

Dim persVogel = From p In db.People
                Where p.LastName = "Vogel"
                Select p

Dim persVogelPHVIS = From pp In persVogel
                     Where pp.Company.Name = "PHVIS"
                     Select pp 

While this looks inefficient, it's not. It's important to remember that a LINQ query doesn't result in any data retrieval: At this point in my sample code, my persVogel and persVogelPHVIS variables are just holding LINQ queries; the variables aren't holding the results of those LINQ queries (at least, not holding the results yet).

It isn't until you start working with the individual objects that Entity Framework will finally issue a SQL statement against your database. When that SQL query is finally issued, Entity Framework will take care of collapsing those two LINQ queries into one SQL statement for you.

One way to trigger that retrieval is to use the ToList method. If my LINQ queries were in a method, then I might finish the method with code like this:

Return persVogelPHVIS.ToList()

At this point, when the ToList method executes, Entity Framework will finally retrieve the data and create a collection of objects from that data.

Besides, those collections of objects are more generally useful than the LINQ queries. I've had numerous clients call me up to ask why they're getting messages like "Unable to cast object of type..." when passing a LINQ query to some function. The usual solution is to add a call to ToList to force Entity Framework to retrieve the data.

Posted by Peter Vogel on 01/19/2016 at 10:51 AM0 comments


Seeing a File Twice in Visual Studio

You want to compare/view two parts of the same file at the same time. You have two choices for making this happen.

First, you can click on the divider bar at the top of the scroll bar on the right side of your editor window. Dragging that bar down divides your code window into two panes (one on top of the other), which you can scroll through independently.

However, each of these panes is now smaller than the original window. If you want to see your code in a full-size window then go to the Window menu and select New Window. You'll get a second window with the same name but with ":1" tacked on the end (for example, "Customer.cs" and "Customer.cs:1"). If you want, you can drag one of the tabs to another monitor (something you can't do with the divider bar).

Either way, changes you make in one window/pane automatically appear in the other window/pane.

If you're using Visual Studio 2010, this feature is turned off for some languages (the team ran out of time to completely test it). You'll need to make a change to your Windows Registry to turn it on.

Posted by Peter Vogel on 01/14/2016 at 12:16 PM0 comments


Configuring Entity Framework for Oracle

Oracle needs two NuGet packages in order to work with Entity Framework: one to use at design time and one to use at run time. You'll need to make sure both of these are installed (and it doesn't help that their names are so similar):

  • ODP.NET, Managed Entity Framework Driver
  • ODP.NET, Managed Driver

You'll also need to install Oracle's ODP.NET_Managed_ODAC package.

As much as I'd like to pretend that I'm all-knowing but this information comes from Yonayli Gutierrez (Hi, Yonayli!) who took one of Learning Tree's ASP.NET MVC classes.

Posted by Peter Vogel on 01/05/2016 at 11:00 AM0 comments


Create Factory Functions in TypeScript for Creating Multiple Classes

In TypeScript, you can define a function that, when passed a set of parameters, creates and returns a correctly configured object. One of the parameters passed to the function must be the class of the object being created (I'll call that the "class parameter"). Normally, that means your factory function can only create a single kind of class but, by leveraging generics and interfaces, you can create functions that will create and configure a variety of classes.

Your first step is to define an interface that specifies the properties that your factory function will configure. Here's an example of an interface that specifies two properties:

interface ICustomer
{
  name: string;
  age: number;
}

With that interface in place you can create a generic factory function that works with any class that implements that interface. First, when defining your factory function, follow the factory function's name with a data type marker and specify that the marker extends the interface. Second, in the factory function's parameter list, use TypeScript's new keyword along with the generic data type marker when defining the function's class parameter (you're actually specifying the type of the class' constructor).

The following code shows the declaration of a generic factory function that leverages my ICustomer interface. I first provide a type marker (c) that, using the extend keyword, ties the function to classes that implement the ICustomer interface. I then use that type marker with the new keyword to specify the return type of the function's class parameter (called cust in my example):

function CreateCustomer<c extends ICustomer>(cust:{new(): c;}, 
                                             name: string, age: number): c
{

Now, inside my function, I use the class parameter to instantiate the class passed in the class parameter. Once I've done that, I can configure the object by setting the properties specified in the interface:

    var newCust: c;
    newCust = new cust();
    newCust.name = name;
    newCust.age = age;
    return newCust;
}

To use this factory, I pass the class I want created (which must implement the ICustomer interface) along with the rest of the parameters required by my factory function. This example:

var cust: Customer;
cust = CreateCustomer(Customer, "Peter", 62);

uses my function to create an instance of a class called Customer.

Posted by Peter Vogel on 12/28/2015 at 11:35 AM0 comments


Warn Developers about Using Your Old Code

At least two or three times in my life, I've come back to old systems I'd worked on and realized that I now knew a better way of doing things. However, rather than just revise existing code, that "better way of doing things" required me to write a new method, property or class. When I released my new code out into the world, I wanted to tell other developers to stop using my old code and move to my new code. The best way to do that, I've decided, is to go back to the old code and decorate it with the Obsolete attribute.

You can add the Obsolete attribute either to a class or to members of a class. Regardless, when a developer attempts to use the item you've decorated, they'll get a warning message in their code that says the class (or the member) you've decorated with the attribute is deprecated.

Of course, developers aren't likely to stop using your class or method unless you tell them about your alternative. You can do that by passing a message to the Obsolete attribute -- that message is then tacked onto the end of the attribute's default warning message. This example will generate the message "'SampleClass' is obsolete: Use PHVIS.NewClass" when someone tries to use SampleClass:

<Obsolete("Use PHVIS.NewClass")>
Public Class SampleClass
  Public Sub SampleMethod()

  End Sub
End Class

By default, the Obsolete attribute just generates a warning message so it won't stop the developer's code from compiling. If you want to be more aggressive, you can pass True as the attribute's second parameter to generate a compile-time error and prevent the developer's code from compiling, as this example does:

Public Class SampleClass
  <Obsolete("Use BetterMethod", True)>
  Public Sub SampleMethod()

  End Sub
End Class

I'd wait awhile before doing that, though.

Posted by Peter Vogel on 12/17/2015 at 10:57 AM0 comments


Wrapping Lines in Visual Studio

I was teaching Learning Tree's ASP.NET MVC course a few weeks back. The author of that course decided that having code lines extend past the right-hand edge of the code window wasn't a good idea if you're an instructor demoing some code. To eliminate those disappearing lines on the demo computer we use in the course, he turned on word-wrap for Visual Studio. This choice keeps all of the code on the screen by wrapping long lines of code back to the left hand margin.

If you like that idea, it's easy to turn on that option. Go to Tools | Options | Text Editor | All Languages and select the "Word wrap" choice on the right. That's all you need to do but, if you want, you can also have Visual Studio put a U-turn arrow at the end of each line that's too long to fit in the window -- just click the "Show Visual Glyphs for word wrap" option under the Word wrap choice.

Posted by Peter Vogel on 12/15/2015 at 11:04 AM0 comments


Create .zip Files from Code

If you've ever wanted to create a .zip file from your application, the System.IO.Compression.GZipStream will let you do it, assuming that you're comfortable with your file being in the industry-standard .gzip format (though I'm told you can swap in other compression schemes).

For this tip, I'm assuming that the file is small enough that you can read it all in one gulp. In that scenario, my first move is to define a FileStream object for the file I want to compress, read the file into memory, and close the FileStream:

Dim unCompressedFile As FileStream
unCompressedFile = File.OpenRead("C:\GreatBigFile.txt")
Dim bytes(5000) As Byte
Dim bytesRead As Integer
bytesRead = unCompressedFile.Read(bytes, 0, 5000)
unCompressedFile.Close()

My next move is to create a FileStream object for the compressed file I want to create:

Dim CompressedFile As FileStream
CompressedFile = File.Create("C:\IttyBittyFile.gzip")

With all the files in place, I'm ready to create the GZipStream object that will do the actual compression. You have to pass two parameters when creating the GZipStream object: The first is the FileStream for the compressed file you intend to create; the second indicates that you want to compress the file.

Here's my code to create a compressed file called IttyBittyFile.gzip:

Dim zipper As GZipStream
zipper = New GZipStream(CompressedFile, CompressionMode.Compress)

Now I can use the GZipStream Write method to write out the compressed file, passing the bytes I retrieved from the original file:

zipper.Write(bytes, 0, bytesRead)

Finally, of course, I close the GZipStream object and my compressed file:

zipper.Close()
CompressedFile.Close()

As you probably suspect, if you change the CompressionMode and pass in a compressed file, you can use GZipStream to decompress a file.

Posted by Peter Vogel on 12/10/2015 at 9:46 AM0 comments


Creating a NuGet Web Site

In my regular Practical.NET column, I showed how easy it is to create NuGet packages and discussed how it was a much better way for a developer to share anything you've created, from Entity Framework classes to JavaScript files (my example was a package that implemented an HtmlHelper consisting of a DLL and a JavaScript file). NuGet also allows you to attach searchable documentation to your package to ensure that a developer can find your package, recognize it and know what your code does.

In that article, I showed how to use a folder as a repository for NuGet packages. But if you'd like something a little more professional, you can create a NuGet Web site. It's easy to do: First, in Visual Studio, create an Empty Web Application. Once the project appears in Solution Explorer, right-click on it and select Manage NuGet Packages. In the NuGet Package Manager, do a search for the NuGet.Server package and install it.

After deploying your Website, you just need to do two things:

  1. Save your NuGet packages into the Packages folder in your new site.
  2. Tell Visual Studio about your site.

My earlier article walks through both processes. You can get the information for your site by surfing to it with your browser -- its default page provides both the file path to the folder you should save your package in and the URL you should use when telling Visual Studio about your NuGet site.

I'll put in one caveat: I only tested this on IIS 7.

Posted by Peter Vogel on 12/03/2015 at 10:18 AM0 comments


Stop Being Bugged About Changed Files

Every once in a while, you have a file open in one of your Visual Studio tabs and the file is updated on the disk. Unlike when any unopened files/folders in Solution Explorer are changed, Visual Studio notices this change. The result is that you get a dialog telling you that the “file has been modified outside of the editor” and are asked if you “want to reload it?” There are, essentially, two buttons on the dialog: Yes and No.

I have never clicked No. Not once. Not ever.

So, the other day, I took the plunge and turned off this dialog: I shouldn’t ever see that message again. Instead, my changed file will be quietly refreshed. If you also want to get rid of the dialog, first go to the Tools menu and select Options. From the Environment treeview on the left side of the resulting dialog, drill down to the Documents node and, on the right, check the option under “Detect when file is changed.” This will cause Visual Studio to skip the dialog and just reload the changed version of the file.

Depending on which version of Visual Studio you have, that option will be called “Autoload Changes, If Saved” or the more obvious “Reload modified files unless there are unsaved changes.” Either way, as long as you haven’t made changes to the file, the changed file will automatically (and silently) be refreshed in the editor tab. If you’ve made changes to the file and haven’t saved them yet, you’ll get a dialog asking if you want to keep your changes.

Quite frankly, I don’t know why it isn’t the default.

Posted by Peter Vogel on 11/17/2015 at 9:43 AM0 comments


Protecting Shared Fields in Asynchronous Processing

Sometimes, in a C# application with multiple threads running simultaneously, you need to share data. So you set up a variable declared outside of any method or property (a "field") and have the different threads share data by updating and reading that variable. It should work ... but it doesn't and you can't figure out why.

The odds are that there's some bug in your asynchronous code that's creating the problem. However (and this is a long shot), it might be the compiler's fault. Some of the optimizations the compiler applies to a field assume that the field will only be accessed by a single thread at a time. This means your source code might look fine ... but the optimized code you're executing is doing something different.

There are two solutions in C#: First, put a lock around any code that accesses the field (this option is also available in Visual Basic). You might take a hit on performance as threads queue up to get to your field, but it ensures that you both keep the compiler's optimizations and have only one thread accessing the field at a time.

If you don't think you can find all the places that the field is being read or written (or are too lazy to look) you can, in C#, mark the variable as volatile:

internal volatile string Status;

The volatile keyword causes the compiler to omit the optimizations that assume single-thread access. You'll still take a performance hit because, internally, the compiler will cause reads and writes to your variable to be processed in sequence. But, now, when your application still doesn't work, you'll know it's your fault.

Visual Basic doesn't have an equivalent to the volatile keyword. However, if you can track down all the places where you read or write the field, you can use the Thread object's VolatileRead and VolatileWrite methods when working with the field.

Posted by Peter Vogel on 11/04/2015 at 10:07 PM0 comments


Upcoming Events

.NET Insight

Sign up for our newsletter.

I agree to this site's Privacy Policy.