Store user options using enumeration, bitwise operators, and EF Core

At times you need to store a set of options, settings, or choices for a user. A common approach is to create three tables - Users, Options, and UserOptions - to store the data involved. However, you can also use an alternate approach that involves enumerations, bitwise operators, and EF core value converters. To that end this article discusses such an approach with an example.

Example

Let's assume that you are developing an ASP.NET Core web application that sends notifications to the end users. There are several types of notifications supported by the application - Email, SMS, Popup, Calendar, and Private Message. The application allows a user to decide how to receive the notifications. That means a user can have one or more ways of receiving the notifications. For example, a user can opt to receive only Email notifications whereas some other user may opt for Email and SMS based notifications. You would like to capture these user notification options / settings and store them in a SQL database.

A common approach to this problem is to create three tables - Users, Options, and UserOptions. This approach is great when there is unlimited number of options and there could be any combination of users and options. However, if you have only limited number of options as in the example scenario described above, you may want to avoid Options and UserOptions tables altogether.

Another approach could be to create as many columns in the Users table as the number of notification Options and then assign True / False value to each column. However, this will lead to a lot more columns to the Users table. If you need to add a notification option in the future you will need to change database schema as well as C# code.

Yet another approach is to use C# enumerations, bitwise operators, and EF Core value converters. This approach works well when you have a small set of options that are not going to change frequently. The remainder of this article discusses this approach to accomplish the task.

Now that you have understood the example scenario and what we are trying to accomplish, let's build an application that will demonstrate what we just discussed.

Begin by creating and configuring a new ASP.NET Core web application.

Create the NotificationOptions enumeration

Now add a class named NotificationOptions in the Models folder. The NotificationOptions class holds the possible notification options and is shown below :

[Flags]
public enum NotificationOptions
{
    Email = 1,
    SMS = 2,
    Popup = 4,
    Calendar = 8,
    PrivateMessage = 16
}

Notice a couple of things about this class. Firstly, it is decorated with [Flags] attribute. The [Flags] attribute is used to indicate that the enumeration values can be used with bitwise operators such as | and &. Secondly, the enumeration values have been explicitly assigned to power of 2 (1, 2, 4, 8, 16). This is required for the proper functioning of bitwise operations.

Bitwise operations on NotificationOptions

Before we go ahead and see how to store notification options using Entity Framework Core, it's worthwhile to see how bitwise operators can be used with enumeration flags we just created.

Suppose we want to indicate that a user has two notification options - Email and SMS. This is how you can represent them in your C# code :

NotificationOptions options = 
NotificationOptions.Email | NotificationOptions.SMS;

Notice how the bitwise OR operator ( | ) is used to combine enumeration Email and SMS flags. This way you can combine as many number of flags as you want and store the result in options variable.

So far so good. But how to check whether a particular option exists in the options thus formed? This can be done using bitwise AND ( & ) operator. The following code shows how :

if((options & NotificationOptions.Email) !=0)
{
    //email option exists!
}
if ((options & NotificationOptions.SMS) != 0)
{
    //SMS option exists!
}

If we want to check whether Email notification is part of the selected options, we use & operator and figure that out. Similarly you can check for other notification options.

There is an alternate way to the above task. Instead of using the bitwise AND operator you can use HasFlag() method of an enumeration as follows :

if(options.HasFlag(NotificationOptions.Email))
{
    //email option exists!
}
if (options.HasFlag(NotificationOptions.SMS))
{
    //SMS option exists!
}

The HasFlag() method returns true if a flag is a part of the value being tested, otherwise it returns false.

Convert enumeration values to integers in EF Core

The above code works with NotificationOptions enumeration. This is quite alright in your C# code. But how would you save these enumeration values to the database? Luckily, Entity Framework Core provides an easy way to convert enumeration values to numbers (or strings) so that they can be easily stored to a database. This conversion needs to be enabled for the required entities. Let's see how.

Consider the following entity class named UserNotifications :

public class UserNotifications
{
    public int Id { get; set; }
    public string Name { get; set; }
    public NotificationOptions Options { get; set; }
}

The UserNotifications class stores all the notification options for a user and has three properties namely Id, Name, and Options. The Options property is assigned using the bitwise OR operation as discussed earlier and can have one or more notification options.

The following figure shows the schema of UserNotifications table from a SQL Server database.

As you can see the Options column is an integer column. That means you will need to convert to and from NotificationOptions to integer. Although by default EF Core does that correctly in most of the cases, it's good to ensure that appropriate values are being transferred from our C# code also. This is accomplished using what is known as Value Converter.

The following code shows the AppDbContext that makes use of EnumToNumberConverter inbuilt value converter.

public class AppDbContext : DbContext
{
    protected override void OnConfiguring
(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(
"data source=.;initial catalog=MyDatabase;integrated 
security=true");
    }

    protected override void OnModelCreating
(ModelBuilder modelBuilder)
    {
        EnumToNumberConverter<NotificationOptions,int> 
converter = new EnumToNumberConverter<NotificationOptions,int>();

        modelBuilder.Entity<UserNotifications>()
                    .Property(e => e.Options)
                    .HasConversion(converter);
    }

    public DbSet<UserNotifications> 
UserNotifications { get; set; }
}

Notice a few things about the AppDbContext class.

It sets the database connection string in the OnConfiguring() overridden method. You can also pick this value from a configuration file. More interesting is the OnModelCreating() overridden method.

Inside, we create an instance of EnumToNumberConverter class. The EnumToNumberConverter converts an enumeration value to a number and vice a versa. In this case we want to convert between NotificationOptions and an integer and hence we pass the generic types as shown above.

The code then uses HasConversion() method and passes the EnumToNumberConverter object to it. This way EF Core knows how to convert the values assigned to the Options property.

Ok. Now we have all the pieces ready - NotificationOptions enumeration, UserNotifications table, UserNotifications entity class, and AppDbContext class.

Save notification options to the database

Let's write some code that will add a few records to the UserNotifications table. The following code from Index() action shows how that can be done :

using (AppDbContext db = new AppDbContext())
{
    UserNotifications user1 = new UserNotifications();
    user1.Name = "Nancy Davolio";
    user1.Options = NotificationOptions.Email | 
NotificationOptions.SMS;

    UserNotifications user2 = new UserNotifications();
    user2.Name = "Andrew Fuller";
    user2.Options = NotificationOptions.Popup | 
NotificationOptions.SMS | NotificationOptions.Calendar;

    UserNotifications user3 = new UserNotifications();
    user3.Name = "Janet Leverling";
    user3.Options = NotificationOptions.Email;

    db.UserNotifications.Add(user1);
    db.UserNotifications.Add(user2);
    db.UserNotifications.Add(user3);
    db.SaveChanges();
}

The above code creates three UserNotifications entities and assigns their Name and Options properties. Notice how multiple notification options have been assigned using the OR operator as discussed earlier. The Add() method adds these entities to the UserNotifications DbSet and SaveChanges() saves them to the UserNotifications table.

Retrieve notification options from the database

Now let's read the saved data and conform the working of enumerations and bitwise AND operator.

Add a new view model class to the Models folder named UserNotificationSummary.

public class UserNotificationSummary
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool Email { get; set; }
    public bool SMS { get; set; }
    public bool Popup { get; set; }
    public bool Calendar { get; set; }
    public bool PrivateMessage { get; set; }
}

The UserNotificationSummary class is intended to hold all the notification options for a user in Boolean properties.

Now add the following loop below the SaveChanges() call we wrote earlier :

List<UserNotifications> data = 
db.UserNotifications.ToList();

List<UserNotificationSummary> model = 
new List<UserNotificationSummary>();

foreach(var item in data)
{
    UserNotificationSummary summary = 
new UserNotificationSummary();

    summary.Id = item.Id;
    summary.Name = item.Name;
    if((item.Options & NotificationOptions.Email) !=0)
    {
        summary.Email = true;
    }
    if ((item.Options & NotificationOptions.SMS) != 0)
    {
        summary.SMS = true;
    }
    if ((item.Options & NotificationOptions.Popup) != 0)
    {
        summary.Popup = true;
    }
    if ((item.Options & NotificationOptions.Calendar) != 0)
    {
        summary.Calendar = true;
    }
    if ((item.Options & NotificationOptions.PrivateMessage) != 0)
    {
        summary.PrivateMessage = true;
    }
    model.Add(summary);
}

return View(model);

The code retrieves all the records from the UserNotifications table. It also creates an empty List of UserNotificationSummary to hold  the resultant data. A foreach iterates through the data and checks the notification options for a user. This is done using a series of If statements that assign the Boolean view model properties as per the outcome. The List of UserNotificationSummary is then passed to the Index view.

The Index view simply outputs the model data as shown below :

@model List<UserNotificationSummary>


<h1>Summary</h1>

<table border="1" cellpadding="10">
    <tr>
        <th>Id</th>
        <th>Name</th>
        <th>Email</th>
        <th>SMS</th>
        <th>Popup</th>
        <th>Calendar</th>
        <th>Private Message</th>
    </tr>
    @foreach (var item in Model)
    {
        <tr>
            <td>@item.Id</td>
            <td>@item.Name</td>
            <td>@item.Email</td>
            <td>@item.SMS</td>
            <td>@item.Popup</td>
            <td>@item.Calendar</td>
            <td>@item.PrivateMessage</td>
        </tr>
    }
</table>

The following figure shows a sample run of the application :

That's it for now! Keep coding!!