Columns


Configuring Your Application-Wide Objects in ASP.NET Core

ASP.NET Core's support for sharing objects defined at startup is great ... but what if you need to set options on those objects? Here's a case study that starts off great and then descends into over-engineered madness (but only if you want to go that far).

Creating the Right Database Initializer for Entity Framework

If you want to treat your database design as an "implementation detail" that just falls out of getting your object model right, then Entity Framework gives you four choices. Picking the right one, however, may mean creating your own.

ASP.NET Core: Learning the Ropes, Part 3

Eric Vogel uses code samples and screenshots to demonstrate how to create and use the views and controller for an ASP.NET MVC Core CRUD application.

21 New Tools and Extensions for Visual Studio 2017

From legacy xBase code to cutting-edge Quantum computing, these Visual Studio extensions will make you more productive.

Self-Organizing Maps Using Python

Dr. James McCaffrey of Microsoft Research uses a full project code sample and screenshots to detail how to use Python to work with self-organizing maps (SOM), which let you investigate the structure of a set of data.

Working with Session in ASP.NET MVC Core (or: Why You Can't Migrate)

Here's everything you need to write code for the Session object in ASP.NET Core -- including why you can't expect to migrate your existing ASP.NET MVC application to ASP.NET MVC Core (though Peter has some suggestions on easing that pain).

Creating Web Pages with Blazor: The Basics

If you know how to create an ASP.NET MVC View, you know a great deal about how to create pages in Blazor. But, by packaging up pages as Blazor Components, you can use (and re-use) those pages more like objects.

Finding Your Objects in ASP.NET Core

Central to ASP.NET Core is the collection of objects that give you access to ASP.NET Core functionality. Here's how to access it, how to add to it and an example of how to use this technology with the "difficult" cases.

An Introduction to Templated Components in Blazor

Templated components expose customizable sections via parameters, and consumers then pass in their own templates for these sections that the component will use when rendering. They make it really easy to create some high-level reusable components, especially when incorporating generics.

Image Classification Using Keras

Creating a custom image classification model is challenging, but the existence of neural network libraries like Keras has made it doable. Here's how, with many code samples and a full project download.

Programming Will Always Be Hard

If you're a programmer then you know that you frequently get things wrong. Sometimes you find those bugs before your application gets to production ... and sometimes you don't. Bad news: Nothing is going to help and it's not going to get any better.

Providing Constant Context for .NET Core Tests

By default, tests in the new .NET Core testing framework (xUnit) are isolated. This is a good thing ... except when you need to create a single test environment that is used by multiple tests. Here's all the ways you can provide a single environment for a set of tests in xUnit.

Writing xUnit Tests in .NET Core

There's a new testing framework in town. Here's how to use it.

Architecting Blazor (and Integrating JavaScript)

Sometimes the easiest solution isn't the best one. Here's an architectural approach to building Blazor pages that also makes it easy to combine the worlds of JavaScript and Blazor.

ASP.NET Core: Learning the Ropes, Part 2

Eric Vogel provides many code samples to show how to use Entity Framework Core for an ASP.NET Core MVC application.

Introducing the .NET Core Unit Testing Framework (or: Why xUnit?)

There's a new kid in the Visual Studio testing environment, though it's only for your .NET Core projects. You don't have to use it, but here are some reasons you'll want to.

Sentiment Analysis Using Keras

Custom sentiment analysis is hard, but neural network libraries like Keras with built-in LSTM (long, short term memory) functionality have made it feasible. Step into the Data Science Lab with Dr. McCaffrey to find out how, with full code examples.

Adding Blazor to Existing HTML+JavaScript Pages

Not only can you integrate JavaScript with Blazor, that integration provides a strategy for moving your existing pages to Blazor without having to rewrite your existing JavaScript code.

Subqueries in LINQ

If someone tells you that LINQ doesn't support subqueries ... well, they're not wrong. But they're also not entirely correct, either. With LINQ you can meet many of the goals of SQL subqueries including the ability to build complex queries out of simpler ones.

Blazor: Working with Events

Blazor expert Chris Sainty provides hands-on code samples to explain how to handle DOM and user-defined events in Microsoft's experimental project for writing browser-based apps with C# instead of JavaScript.

Most   Popular
Upcoming Events

.NET Insight

Sign up for our newsletter.

Terms and Privacy Policy consent

I agree to this site's Privacy Policy.