Practical .NET


Supporting Multiple String Formats from Your Class

Developers (including you) benefit when you provide a string representation of your class. By implementing IFormattable, you can take control of this representation and provide some flexibility. Besides, if you don't provide one, the Microsoft .NET Framework will provide a useless one for you.

Processing a File or Folder When It Changes in Your Desktop Apps or Windows Service

When you need to know when a file or folder appears, disappears or is renamed -- in fact, if almost anything at all happens in the file system -- you can have Windows notify your application so that you can take action.

Opening a Dialog Box in an ASP.NET MVC Page

There are lots of benefits to gathering information by opening a dialog box instead of sending your user to another page. Fortunately, jQuery and ASP.NET MVC make it easy to do (and you don't have to worry about offending pop-up blockers).

Leveraging Interfaces Instead of Inheritance

If you need to have objects look alike but don't have any code to share, you don't need inheritance -- you need an interface. Here's an example of how interfaces provide a more flexible way to deal with similar-but-different classes.

The Easiest Way to Share Code: NuGet

You want to use a DLL in multiple projects (it's even possible that other developers at your company might find your DLL helpful). The easiest way to distribute and deploy that DLL, or any other combination of files, is with NuGet. Really.

Creating a True Value Object

You can dramatically simplify your code by using classes to define read-only/immutable objects … but to create classes that behave correctly requires a little bit of redirection.

Creating a Value Object that Developers Can Use

You can dramatically simplify your code by using value objects, but to create a value object that makes sense to the developer who uses it, you need to redefine what the equals sign means. Along the way, Peter points out some problems when you don't use classes to define your data.

Using Predicates in Akka.NET Receive Actors

Create precise logic dictating which messages an actor will handle and how they will react to them.

Modelling Actor Behaviors in Akka.NET

Simplify conditional actor code and improve readability.

Simplifying Applications with Eventual Consistency

Stop trying to make everything work all at once. Instead, use Domain Events to make applications simpler, more scalable and easier to maintain -- and to defer updates until you can't avoid making them.

Simplifying Applications by Implementing Eventual Consistency with Domain Events

Implementing Domain Events can dramatically simplify your application while also making it more scalable. Here are some of the implementation options available to you in the .NET environment.

Creating a Genuine Value Object

Peter addresses reader's concerns by showing how to implement a read-only/immutable value object.

Building a Better MVC Helper

Readers suggest ways to build a powerful HtmlHelper that simplifies creating typical application Views. Along the way, Peter uses a workaround for extending an anonymous object with additional properties and shows how to extract values from a lambda expression in a View.

Strategies for Isolating Applications

If you're not careful, you'll replace your huge, lumbering unmaintainable enterprise applications with a web of applications that can't be changed without blowing each other up. But if you apply the same tools you use inside your applications to your application architecture, you can avoid that.

Distributed Concurrent Actor Models with Akka.NET

Ease the pain of concurrent programming with the Actor Model and Akka.NET.

Upcoming Events

.NET Insight

Sign up for our newsletter.

I agree to this site's Privacy Policy.