Practical .NET


Writing Cleaner Code with Reactive Extensions

When you have a process that can return multiple results over time, then .NET Framework Reactive Extensions will let you simplify your code and manage it better.

Building a Useful HTML Helper for ASP.NET MVC Views

Creating a full-featured extension for the ASP.NET MVC HtmlHelper class sounds like a lot of work. But, because of the way the Microsoft .NET Framework works, it's almost trivially easy. To show that, here's an EditBlockFor method that adds a label, a textbox and a validation message to your ASP.NET View.

vNext: What's in It for You?

Here's a grab bag of what you might find useful in the next version of the .NET Framework. It's good news for everyone but ASP.NET Web Form developers.

Splitting Tables To Improve Performance: A Designer-Based Solution

Peter returns to improve performance by splitting a single table into multiple entities, but this time, he implements his solution using the Entity Framework 6 designer.

Splitting Tables in Entity Framework 6 to Improve Performance

There are some occasions when using Entity Framework can really hurt you: When you have tables with hundreds of columns or tables with large payloads. Here's how to get EF6 to do the right thing.

The Sociology of Application Security: Less Can Be More

The critical part of security isn't your code; it's the people using your applications. Because of that, increasing your security often makes your applications less secure.

Managing Transactions in Entity Framework 6

Here's an article about managing transactions that you don't need to read because, with one exception, Entity Framework will do the right thing by default. But, in the .NET Framework 4 and later, you can do more (if you ever need to).

How To Manage Asynchronous Tasks Using the Task Object

You want the responsiveness that asynchronous programming in the Microsoft .NET Framework 4 provides, but also need your asynchronous methods to work with other code in your application. Here's how the Task object answers all of your problems.

Leveraging Interfaces and Extension Methods To Extend Your Classes

Extension methods provide a great way for extending a class functionality -- but it's interfaces that let you use those methods anywhere you want.

The Last Step in UI Design: Scripting Interaction

An interaction script bridges the gap between designing concepts and actually adding controls to forms. The interaction script will tell you what your application needs to do, leading you (finally) to what controls you need on which forms.

Leveraging User Mental Models To Create Effective User Interfaces

The principles of great UI design start from a different place than the principles that lead to great application design. They both end up in exactly the same place, though.

Bridging the User Interface Design Gap

The best thing you can do in order to create a great UI is to stop thinking about UI design.

Test-Driven Development with Entity Framework 6

You can completely disconnect your test code from your database with Entity Framework 6 in .NET and Visual Studio. You just need a little bit of custom code for your application, along with some boilerplate code.

Shedding Tiers: Stop Thinking in Terms of Layers

Thinking in terms of layers or tiers really isn't much help to you. Stop doing it: The single responsibility principle and design patterns are all you really need.

How To Simplify Asynchronous Programming with Await and Async

Prune your Entity Framework with the help of asynchronous methods.

Upcoming Events

.NET Insight

Sign up for our newsletter.

I agree to this site's Privacy Policy.