Practical .NET


TypeScript & Visual Studio 2013: Coming of Age

Visual Studio 2013, with the latest version of TypeScript, gives you the same kind of support you've come to expect when writing code in C# and Visual Basic.

Offloading Work from Your Application with a Queue

Sometimes you can improve your application's response time by shunting some activities to offline processing -- sending an e-mail response, for instance. Here's how to use Microsoft Message Queue (available on both your development and production computers) to simplify the process.

Strategies and Code for Creating Fluent APIs

There are numerous ways to implement a fluent API, depending on the degree of control you want to maintain over the API, how many classes you want to be able to use it with, and how you want to extend your API. Here are your options.

Book Review: .NET 4.5 Parallel Extensions Cookbook

Bryan Freeman's book on creating asynchronous applications does a great job of explaining the technology the .NET Framework provides for creating asynchronous applications.

Picking and Choosing Features in Your Language

Just because your language can do it, it doesn't mean that you should.

Best Practices for Designing a Fluent API

You can't "grow" a fluent API; you need to understand how developers will need (and expect) to use your API. Here's a case study of what the design process for a fluent API looks like.

Creating Useful Naming Conventions: Business Considerations

Peter continues to look at the value of imposing naming conventions on developers; but this time, he looks at the benefits related to understanding the business problem, as well as why flexibility is crucial.

Implementing a Fluent Interface

Here's how to implement a fluent API for a single class that supports the goals of fluent interfaces.

Writing User Manuals: Get Someone Else To Do It (Seriously!)

Just because you've created an application, it may not need a user manual, guide or help system. And, even when your application does need that kind of support, you should -- at all costs -- avoid writing it.

When To Build Fluent Interfaces for Re-Use and Clarity

Fluent methods are a hot design idea and they can improve the readability of your code. However, they only make sense in specific scenarios. Here are some criteria to help you decide if you should be creating a fluent interface, and some design guidelines for when you do.

Handling Record Contention in Code-First Entity Framework

Peter returns to the topic of managing multiple users accessing the same row in a table using Entity Framework, but this time using code-first development. There are some unexpected issues to deal with.

Creating Useful Naming Conventions: Technical Considerations

Naming conventions are obviously a good thing, right? Not necessarily -- and only if you understand the problem they solve.

UI Practicalities: Determining the User's Intent

After having a UI design invalidated during usability testing, Peter has to find a way to figure out what the user wants the application to do.

Test-Driven Development with Content Negotiation in the Web API

There's no doubt that the ASP.NET Web API is a wonderful thing. But developing services that support content negotiation in a testable way requires a little setup.

Checking Collections and Working with Objects in Visual Studio Test

Peter looks for help in building an extension method that will let him compare two objects in a Visual Studio Test. In return, he introduces the CollectionAssert class.

Upcoming Events

.NET Insight

Sign up for our newsletter.

I agree to this site's Privacy Policy.