Practical .NET

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.

Capturing Results from Stored Procedures with Entity Framework 6

Entity Framework 6 gives you a variety of ways to call stored procedures that return data and capture the results those procedures return. Here's a look at all of them.

Moving Data to the Form in Windows Forms

When you implement the Model-View-ViewModel pattern you need to tell your View (in this case, a Windows Form) when the ViewModel has new data. Here's how to do that, along with a warning about how to avoid a potential bug.

Separating the UI Code from the Business Code: What's Reasonable?

Peter Vogel moves a Windows Form to a modern design pattern, which forces him to think about how his code should be divided up among his classes. In the end, he comes up with some rules for making those decisions.

Calling Stored Procedures from Entity Framework

Even in a Code First environment, you can call a stored procedure from a DbContext object. But it's a lot easier if you use the visual designer.

Making Complex Types Useful with Entity Framework 6 Custom Configurations

Complex Types let you reuse structures in your database design. But unless you've been very lucky around the names in your database, you probably couldn't use Complex Types -- until Entity Framework 6, that is.

Upcoming Events

.NET Insight

Sign up for our newsletter.

I agree to this site's Privacy Policy.