The model

Simple and practical example of many-to-many could be some sort of digital ecommerce store. Users can put items into shopping cart (one shopping cart can have many items), whereas items belong to multiple carts. Lets start off by creating Cart and Item classes.

1
2
3
4
5
6

public class Cart
{
    public int Id { get; set; }

    public ICollection<Item> Items { get; set; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Item
{
    public int Id { get; set; }

    public string Name { get; set; }

    public int Quantity { get; set; }

    public ICollection<Cart> Carts { get; set; }
}

This looks good, but unfortunately it won’t work. At the day of publishing this article EF Core cannot handle this scenario. It simple don’t know how to handle this relationship. This is what you get when you’ll try to add migration:

Unable to determine the relationship represented by navigation property ‘Cart.Items’ of type ‘ICollection<Item>’. Either manually configure the relationship, or ignore this property using the ‘[NotMapped]’ attribute or by using ‘EntityTypeBuilder.Ignore’ in ‘OnModelCreating’.

First thing we need to do is to manually create another “in-between” class (table) which will hold many-to-many relations. Lets we proceed we new class:

1
2
3
4
5
6
7
8

public class CartItem
{
    public int CartId { get; set; }
    public Cart Cart { get; set; }

    public int ItemId { get; set; }
    public Item Item { get; set; }
}

Since we have a new class that maps Cart to Item we also need to change navigation properties:

1
2
3
4
5
6

public class Cart
{
    public int Id { get; set; }

    public ICollection<CartItem> Items { get; set; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Item
{
    public int Id { get; set; }

    public string Name { get; set; }

    public int Quantity { get; set; }

    public ICollection<CartItem> Carts { get; set; }
}

If you try to add-migration right now then you’ll get another error:

The entity type ‘CartItem’ requires a primary key to be defined.

Right, CartItem doesn’t have primary key. Since it’s a many-to-many relationship it should have composite key. Composite key is like a regular primary key but it is composed by two properties (columns) instead of one. At the moment, the only way to create composite key is to define it inside OnModelCreating.

1
2
3
4
5
6

protected override void OnModelCreating(ModelBuilder builder)
{
    base.OnModelCreating(builder);

    builder.Entity<CartItem>().HasKey(i => new { i.CartId, i.ItemId });
}

Finally, our database structure can be handled by EntityFramework. We can proceed with migration.

Inserting into Many-To-Many

Suppose that we already have Cart and Item in our database. Now we want to add specific item to specific cart. In order to do this we need to create new CartItem and save it.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

var cart = db.Carts.First(i => i.Id == 256);
var item = db.Items.First(i => i.Id == 1024);

// you can either associate it using ids
var cartItem = new CartItem
{
    CartId = cart.Id,
    ItemId = item.Id
};

// or by using entities
var cartItem = new CartItem
{
    Cart = cart,
    Item = item
};

db.Add(cartItem);
db.SaveChanges();

Retrieving related data in Many-To-Many

Fetching data from database is rather simple. You need to pay attention to includes in case of retrieving entities with related data. Just remember that there are a total of 3 tables involved: Cart, Item, and CartItem which links items with carts.

1
2
3
4

// get specific cart including all items
var cartIncludingItems = db.Carts.Include(cart => cart.Items).ThenInclude(row => row.Item).First(cart => cart.Id == 1);
// get all items belonging to cart
var cartItems = cartIncludingItems.Items.Select(row => row.Item);

In addition, you don’t have to do it using a relation. For instance, if you have cart id you can fetch all items at once using following Linq:

1
2

var cartId = 1;
var cartItems = db.Items.Where(item => item.Carts.Any(j => j.CartId == cartId));

Same principle applies to opposite use case, which means that you can apply above pattern to get all carts which have specific item.

Deleting from Many-To-Many

By deleting we mean removing association between cart and item. We won’t remove the cart or the item in the following examples, just the thing which holds cart and item association.

Lets start by deleting single item from cart.

1
2
3
4
5
6

var cartId = 1;
var itemId = 1;
var cartItem = db.CartsItems.First(row => row.CartId == cartId && row.ItemId == itemId);

db.Remove(cartItem);
db.SaveChanges();

Then, let me show you how to remove all items from a cart.

1
2
3
4

var cart = db.Carts.Include(c=> c.Items).First(i => i.Id == 2);

db.RemoveRange(cart.Items);
db.SaveChanges();

Enumerable.Range overview

It takes two arguments. First argument is the first number in sequence (e.g. 10, means that the first number in sequence is 10). Second argument is the number of items in sequence (e.g. 11 means that it will return 11 numbers).

It returns IEnumerable<int> which contains generated sequence. Keep in mind that each subsequent number is incremented by 1, which also means that it’s in ascending order. This however can be changed with some Linq tricks (check examples below).

Range function works only with integral numbers, but with the help of Linq we can make it work with floats.

Basic example

Lets start with basic example. We’re going to print numbers 9 to 99.

1
2
3
4
5

// print 91 numbers, 9 being the first number
foreach(var number in Enumerable.Range(9, 91))
{
    Console.WriteLine(number);
}

Reversing sequence, descending order

Linq makes reversing the sequence very easy. All you need to do is to use Reverse method. Check out following example, which prints number 10 to 1.

1
2
3
4
5
6

// generate sequence of numbers from 1 to 10
// then reverse it
foreach(var number in Enumerable.Range(1, 10).Reverse())
{
    Console.WriteLine(number);
}

Generating sequence of even (or odd) numbers only

This turns out to be pretty easy with modulo and Linq. However, there is a caveat. Code below won’t generate 100 numbers. It is because we firstly generate numbers 1 to 100 then we select only numbers which match criteria (even or odd), which basically halves amount of numbers.

1
2

var even =  Enumerable.Range(1, 100).Where(number => number % 2 == 0);
var odd =  Enumerable.Range(1, 100).Where(number => number % 2 == 1);

Negative numbers

Suppose you want to generate sequence of numbers from -1 to -10. The easiest way to do it (at least in terms of Enumerable.Range) is to generate sequence from 1 to 10 and turn each number to negative number.

1

var numbers =  Enumerable.Range(1, 10).Select(number => -number);

Increment (or decrement) by any number

Suppose that you want your sequence step to be 2 instead on 1. For example you want 1, 3, 5, 7, 9 instead of 1, 2, 3, 4, 5.

The tricks is to multiple each number by 2 and then substract 2 from it.

1

var numbers =  Enumerable.Range(1, 5).Select(number => number * 2 - 2);

If you need your numbers to alter by 3 (or any other number) then you have to replace 2 with 3.

Working with floats

Enumerable.Range doesn’t work with floats. As you’ve seen in previous use cases it generates only integer values. Unless you use Linq, but it has a drawback. It hard to read, in addition you have to think twice before you (or someone else reading your code) figure it out. With that being said, lets take a look at the example.

Following snippet generates sequence of numbers from 1 to 2 with step 0.1.

1
2
3
4

var numbers =  Enumerable.Range(10, 10).Select(number => number / 10f);
// for each number in sequence 10, 11, 12, ..., 20
// divide it by 10
// which results in sequence 1.0, 1.1, 1.2, ..., 2.0

Custom sequence generator

You’ve probably noticed that some examples are a little bit far fetched. Enumerable.Range works well for simple scenarios. However advanced use cases are hard to read and result in additional Linq overhead. Fortunately we can easily create our own custom sequence generators.

You can use following technique to rewrite every example in this post. I won’t go into details, so it’s up to you to figure it out, but let me just show you how you can rewrite the even numbers generator.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public static class Sequences
{
    public static IEnumerable<float> Even(int start, int count)
    {
        // validation skipped e.g. count should always be more than 0
        // I'll leave it as an exercise for you

        // if start is odd number then increment it
        // so the first number is always even
        if (start % 2 == 1)
        {
            start++;
        }

        int counter = 0;
        while (counter < count)
        {
            yield return start;
            counter++;
            start += 2;
        }
    }
}

// usage - get 10 even numbers starting with 2
foreach (var number in Sequences.Even(2, 10))
{
    // some action
}

If you want the answer right away, then here it is. You have to use + sign in the name of your resource file (like this: OuterClass+NestedClass.en.resx).

Localizing with resource files

Both Razor Pages and ASP.NET Core have built-in support for localization using resource files (RESX). Each resource file is basically an XML file. It contains keys (string to be localized), values (localized values) and optional comments. We access translations by using instances of IStringLocalizer (or IViewLocalizer for views) which lets us get localized strings by using indexers.

Resource files has to be named after class or view file. In addition it has to be put in directory structure which reflects namespace of localized file. Each language has to have its own RESX file, and the language code has to be a part of its file name. If you want to know more about it please refer to the official documentation located here.

Let me show you and example of how it works. We’ll start with a controller, notice the IStringLocalizer instance (_localizer)and how we can use it to access localization.

Now, take a look at the directory structure.

Nested classes

Sometimes we want to create nested classes. There are various reasons you may want to do that. Personally, I do that for view models when I want to group chunk of common data or when I want to create a list of items because it’s used only at that place.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// Example nested class
public class ListViewModel
{
    public string SomeVariable { get; set; }

    public List<ListItem> Items { get; set; }

    public class ListItem
    {
        public int Id { get; set; }

        public string Name { get; set; }
    }
}

So, how do we localize nested class in the example above? It pretty simple, we need to name RESX file in special way. Firstly, we include class name, then goes the plus sign and then goes the nested class name. That’s how reflection “sees” nested classes (outer class name, plus sign, inner class name).

Some basic points before we begin:

• Dictionary is an unordered data structure
• Dictionary maps keys to values
• Keys have to be unique
• Dictionary implements IEnumerable

Let’s start by creating a simple dictionary with some data:

1
2
3
4
5
6

// e.g. name and birth date
var people = new Dictionary<string, DateTime>
{
    { "John", new DateTime(2000, 1, 1) },
    { "Jane", new DateTime(2000, 1, 2) }
};

Looping through dictionary is simple, since it implements IEnumerable all we have to do is to use foreach loop. Each dictionary item has Key and Value property:

1
2
3
4

foreach (var person in people)
{
    Console.WriteLine($"Name: {person.Key} Birth: {person.Value}");
}

Also, remember that dictionary is unordered, which means that you cannot expect it to return values in the same order every time. So when you loop it one more time it can print values in different order.

We iterated through dictionary entries, but we can also iterate throught dictionary Keys or Values only:

1
2
3
4
5
6
7
8
9

foreach (var name in people.Keys)
{
    Console.WriteLine($"Name: {name}");
}

foreach (var birth in people.Values)
{
    Console.WriteLine($"Birth: {birth}");
}

You can use Linq to filter entries:

1
2
3
4

foreach (var person in people.Where(i => i.Value.Year >= 2000))
{
    Console.WriteLine($"Name: {person.Key} Birth: {person.Value}");
}

Or you can transform/project it to some other data structures:

1
2
3
4

foreach (var username in people.Select(i => $"{i.Key}{i.Value.Year}"))
{
    Console.WriteLine($"Username : {username}");
}

That’s it.

All 2 can be applied to all types implementing IEnumerable interface. It means that you can apply them to data retrieved from database (IQueryable), list (List/IList implements IEnumerable), arrays (which also implements IEnumerable) and others.

It’s important to know that each one of those functions return new IEnumerable. Even if we execute these methods on array (e.g. int[]) it returns enumerable (e.g. IEnumerable<int>). Note that it works a bit different for IQueryable and database operations. Since this is an introductory level post I’ll show you how to use them using array based examples.

Select()

With Select we can map/project data to new form. It means that we can use it make something with every element.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

>var numbers = new [] { 1, 2, 3, 4, 5 };

// take each number and multiply it by itself
var newNumbers = numbers.Select(number => number * number);

// take each number and put it into a string
var numberMessages = numbers.Select(number => $"I say {number}");

// take each number and put it into new class
var people = numbers.Select(number => new Person { Id = number });

Where()

We use Where when we want to filter data. So it checks every element and returns only elements which matches critera.

1
2
3
4
5
6
7
8
9

var numbers = new [] { 1, 2, 3, 4, 5 };

// take each number make sure it's an odd number
var oddNumbers = numbers.Where(number => number % 2 == 1);

var names = new [] { "Adam", "Eve" };

// take each name and find only the ones that start with and "A"
var foundNames = names.Where(name => name.StartsWith("A"));

Chaining Select and Where

Since both of these functions return IEnumerable we can chain them. Take a look at this example:

1
2
3
4
5

var names = new [] { "Adam", "Amy", "Eve" };

// take each name and find only the ones that start with and "A"
// then create an sentence with given name
var foundNames = names.Where(name => name.StartsWith("A")).Select(name => $"My name is {name}");

What are tag helpers?

Basically tag helpers are classes which take part in processing (or creating) HTML elements inside Razor views. You can create C# code which will target desired HTML and produce desired output. For more throughtout explanation see Introduction to Tag Helpers in ASP.NET Core

Setup

Before we begin, make sure that your setup is correct. If your custom tag helpers are in Solution assembly then you need to add this line to your View/_ViewImports.cshtml file:

1

@addTagHelper *, Solution

How to add a HTML class attribute to all img elements by extending ImageTagHelper.

If you use Bootstrap you may want to add img-fluid css class to images to automatically make all available images responsive.

We can achieve this by extending ImageTagHelper. Notice that we’re merging attributes, so our tag helper won’t override classes which are already present in the markup.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

[HtmlTargetElement("img", TagStructure = TagStructure.WithoutEndTag)]
    public class ResponsiveImageTagHelper : ImageTagHelper
    {
        public ResponsiveImageTagHelper(IHostingEnvironment hostingEnvironment, IMemoryCache cache, HtmlEncoder htmlEncoder, IUrlHelperFactory urlHelperFactory)
            : base(hostingEnvironment, cache, htmlEncoder, urlHelperFactory)
        {
        }

        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            base.Process(context, output);

            var img = new TagBuilder("img");
            img.Attributes.Add("class", "img-fluid");
            output.MergeAttributes(img);
        }
    }

Results:

1
2
3
4

// input
<img class="border" src="image.png" />
// output
<img class="border img-fluid" src="image.png" />

How to add required indicator to labels which refer to [Required] properties by extending LabelTagHelper.

I’ll show you a way to add “(required)” text to all labels which point to properties with Required attribute.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

[HtmlTargetElement("label", Attributes = "asp-for")]
    public class LabelRequiredTagHelper : LabelTagHelper
    {
        public LabelRequiredTagHelper(IHtmlGenerator htmlGenerator)
            : base(htmlGenerator)
        {
        }

        public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
        {
            await base.ProcessAsync(context, output);

            var metadata = For.Metadata as DefaultModelMetadata;
            bool hasRequiredAttribute = metadata
                                        ?.Attributes
                                        .PropertyAttributes
                                        .Any(i => i.GetType() == typeof(RequiredAttribute)) ?? false;
            if (hasRequiredAttribute)
            {
                output.PostContent.AppendHtml("(required)");
            }
        }
    }

Results:

1
2
3
4

// input
<label asp-for="Username"></label>
// output
<label for="Username">Username<span>(required)</span></label>

How to show number of allowed characters next to textarea by extending TextAreaTagHelper.

Textarea has maxlength attribute, we’re going to display a message which’ll print it out with additional message. Note that we should use MaxLength attribute (from DataAnnotations) to check maximum length of sent data. I’ve ommited this for brevity.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

[HtmlTargetElement("textarea", Attributes = "asp-for")]
    public class ExtendedTextareaTagHelper : TextAreaTagHelper
    {
        public ExtendedTextareaTagHelper(IHtmlGenerator generator)
            : base(generator)
        {
        }

        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            base.Process(context, output);

            if (!output.Attributes.TryGetAttribute("maxlength", out TagHelperAttribute maxLengthAttribute))
            {
                return;
            }

            var description = $"Only <b>{maxLengthAttribute.Value}</b> characters allowed!";
            output.PostElement.AppendHtml(description);
        }
    }

Results:

1
2
3
4

// input
<textarea asp-for="Description" maxlength="1024"></textarea>
// output
<textarea asp-for="Description" maxlength="1024"></textarea><p>Only <b>1024</b> characters allowed!</p>

BONUS: Did you know that you can add TagHelper to any HTML element?

One of the great things about tag helpers is that you can make it work for any existing HTML tags. I’ve show you examples of extending existing tag helpers, but you can also create new tag helpers for any element.

As an example, you could create tag helper which would create sortable links for all table header cells (something linke <th asp-for="FirstName"></th>). Another example could be printout out “Empty” inside a table with no rows.