TL;DR – Iterators - the thing that allows you to use the yield keyword in functions that return IEnumerable<T> - do magic under the hood and are significantly different from non-iterator code that returns IEnumerable<T>. In addition, up until recently iterators did not support async/await but IAsyncEnumerable<T> has changed that - now you can use yield inside of your async code.

Let’s talk about iterators in C# (e.g. any method that can use yield return) - a concept that I find still confuses developers - and then discuss the recently added IAsyncEnumerable<T> and why it’s useful.

Iterator basics

Iterators in C# - the ability to use yield to return elements in a function that is declared as IEnumerable<T> - have been around for a while, but I still find that there are developers who don’t know what they are or how to use them. Most commonly, they know of the yield keyword - but don’t know the implications of using it.

The best way I’ve found to demonstrate the differences between code that uses yield and code that doesn’t is to talk about the IL that’s generated. I’m no IL expert by any means, but I can at least compare two sets of IL and figure out which one I think is more complicated.

Let’s take this method for example:

public IEnumerable<string> GetStrings() {
    return new[] {
        "Spencer",
        "Schneidenbach",
        "Louie"
    };
}

The IL that’s generated is very straightforward - declare an array, set the elements of that array in said array, and return it:

.method public hidebysig 
    instance class [System.Private.CoreLib]System.Collections.Generic.IEnumerable`1<string> GetStrings () cil managed 
{
    .maxstack 4
    .locals init (
        [0] class [System.Private.CoreLib]System.Collections.Generic.IEnumerable`1<string>
    )

    IL_0000: nop
    IL_0001: ldc.i4.3
    IL_0002: newarr [System.Private.CoreLib]System.String
    IL_0007: dup
    IL_0008: ldc.i4.0
    IL_0009: ldstr "Spencer"
    IL_000e: stelem.ref
    IL_000f: dup
    IL_0010: ldc.i4.1
    IL_0011: ldstr "Schneidenbach"
    IL_0016: stelem.ref
    IL_0017: dup
    IL_0018: ldc.i4.2
    IL_0019: ldstr "Louie"
    IL_001e: stelem.ref
    IL_001f: stloc.0
    IL_0020: br.s IL_0022

    IL_0022: ldloc.0
    IL_0023: ret
}

Now, what about its iterator cousin? It’s still pretty straightforward looking on the surface:

public IEnumerable<string> GetStrings() {
    yield return "Spencer";
    yield return "Schneidenbach";
    yield return "Louie";
}

But under the hood it looks a liiiiiitle different. That’s because it generates a state machine under the hood to track which elements have been returned from the method - for instance, if you call GetStrings().First(), the state machine suspends after it yields its first element and doesn’t run the rest of the method until you request more elements after the first. You can find a good explanation of this in Microsoft’s documentation.

Iterators and async/await

Iterators are an important and useful abstraction over data streams - it’s generally good to process data as you retrieve it if that’s possible. However, until recently iterators had one big problem: they did not support async/await natively. Then, C# 8 came along and brought with it IAsyncEnumerable<T>.

Previously, you had to write some pretty nasty code to get iterators to work in normally async code (please don’t do this):

public IEnumerable<string> GetStrings()
{
	var httpClient = new HttpClient();
	var websites = new[] {
		"https://google.com",
		"https://microsoft.com",
		"https://schneidenba.ch"
	}
	
	foreach (var website in websites)
	{
        var requestTask = httpClient.GetAsync(website);
		var request = requestTask.GetAwaiter().GetResult();	        //bad
		yield return request.Content.ReadAsStringAsync().Result;	//WORSE
	}
}

You could forego it and use async all the way down:

async Task<IEnumerable<string>> GetStrings()
{
	var websites = new[] {
		"https://schneidenba.ch",
		"https://google.com",
		"https://microsoft.com"
	};
	var httpClient = new HttpClient();
	var list = new List<string>();

	foreach (var website in websites)
	{
		var resp = await httpClient.GetAsync(website);
		list.Add(await resp.Content.ReadAsStringAsync());
	}
	
	return list;
}

The problem with this code is that it required you to build up a list in memory and return the data all at once, as opposed to as the data was returned to you.

Of course there were other options, like using the Reactive Extensions - a perfectly valid option and one I’ve used before. However, it’s nicer to have async iterators in the language. Now, we can have the best of all worlds: code that is very simple to read and understand yet also very powerful:

async IAsyncEnumerable<string> GetWebsitesAsync()
{
	var websites = new[] {
		"https://schneidenba.ch",
		"https://google.com",
		"https://microsoft.com"
	};
	
	foreach (var website in websites) {
		var req = await HttpClient.GetAsync(website);
		yield return await req.Content.ReadAsStringAsync();
	}
}

Which can be consumed by doing await foreach:

await foreach (var website in GetWebsitesAsync()) {
    Console.WriteLine(website.Substring(0, 100));
}

Stuart Lang has a great post on IAsyncEnumerable<T> which covers it differently from me - different perspectives are always good :) Surprisingly, the official Microsoft docs don’t seem to have a lot on IAsyncEnumerable<T> yet, but at least their async/await docs are good!

TL;DR – System.Text.Json is a new JSON library for .NET with different design goals from its predecessor, Newtonsoft.Json. If you’re already using Newtonsoft.Json in an existing project, you likely don’t need to switch. If you absolutely need high JSON serialization/deserialization performance, go with System.Text.Json.

System.Text.Json was released last year and since it’s integrated into ASP.NET Core 3, I thought we should briefly compare it to the most downloaded NuGet package around, Newtonsoft.Json.

I think it’s important to understand the reasoning behind writing a whole new JSON library when we already have Newtonsoft.Json. System.Text.Json was designed first and foremost with high performance in mind - the .NET team (which includes James Newton-King, the guy who wrote Newtonsoft.Json) found they couldn’t refactor Newtonsoft.Json to meet some of these goals without making breaking changes to existing code.

In addition, System.Text.Json strictly adheres to the JSON spec, RFC 8259 - things you previously could do with Newtonsoft.Json (because it wasn’t spec compliant) aren’t allowed in System.Text.Json.

For example, Newtonsoft.Json will deserialize:

• Property names that have a different case
• Property names in JSON that have single/double/no quotes
• Null values for non-nullable fields properties (null -> an int property is allowed)

System.Text.Json only supports (out of the box):

• Deserializing JSON properties by names with the same case
• Property names with double quotes
• Deserializing JSON properties to their like-typed C# counterparts (int -> int only, not null -> int property)

There’s a lot of differences in behavior that you can find in this article, but the question needing answered is, do you need to switch from Newtonsoft.Json to System.Text.Json?

The answer is almost certainly no. If you switch, there are a lot of subtle differences that may cause runtime errors. Newtonsoft.Json is still a nice abstraction for .NET - System.Text.Json is much closer to the JSON metal.

Other links:

• How to migrate from Newtonsoft.Json to System.Text.Json
• Blog post announcing System.Text.Json

Updated for 2019 - but this time I ended up removing a bunch of stuff, like Angular. New items are bolded.

Here is my (mostly) comprehensive list of tools I use for development, either at home or work.  It’s like Scott Hanselman’s, but focused almost purely on development, with a couple of extras.  While you’re at it, go check his out.  All opinions are my own and are not bought or sold.

The Main Stuff

Visual Studio – the essential tool for .NET devs everywhere, especially ones still tied to the .NET Framework. Not much else to say except that it has a great starting toolset for any developer and amazing plugin support.  The Community edition gives the masses the power of the Professional SKU, for free.  Simply amazing and getting better with every release.

JetBrains Rider – this has emerged as a real contender as a .NET IDE. I love using this on the Mac side (still have to use Visual Studio for the “old” .NET Framework stuff). It’s like having a super fast ReSharper in your IDE.

Visual Studio Code – Microsoft’s cross-platform IDE has taken the lightweight-yet-extensible text editor world by storm. I use this on my Mac for developing ASP.NET Core apps, writing Markdown files, and just editing plain text files. Has almost totally replaced my use of Notepad++. The plugin system and rapid development turnaround is going to threaten the paid alternatives in a big way (Sublime, I’m looking at you).

Parallels - my preferred virtualization platform for running Windows 10 on my Mac. Fast and excellent support.

Node Package Manager - best tool for installing your command-line dev tools and front-end frameworks. I use it in conjunction with Visual Studio and Visual Studio Code to do development across several stacks, including WebForms apps that I support.

SQL Server Management Studio – it ranges from a useful IDE for SQL to a huge time saver for things like table creation and script generation.  The DROP and CREATE tools are awesome for generating scripts for tables, stored procs and more.

LINQPad – the best .NET code scratchpad on the market. It’s not just for writing LINQ queries - it’s   It’s not a complete replacement for SQL Management Studio, but for complex queries with lots of data, it’s my first choice.  The Premium edition is a steal and makes this essential tool 5 times more useful with C# autocomplete, NuGet, cross-database query support, and debugging.

NimbleText – thanks to Scott Hanselman, I have found this program – and my new favorite way to write repetitive code or handle small or large data transformation tasks.  I’ve used it from everything from writing HTML to generating SQL insert scripts.  Its time-saving power cannot be overstated.  And, it’s FREE!

Balsamiq - my personal favorite mockup tool. I use the Desktop version, though the cloud versions are good products too!

Fiddler – the essential tool for viewing and diagnosing HTTP requests that are happening on your machine.  Turn on SSL decryption and see previously-unknown HTTPS requests decrypted before your eyes.  Use it to view incoming and outgoing HTTP requests in real time.  Turn it into a proxy and send a device’s HTTP requests through it to test devices within your network.  Replay captured HTTP requests with its Composer system.  Fiddler’s amazing abilities cannot be overstated.  It’s helped me diagnose and fix more problems with HTTP services than any other tool.

dotPeek – my favorite way to decompile .NET code, free from JetBrains.  It even has the ability to break a .NET DLL/EXE down into a fully-structured Visual Studio project!

Postman – my second-favorite way to test HTTP services is Postman.  Postman has an easy-to-use interface and provides a straightforward way to make HTTP requests.

Google Chrome – I still prefer Google Chrome, though Firefox is looking more and more appealing.

PowerShell - easily the best scripting language on the Windows platform. Great scripting plus the power of the .NET Framework at your disposal when you need those extra awesome features. Also, recently made cross-platform!

Webpack - bundle all of your JS, CSS, TS, etc files together for delivery to your local friendly web app. I use this on new and old projects alike. Powerful and simple to configure.

Visual Studio add-ins

ReSharper – perhaps the most essential tool for .NET devs around the world.  Amazing refactoring that puts Visual Studio’s default refactoring capabilities to shame.  Code generation that makes writing constructors, methods, or pretty much anything a snap.  Search tools that makes navigation through code effortless.  A built-in test runner that makes running and viewing tests a breeze.  A code analysis tool to help you find mistakes and potential pitfalls in your code.  Built-in added support and intellisense for common frameworks such as ASP.NET MVC.  It is truly the god of all Visual Studio plugins.  Go download it and tell your friends.

OzCode – if you’re a C# developer, you need OzCode.  It turns debugging from a necessary chore to a borderline delight.  Break down code expressions, highlight the most needed data in an object, compare data between two objects, find all objects of a given type in memory, and exceptional exception handling make OzCode a star – and that’s just the tip of the iceberg.

Web Essentials – a great tool by Mads Kristensen of Microsoft – it’s his personal testbed for new web-based Visual Studio features.  Features things like quick HTML typing using ZenCoding, a link between the browser and Visual Studio for seeing immediate changes to your changed HTML/CSS, better Intellisense for CSS/HTML/JavaScript/Angular, and so much more.  Install it and watch your productivity in web development go to 10.

GhostDoc - best way to quickly write your XML code comments. Makes it so easy to annotate your code with comments about the code you’re writing.

Source control

Git - the favorite source control solution for tons of developers. So prevalent that all recent Microsoft open source code is published to GitHub instead of their own internal SCM, Team Foundation Server. Most powerful learned with the command line or using tools such as…

GitKraken – a great visual tool for Git users.  Much better than SourceTree IMO.

Languages

C# - my preferred backend language since the start of my career. So much power and ease in the language and in the .NET Framework. Made even more relevant with the recent introduction of .NET Core.

JavaScript - famously called the machine language of the web, it’s the most critical language for any software engineer of all disciples and skill levels to master if you’re doing web work of any kind.

TypeScript - my preferred language for all JavaScript development I do. Embraces the weirdness of JavaScript while adding awesome features like a better type system, interfaces, and all of the features of any flavor of ECMAScript.

Hosting

Microsoft Azure - the no-brainer hosting solution for .NET developers and, well, any developers for that matter. Runs Windows as well as it runs Linux, Unix, you name it. Amazing interface and tons of power - even has a RESTful API that you can use to spin up and maintain servers.

Frameworks

My favorite .NET/web frameworks!

Web

ASP.NET Core – built on top of MVC, Web API makes spinning up an RESTful API a breeze.  Host it in IIS or self-host on top of OWIN (this works great with Topshelf.)  Use it to power everything from your mobile app to your single-page application, powered by your favorite JavaScript frontend framework.  Versatile and fun to use.

React - amazing view library which has gotten a ton of love in the last couple of years. Combine it with your tooling of choice to create awesome web apps that scale well from a codebase perspective. Write your views in JavaScript using JSX and put the power of your HTML into your JS, as opposed to the other way around with Angular. (Yes, I took Angular off this list.

SignalR – the easiest and most powerful way to create an excellent realtime experience for the web or anything that can connect over HTTP.  I personally used it to power realtime text message communications between a Xamarin-powered mobile app as well as a desktop app.

Data access

Entity Framework – my favorite way to access a database, period.  Use LINQ to communicate with your database, create your data views using attributed POCOs and easily update your model with Migrations.  It’s not for everyone, but it’s fast enough for most use cases and getting better every day.

Dapper – when I want a way to quickly access a database using SQL, Dapper has my back.  Deceptively simple API for what turns out to be a very fast way to access data.  Powers the data access layer behind StackExchange, one of the highest traffic websites on the planet.

General .NET libraries

Newtonsoft.JSON – the standard for JSON serializing and deserializing in .NET.  Used everywhere.  Go and buy him a beer – James Newton-King has made all of our lives easier.

AutoMapper — used to map properties in objects together. One of my favorite libraries in .NET. I combine it with AutoMapper.Attributes to create self-documenting type definitions.

MediatR — a great in-memory request/handler system. I use it in all of my ASP.NET Core projects as the backbone to my implementation of CQRS.

FluentValidation - By far my favorite way to validate requests and other objects. I combine it with MediatR to create a great request-validator-handler pipeline. (Bonus: see my Recess projects for an example implementation!)

RabbitMQ – when you need a reliable messaging queue for your suite of applications, RabbitMQ is a strong choice.  If using .NET,EasyNetQ makes the experience that much easier – it abstracts the most difficult parts away into message passing via POCOs.

Moment.js – Dates in JavaScript are harder than they need to be.  Moment.js makes it that much less difficult by providing a simple and powerful date API.  Usually my second web project add-in (first being Underscore, of course.)

Little stuff

Paint.NET – a fast, free paint tool written using .NET.

WinRAR – my choice for compression.  Yeah, I know Scott Hanselman recommends 7Zip, but 7Zip’s context menu requires two clicks – WinRAR’s only requires one I’m codger-y and like WinRAR. (Thanks for all those who pointed out that, in fact, you can configure 7Zip’s context menu to require one click.)

Treesize Free – a great cleanup tool for those who have constrained hard drive space.

LastPass – a wonderful password manager that makes managing logins a much easier endeavor.  When you’re in IT, you know how crucial it is to keep track of passwords and LastPass makes that much much easier. 

Links

Reddit– I subscribe to r/programming, r/dotnet and a handful of other useful programming-related subreddits.  Useful for a quick mid-day browse when you need to look away from Visual Studio for 5 minutes.

Hacker News – not necessarily programming focused, but it has some interesting tech-related topics.  I just started reading this recently.  Clearly, I’ve missed the party for a long time.

StackExchange– if StackExchange doesn’t have an answer to your programming question or problem, then you’re probably on your own.  Learn from the wisdom of others’ mistakes and find quick, elegant solutions to your programming problems.  Chase down those obscure exceptions.  If you haven’t used it, then you’ve never used Google to solve a problem.

Scott Hanselman’s Blog – Scott Hanselman is my main man.  His blog posts are always interesting and valuable and his contributions to the Microsoft dev world cannot be overstated.

Communication slash speaking slash branding tools

Twitter/X - the best way to communicate with other professionals in your industry in a meaningful way.

Ghost (blogging platform) - recently replaced WordPress in my life. Ghost focuses on one thing and one thing well - creating a great blogging experience. I love the use of Markdown over a WYSIWIG editor. I love its pure speed over Wordpress. Probably going to move to Gatsby soon though…

GitPitch — I use this to create presentations. Write simple slides in Markdown and commit to a GitHub repo, and voila — instant great looking slides. Used to be PowerPoint or Keynote, but GitPitch takes a lot less time, and my code slides look great since GitPitch uses GitHub Flavored Markdown.

Trello - helps me keep track of all of my speaker submissions, my current talks, and any conferences I want to submit to. Useful for so much more.

Camtasia Studio - my favorite tool for recording screencasts and demonstrations. Expensive, but worth it if you do this kind of thing a lot. Open Broadcaster Software (OBS) is a free alternative.

Paging is a useful concept in any API.  Here’s an example of one that I use pretty frequently when making APIs in ASP.NET Web API.

You can download an example project (complete with unit tests!) here: https://github.com/schneidenbach/AspNetPagingExample

The steps we’re going to take to complete this task:

• Setup our paging model.
• Define our entity and API models.
• Create our easy-to-use paging method that will magically turn an IQueryable into a paged set of data.

This example in particular requires AutoMapper, which will allow us to easily map our entities to our returned API models.  I also use Entity Framework to store and retrieve data, though that is not the focus of this particular project.  For the record – you should ALWAYS use API models (or DTOs, if you prefer) to do work through controllers.  Taiseer Joudeh, a Microsoft MVP for ASP.NET, calls it the “model factory pattern” and that’s how I typically refer to it.  That, or just API models. (Another way to think of API models: they hold the same purpose as a view model, but they’re not called that cause there’s no views.)  It’s a little bit more code up front, but will keep your code clean and enforce separation of concerns in the long run.  This has several advantages:

• Lets you control what data is returned to the client.
• Helps avoid binding to undocumented properties on PUTs/POSTs, which can be a pretty big security concern.
• Maintains a separation of concerns. (This object returns data to the client, this object is a database entity, etc.)

1. Create and define a paging model.

public class PagedResults<T>
{
    /// <summary>
    /// The page number this page represents. 
    /// </summary>
    public int PageNumber { get; set; } 
    
    /// <summary> 
    /// The size of this page. 
    /// </summary> 
    public int PageSize { get; set; } 
    
    /// <summary> 
    /// The total number of pages available. 
    /// </summary> 
    public int TotalNumberOfPages { get; set; } 
    
    /// <summary> 
    /// The total number of records available. 
    /// </summary> 
    public int TotalNumberOfRecords { get; set; } 
    
    /// <summary> 
    /// The URL to the next page - if null, there are no more pages. 
    /// </summary> 
    public string NextPageUrl { get; set; } 
    
    /// <summary> 
    /// The records this page represents. 
    /// </summary> 
    public IEnumerable<T> Results { get; set; } 
}

We have our PageNumber and PageSize, which should match exactly what you requested (if you requested page 1 and page size 10, you should have a PageNumber of 1 and a PageSize of 10. These fields are included in the event you don’t want to require a page number or page size in your paged API.)

You have some Results, which represents the actual objects being returned.

There is a TotalNumberOfRecords and TotalNumberOfPages, which returns totals for the returned objects. If there are 100 total records and you’re requesting 15 records per page, you should expect that TotalNumberOfPages will return 7 pages.

Finally, one of the most useful properties in this model is NextPageUrl. NextPageUrl makes it very easy to get the next page in the set by providing the URL to that next resource for you.

2. Define your entities and your API models (you do use separate models for returning data, right?)

public class Employee
{
	public int Id { get; set; }
	public string FirstName { get; set; }
	public string LastName { get; set; }
	public string SocialSecurityNumber { get; set; } //you probably don't want this returned by default, making the EmployeeModel useful
	public ICollection < Todo > TodoList { get; set; } = new List < Todo > ();
}

public class EmployeeModel
{
	public int Id { get; set; }
	public string FirstName { get; set; }
	public string LastName { get; set; }
	public ICollection<TodoModel> TodoList { get; set; }
}

public class Todo
{
	public int Id { get; set; }
	public string Name { get; set; }
	public string Description { get; set; }
	public Employee Employee { get; set; }
}

public class TodoModel
{
	public int Id { get; set; }
	public string Name { get; set; }
	public string Description { get; set; }
}

public class EntityContext : DbContext
{
	public virtual DbSet<Employee> Employees { get; set; }
	public virtual DbSet<Todo> Todos { get; set; }
}

Note that in this example we are using Entity Framework for data storage.

3. Map them together using AutoMapper.

AutoMapper allows us to easily create the EmployeeModel from the Employee without writing and maintaining factory methods. All properties with the same name from Employee will be set on EmployeeModel. A lot of awesomeness in one little library.

Mapper.CreateMap<Employee, EmployeeModel>();
Mapper.CreateMap<Todo, TodoModel>();

4. Create the paged set of data.

I like to use the following CreatePagedResults method below on my controller base class – it does all of the heavy lifting for you.

public class EmployeesController : BaseController
{
    public EntityContext EntityContext { get; }
 
    protected EmployeesController(EntityContext context)
    {
        EntityContext = context;
    }
 
    public async Task<IHttpActionResult> Get(int? page = null, int pageSize = 10, string orderBy = nameof(Employee.Id), bool ascending = true)
    {
        if (page == null)
            return Ok(await EntityContext.Employees.ToListAsync());
 
        var employees = await CreatePagedResults<Employee, EmployeeModel>
            (EntityContext.Employees, page.Value, pageSize, orderBy, ascending);
        return Ok(employees);
    }
 
    /// <summary>
    /// Creates a paged set of results.
    /// </summary>
    /// <typeparam name="T">The type of the source IQueryable.</typeparam>
    /// <typeparam name="TReturn">The type of the returned paged results.</typeparam>
    /// <param name="queryable">The source IQueryable.</param>
    /// <param name="page">The page number you want to retrieve.</param>
    /// <param name="pageSize">The size of the page.</param>
    /// <param name="orderBy">The field or property to order by.</param>
    /// <param name="ascending">Indicates whether or not the order should be ascending (true) or descending (false.)</param>
    /// <returns>Returns a paged set of results.</returns>
    protected async Task<PagedResults<TReturn>> CreatePagedResults<T, TReturn>(
        IQueryable<T> queryable,
        int page,
        int pageSize,
        string orderBy,
        bool ascending)
    {
        var skipAmount = pageSize * (page - 1);
 
        var projection = queryable
            .OrderByPropertyOrField(orderBy, ascending)
            .Skip(skipAmount)
            .Take(pageSize).ProjectTo<TReturn>();
 
        var totalNumberOfRecords = await queryable.CountAsync();
        var results = await projection.ToListAsync();
 
        var mod = totalNumberOfRecords % pageSize;
        var totalPageCount = (totalNumberOfRecords / pageSize) + (mod == 0 ? 0 : 1);
 
            var nextPageUrl =
            page == totalPageCount
                ? null
                : Url?.Link("DefaultApi", new {
                    page = page + 1,
                    pageSize,
                    orderBy,
                    ascending
                });
 
        return new PagedResults<TReturn>
        {
            Results = results,
            PageNumber = page,
            PageSize = results.Count,
            TotalNumberOfPages = totalPageCount,
            TotalNumberOfRecords = totalNumberOfRecords,
            NextPageUrl = nextPageUrl
        };
    }
}

A couple of important things to note:

• The Url.Link method assumes that you have the default Web API route called DefaultApi setup in your RouteConfig.  If you don’t, you might have to tweak this example to work for you.
• This example uses an extension method called OrderByPropertyOrField which (if you haven’t guessed) orders the IQueryable by the specified property, with a boolean to determine whether or not the order by should be ascending or descending. This string points to a property or field name of the entity type represented by IQueryable. The extension method is below:

public static class Extensions
{
    /// <summary>
    /// Order the IQueryable by the given property or field.
    /// </summary>
 
    /// <typeparam name="T">The type of the IQueryable being ordered.</typeparam>
    /// <param name="queryable">The IQueryable being ordered.</param>
    /// <param name="propertyOrFieldName">The name of the property or field to order by.</param>
    /// <param name="ascending">Indicates whether or not the order should be ascending (true) or descending (false.)</param>
    /// <returns>Returns an IQueryable ordered by the specified field.</returns>
    public static IQueryable<T> OrderByPropertyOrField<T>(this IQueryable<T> queryable, string propertyOrFieldName, bool ascending = true)
    {
        var elementType = typeof (T);
        var orderByMethodName = ascending ? "OrderBy" : "OrderByDescending";
 
        var parameterExpression = Expression.Parameter(elementType);
        var propertyOrFieldExpression = Expression.PropertyOrField(parameterExpression, propertyOrFieldName);
        var selector = Expression.Lambda(propertyOrFieldExpression, parameterExpression);
 
        var orderByExpression = Expression.Call(typeof (Queryable), orderByMethodName,
            new[] {elementType, propertyOrFieldExpression.Type}, queryable.Expression, selector);
 
        return queryable.Provider.CreateQuery<T>(orderByExpression);
    }
}

Download the completed project here: https://github.com/schneidenbach/AspNetPagingExample

Are you using String.Length to compute the length of a string that might include emojis?

If you compute String.Length for such a string, you may not get back exactly what you expect:

var str = "👶👶👶👶🍼🍼";
Console.WriteLine(str.Length);    //what do you think will be written?

This will write 12 to the screen. What were YOU expecting?

This happens because C# strings are UTF-16 by default and Unicode characters that fall outside of these 16-bit lengths are stored as surrogate pairs, or two chars that represent one 32-bit character.

However, you may be wanting the number of Unicode characters, not the actual length of the char array, in which case you should use System.Globalization.StringInfo to compute the length of your strings. Like so:

var str = "👶👶👶👶🍼🍼";
var stringInfo = new System.Globalization.StringInfo(str);
Console.WriteLine(stringInfo.LengthInTextElements);

This will yield what you’re looking for: 6

Want more reading? Check out Joel Spolsky’s very excellent article on strings and encoding. Remember, there is NO such thing as plain text!

nameof is one of my favorite operators in C# 6 – it’s a little thing that makes life a little easier.  I use it a lot in Entity Framework 6 with the ForeignKey attribute and when throwing ArgumentExceptions so that I don’t have to have magic strings everywhere.

I discovered some interesting behavior regarding Nameof in VB.NET that I thought took VB.NET’s case insensitivity to the next level:

Class Program
    Sub Main()
        Dim firstNameOf = Nameof(YourClass.FirstName)
        Console.WriteLine(firstNameOf)
        'Output: FirstName
	
        Dim secondNameOf = Nameof(YourClass.fIRsTnAMe)
        Console.WriteLine(secondNameOf)
        'Output: fIRsTnAMe
    End Sub
End Class

Public Class YourClass
    Public Property FirstName As String
End Class

See the difference in outputs?  FirstName versus fIRsTnAMe?  I mean, c’mon, really?  The Nameof operator returns exactly what you type inside of it and not the actual properly cased member name??

This actually caused me a fair bit of grief the other night – I was using Nameof with the ForeignKey attribute in EF and kept getting these odd exceptions where it said it couldn’t find the member called Firstname – and all because I mistyped the casing for the property (FirstName.)

I’ve always had a soft spot for VB.NET – in fact I wrote a whole blog post about it a couple of years ago (lost to the ages).  I don’t use it nearly as much anymore – I only have one client who has a VB.NET app.  I gotta say though, it’s weirdness like this that makes me not miss it much, cause that sure is a strange design decision.  It’s one of the very few times that a VB.NET feature is truly not on par with a similar C# one.

(See also: unexpected behavior when using VB.NET’s If() with nullable types: http://stackoverflow.com/questions/10699740/mystery-of-the-if-function-in-vb-net)

Follow @schneidenbach on Twitter/X