DEV Community: Carl Layton

6 Options to Implement Auto-Implemented Properties

Carl Layton — Thu, 22 Feb 2024 11:14:11 +0000

Introduction

In this post, I show 6 ways to implement auto-implemented properties in C#. An auto-implemented property is a short-hand way to declare a property when there is no logic required in the accessors and it doesn't require a backing field.

Auto-Implemented Properties

A traditional property with a backing field looks like this.

private string _name; // field
public string Name // property
{
   get { return _name; }
   set { _name = value; }
}

This property doesn't require any logic in the get or set accessor. The first way to shorten it is to make it an auto-implemented property like this

public string Name { get; set; }

This is probably the most common way to declare auto-implemented properties in C# but it has it's drawbacks. It is mutable because the value can be set from anywhere and no default value means it could be null when an instance is created.

A second way to declare the auto-implemented property is to assign a default value. This is still mutable but will have a value if not set when an object is instantiated.

public string Name { get; set; } = string.Empty;

Another way to declare the auto-implemented property is to change the access level of set to private set so it can only be updated from the object's constructor.

public string Name { get; private set; }

The example above requires the object to have a constructor to provide a value. A similar option is available but allows the value to be set when the object is initialized.

// Set only allowed during object initialization
public string Name { get; init; }

// Instantiate an object
public class Person
{
    public string Name { get; init; }
}

public static void main(strings[] args)
{
    var person = new Person()
    {
        Name = "Test Name" // Name can only be set here.
    }
    p.Name = "Updated Name"; // Compilation error because Name cannot be changed outside of the object initializer.
}

This can also be expanded to include a default value as well

public string Name { get; init; } = string.Empty;

Finally, if the property is required but a default value doesn't make sense, the required keyword can be added. This would produce a compilation error if an object is initialized without the property being set to a value.

// Set only allowed during object initialization
public required string Name { get; init; }

// Instantiate an object
public class Person
{
    public required string Name { get; init; }
}

public static void main(strings[] args)
{
    var person = new Person(); // Compilation error because `Name` is not set to a value

    // Valid
    var person = new Person()
    {
        Name = "Test Name" // Name must have a value and can only be set here.
    }
}

Conclusion

In conclusion, there are many ways to set auto-implemented properties. Each one has it's benefits and drawbacks depending on the purpose of the class and how it is used. I find the varying options useful when I want values to be immutable, required, or to avoid null values.

Named Entity Recognition Using Azure AI

Carl Layton — Sun, 10 Dec 2023 06:00:00 +0000

This post is part of the 2023 C# Advent Calendar. Please check out the other great posts as well!

In this post, I explain what Named Entity Recognition (NER) is and how to leverage Azure AI to integrate NER into a .NET application using C# and the Azure SDK.

Named Entity Recognition, commonly abbreviated (NER), is the ability to extract entities from unstructured text. Entities include people, locations, organizations, dates, and more. These are referred to as entity types and different NER implementations support varying entity types. Some applied uses of NER include search engines and chatbots. It is a subtask of Natural Language Processing (NLP).

NLP is a field of computer science with the goal of processing and understanding human language. While the field can be traced back to the 1950s, recent advancements in NLP and AI have made the field more accessible than it has ever been before. This includes text classification, information, extraction, and question / answer systems to name a few. NER is a task of information extraction. The diagram below puts NER in context.

Azure AI Language

Azure AI Language is a cloud service that provides NLP features for analyzing text. This includes NER. There is a free tier available. Microsoft docs has a full overview of Azure Language.

Demo Application

I created a command line application to show Azure Language in action. The full source code is available on GitHub.

The app has 2 actions available as command line arguments. The first is -i followed by the text to extract entities from. The second is -f followed by the path to a file. If -f is used, the app will read the text from the file and extract the entities found in the file. This is good for longer text and the file must be a text file. The entities found are displayed to the user.

Here is an example using -i.

.\AzLangExample.CLI.exe -i "Santa Clause visits on December 25th"

Type                   Text                                 Score
Person                 Santa Clause                         0.97
DateTime               December 25th                        1.00

The Code

Now that you have seen an example, lets see how it extracts the entities. The Azure Text Analytics SDK works like other Azure SDKs. First a TextAnalyticsClient is instantiated with an endpoint and credentials. Then RecognizeEntitiesBatchAsync is called and returns a collection named RecognizedEntitiesResultCollection. This object is the result of the API call and contains a collection of CategorizedEntity objects that have the properties displayed in the app as well as additional properties. The full documentation of this class is available here. Below is the complete method to get entities. There is a limit on the amount of text that can be sent in one request so it also breaks it up into chunks.

public async Task<List<Entity>> GetEntities(string content)
{
    var credentials = new AzureKeyCredential(Settings.Instance.AzLanguageServicesKey);
    var endpoint = new Uri(Settings.Instance.AzLanguageEndpoint);

    var client = new TextAnalyticsClient(endpoint, credentials);

    var contentParts = SplitStringByLength(content, 5000);
    var response = await client.RecognizeEntitiesBatchAsync(contentParts);
    var collection = response.Value;
    var result = new List<Entity>();
    foreach (var docResponse in response.Value)
    {
        foreach (var entity in docResponse.Entities)
        {
            result.Add(new Entity()
            {
                Text = entity.Text,
                Type = entity.Category.ToString(),
                Score = entity.ConfidenceScore,
                Start = entity.Offset,
                Length = entity.Length,
            });
        }
    }

    return result;
}

Config file

Credentials are required for accessing the language service. The repository contains a config file with placeholders for real credentials. Credentials can be added to this file and the file can be renamed to config.json and then the sample app will work with any azure language service!

Conclusion

In conclusion, NER is a task of NLP, which is a big field with a lot of applications across many business domains. Cloud services have made NER more accessible than it has ever been. This post showed one example using the AI services available in Azure. There are other cloud and on-premises solutions as well.

Unit Testing Azure Functions With EF

Carl Layton — Sat, 24 Jun 2023 12:00:00 +0000

Introduction

In this post I demonstrate how to create and unit test an Azure function app that uses Entity Framework. I only debug the function app running on the local machine and never publish it to Azure, so no Azure subscription is required. This example uses Visual Studio 2022, .NET 6, Entity Framework 6.0.x, NUnit 3.x, localdb, and the azure functions tools with Visual Studio. The full example is available in GitHub.

Setup projects

There are 3 projects, the azure function, the data project that contains the data context and Entity Framework dependencies, and the unit test project. First, I'm going to create a shell of each project and then go into detail of each in the following sections. All 3 projects use .NET 6. To create the Azure Function project, open Visual Studio 2022 and search for the Azure Function template. If you don't see it in the list, you may need to install the Azure development features of Visual Studio.

Select next, give it a name, select create. I named mine AzFuncUnitTestWithEf. Choose Http Trigger and click create again. After the Azure function app is created, it is time to create the class library project for the data context. Right click on the solution and choose Add / New Project. Choose class library for the type and click Next. I named mine AzFuncUnitTestWithEf.DataContext but you can name it whatever you prefer.

Finally, create the unit test project. I'm using NUnit, which has a template in Visual Studio 2022. I'm not sure if there are additional dependencies required for the template to be available. Right click on the solution and, once again, choose Add / New Project, search for nunit, and select NUnit Test Project from the list of templates.

Now that all projects are added, ensure the solution builds. In the next section, I'll go over creating the data context with Entity Framework and localdb.

Entity Framework Setup

In this section, I'll detail adding the required NuGet dependencies for Entity Framework, and creating the model and data context. I do not cover a migration to create a real database because we're not using a real database in this example. For more information on EF migrations, visit this Microsoft doc.

The first step is to add the required NuGet dependencies. These are all installed to the AzFuncUnitTestWithEf.DataContext project. Open Tools / NuGet Package Manager / Managed NuGet Packages for Solution. Below is a table of the Entity Framework NuGet packages and which version to install.

NuGet Package	Version
Microsoft.EntityFrameworkCore	6.0.4
Microsoft.EntityFrameworkCore.SqlServer	6.0.4

Next I'll create the model class and data context. This app uses a simple model class named book. The Book.cs file is below

public class Book
{
    [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }

    [Column(TypeName = "nvarchar(512)")]
    public string Title { get; set; }

    [Column(TypeName = "nvarchar(512)")]
    public string Author { get; set; }

    public DateTime PublishedDate { get; set; }
}

Create another class for the data context named BookDataContext.cs. This inherits from Entity Framework DbContext and contains a DbSet for Books.

public class BookDataContext : DbContext
{
    public DbSet<Book> Books { get; set; }

    public BookDataContext(DbContextOptions<BookDataContext> options) : base(options)
    {
        if (options == null)
        {
            throw new ArgumentNullException(nameof(options));
        }
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            optionsBuilder.UseSqlServer(
                @"Server=(localdb)\mssqllocaldb;Database=book_db;Trusted_Connection=True;ConnectRetryCount=0");
        }
    }
}

At this point, build the project again to make sure the db model and context are correct. In the next section, I'll go over setting up the azure function start up class and using the data context in the azure function.

Add Function App StartUp

To use the data context in the Azure function, I'm going to inject it as a dependency. Like an ASP .NET core web app, an azure function can have a StartUp class that inherits from FunctionsStartup to configure services. Browse to Tools / NuGet Package Manager / Manage NuGet Packages for Solution. Install the NuGet packages below to the function app project to use the function startup class.

NuGet Package	Version
Microsoft.Azure.Functions.Extensions	1.1.0

There is 1 method to implement, void Configure(IFunctionsHostBuilder builder).We're adding 1 service and that is a DbContext for the BookDataContext. The StartUp class is below.

public class StartUp : FunctionsStartup
{
    public override void Configure(IFunctionsHostBuilder builder)
    {
        var services = builder.Services;
        var configuration = builder.GetContext().Configuration;

        services.AddDbContext<BookDataContext>(options => options.UseSqlServer(configuration["DbConnection"]));
    }
}

Next, a FunctionStartupAttribute needs to be assigned in the StartUp class. Do this by adding this line above the namespace declaration: [assembly: FunctionsStartup(typeof(StartUp))]. We also need a database connection to configure the DB Context. This is referenced in the code above. I'm using local db and added a setting to the local.settings.json config file of "DbConnection": "Server=(localdb)\\mssqllocaldb;Database=book_db;Trusted_Connection=True;MultipleActiveResultSets=true". We don't actually use this configuration in this demo but in a real project this would be the sql server connection string. The next step is to implement the function to actually do some work and I'll show that in the next section.

Azure Function Implementation

The next step is to implement the azure function to accept requests and save those requests to our database. Since we configured the BookDataContext as part of the services of the azure function, it can be injected into the azure function constructor through dependency injection. Add a private field and constructor to the azure function. Also, make the azure function class and Run method not static.

private readonly BookDataContext _bookDataContext;

public Function1(BookDataContext ctx)
{
     _bookDataContext = ctx;
}

We can now reference _bookDataContext in the function run method. The function is an HTTP triggered function that accepts POST requests. The POST request contains Book information that is mapped from an input model to a database model and saved through the db context.

[FunctionName("Function1")]
public async Task<IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req, ILogger log, ExecutionContext executionContext)
{
    try
    {
        log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");

        var book = await ParseInput(req);

        _bookDataContext.Add(Map(book));

        await _bookDataContext.SaveChangesAsync();

        return new NoContentResult();
    }
    catch (Exception ex)
    {
        log.LogError(ex.Message);
        return new InternalServerErrorResult();
    }
}

The following code is the Parse and Map private helper methods to round out the function class.

private async Task<BookInput> ParseInput(HttpRequest req)
{
    string requestBody = String.Empty;
    using (StreamReader streamReader = new StreamReader(req.Body))
    {
        requestBody = await streamReader.ReadToEndAsync();
    }

    return System.Text.Json.JsonSerializer.Deserialize<BookInput>(requestBody);
}

private Book Map(BookInput b)
{
    return new Book { Title = b.Title, Author = b.Author, PublishedDate = b.PublishedDate };
}

The request is deserialized to a BookInput type. That class is below.

public class BookInput
{
    public string Title { get; set; }
    public string Author { get; set; }  
    public DateTime PublishedDate { get; set; } 
}

That completes the azure function project. Finally, we're ready to setup a unit test that uses an in-memory DB Context and calls the Run method.

Unit Test Implementation

The last step is to implement tests in the NUnit project that was created earlier. We'll first add a couple NuGet packages. Browse to Tools / NuGet Package Manager / Manage NuGet Packages for Solution. The table below lists the NuGet packages required for the test project.

NuGet Package	Version
Microsoft.EntityFrameworkCore.InMemory	6.0.5
Moq	4.18.1

Once the packages are installed, create a new file named FunctionTests.cs that will contain our test. We're going to use an in-memory database with Entity Framework for our unit test. This exists for the lifetime that the tests are running. This allows tests to run against Entity Framework without a real database. A static instance of InMemoryDatabaseRoot is created for the database and a private field is used in the test class for BookDataContext.

private static InMemoryDatabaseRoot _root = new InMemoryDatabaseRoot();
private BookDataContext _bookContext;

There is a OneTimeSetup method that is called once prior to all tests running that builds the in-memory database. This is done using a DbContextOptionsBuilder instance, like building any other database. The UseInMemoryDatabase extension method tells it to use an in-memory database. Finally, set the _bookDataContext field to a new BookDataContext using the db builder options. The one time setup method is below.

[OneTimeSetUp]
public void OneTimeSetup()
{
    var dbBuilder = new DbContextOptionsBuilder<BookDataContext>();
    dbBuilder.UseInMemoryDatabase(databaseName: "Book", _root);
    _bookContext = new BookDataContext(dbBuilder.Options);
}

There is also a setup method that resets the database before each test run.

[SetUp]
public void Setup()
{
    // Make sure database is empty when starting
    _bookContext.Database.EnsureDeleted();
    _bookContext.Database.EnsureCreated();
}

Now lets write a test that uses it. We'll write one test that calls the function's Run method and then verify that it wrote to the in-memory database. First, I'll explain all of the code and then list the full method. The test follows the Arrange, Act, Assert pattern. The arrange section creates the dependencies required for the function run method. This includes a Logger, an executionContext, and test request data.

The next step is to act by instantiating the Function class and passing the local _bookContext data context to the constructor. Next call the Run method passing in the local variables for the required parameters. This will execute the full Run method of the function.

Finally, we'll assert the results. This is done by querying the in-memory database for the test Book that was just inserted by the function. Assert the book returned equals the test book data that was passed in the request. If everything checks out, we know the function inserted the book correctly into the database. The full code of the test method is below.

[Test]
public async Task ReturnsSuccess()
{
    // Arrange
    // Arrange function dependencies
    var loggerFactory = new LoggerFactory();
    var logger = loggerFactory.CreateLogger("DebugLogger");
    var executionContext = new Microsoft.Azure.WebJobs.ExecutionContext();
    var id = Guid.NewGuid();
    executionContext.InvocationId = id;
    // Arrange request data
    string input = "{\"Title\": \"Test Title\", \"Author\": \"Test Author\", \"PublishedDate\": \"2022-04-08T14:47:46Z\"}";
    using (var requestStream = new MemoryStream())
    {
        requestStream.Write(Encoding.ASCII.GetBytes(input));
        requestStream.Flush();
        requestStream.Position = 0;

        var requestMock = new Mock<HttpRequest>();
        requestMock.Setup(x => x.Body).Returns(requestStream);

        // Act
        Function1 sut = new Function1(_bookContext);
        var result = await sut.Run(requestMock.Object, logger, executionContext);

        Book resultData = await _bookContext.Books.FirstOrDefaultAsync(b => b.Title == "Test Title");

        //Assert
        Assert.AreEqual(typeof(NoContentResult), result.GetType());
        Assert.IsNotNull(resultData);
    }
}

Conclusion

In conclusion, this post demonstrates how to unit test an azure function that uses entity framework with nUnit and an in-memory EF database. The key is the data context that connects to a database is injected as a dependency so different variations can be used. This allows the test to call the complete Run method and verify the results against an in-memory database, while the production code would inject a _bookContext connected to a live database.

Use Dropbox for Persistent Storage with an Angular Application

Carl Layton — Fri, 06 Mar 2020 09:50:06 +0000

In this post, I show an example of using Dropbox with an Angular application. I'll show how to authenticate to Dropbox with Angular and how to read and write files to Dropbox. This can be used to add persistent storage to the application without needing a custom backend service or API. First, I'll go over the functionality of the app, then show how to create the Angular piece. Finally, I'll detail how to add Dropbox integration. This post requires the Angular CLI and some familiarity with Angular but you don't need to be an expert. NodeJs and NPM are also required. You must also have a Dropbox account. The free version works. The complete example is available on GitHub.

Application overview

We're going to create an application that allows the user to manage a list of books and use Dropbox for storage. The application performs create, read, and delete operations. It's an angular application with no routing to keep it simple. The top of the page contains a form for entering new Books.

The bottom part of the page displays the list of books with a button to remove a book from the list.

Create the Angular Application

We're going to use the Angular CLI to create a new application. If you don't have it installed, click here to download it. Once installed, from a terminal / command line / powershell run ng new to create a new app. The CLI will prompt for a name, I called it 'angular-dropbox' and ask if you would like to include routing. Routing is not required for this project so answer 'N'. Finally, it asks which stylesheet format you want to use, pick CSS (the default). Next run ng serve to verify the basic Angular application is working out of the box.

To keep this application simple and the focus on Dropbox integration, I added everything to the main app component. First, add a couple lines to app.component.css to format the table to display books.

    table, th, td {
        border: 1px solid black;
    }

Next, we're going to create a regular typescript class to hold the Book data named book.entity.ts.

    export class BookEntity {
        public Title: string;
        public Author: string;
        public Length: number | null;
        public PublishedDate: Date | null;

        public Reset(): void {
            this.Title = "";
            this.Author = "";
            this.Length = null;
            this.PublishedDate = null;
        }
    }

Now it's time to setup the html template. Remove everything from app.component.html and replace it with the template below.This has the form at the top of the page, binding data to the newBook object in the typescript file, which we'll define later. It also loops through a list of books to display in the table.

    <label for="title">Title: </label><input id="title" type="text" [(ngModel)]="newBook.Title" />
    <br /><br />
    <label for="Author">Author: </label><input id="author" type="text" [(ngModel)]="newBook.Author" />
    <br /><br />
    <label for="length">Length (In Pages): </label><input id="length" type="number" min="0" [(ngModel)]="newBook.Length" />
    <br /><br />
    <label for="published">Date Published: </label><input id="published" type="date" [(ngModel)]="newBook.PublishedDate" />
    <br /><br />
    <button (click)="addBook()">Add Book</button>

    <h1>Books</h1>
      <table>
    <thead>
      <tr>
        <th>Title</th>
        <th>Author</th>
        <th>Length (In Pages)</th>
        <th>Publish Date</th>
        <th>Delete</th>
      </tr>
    </thead>
    <tbody>
      <tr *ngFor="let book of Books; let i = index">
        <td>{{book.Title}}</td>
        <td>{{book.Author}}</td>
        <td>{{book.Length}}</td>
        <td>{{book.PublishedDate}}</td>
        <td><button (click)="removeBook(i)">X</button></td>
      </tr>
    </tbody>
    </table>

Since our application binds data using a form, we need to import the FormsModule in app.module.ts. The file looks like this after it's added.

    import { BrowserModule } from '@angular/platform-browser';
    import { NgModule } from '@angular/core';
    import { FormsModule }   from '@angular/forms';

    import { AppComponent } from './app.component';

    @NgModule({
      declarations: [
        AppComponent
      ],
      imports: [
        BrowserModule,
        FormsModule
      ],
      providers: [],
      bootstrap: [AppComponent]
    })
    export class AppModule { }

Finally, we need to modify the app.component.ts file. There is a BookEntity object to store the new book being added and an array of BookEntity objects to keep track of the list to display. There are functions to add and remove a book. The Books property is static with a getter function and that is so we can populate it later when we add Dropbox integration. ngOnInit() will be used at that time also.

    import { Component, OnInit } from '@angular/core';

    import { BookEntity } from './book.entity';

    @Component({
      selector: 'app-root',
      templateUrl: './app.component.html',
      styleUrls: ['./app.component.css']
    })

    export class AppComponent implements OnInit {
      newBook: BookEntity;
      static books: BookEntity[];

      constructor() {
        this.newBook = new BookEntity;
        AppComponent.books = [];
      }

      ngOnInit() {
        // Load dropbox data here...
      }

      get Books():BookEntity[] {
        return AppComponent.books;
      }

      public addBook() {
        let b: BookEntity = new BookEntity;
        b.Title = this.newBook.Title
        b.Author = this.newBook.Author;
        b.Length = this.newBook.Length;
        b.PublishedDate = this.newBook.PublishedDate;
        AppComponent.books.push(b);

        this.newBook.Reset();
      }

      public removeBook(i) {
         AppComponent.books.splice(i, 1);

      }
    }

At this point, we have a working angular application that allows us to add and remove books. Run ng serve to test it. Next, we'll add Dropbox to persist the list of books.

Dropbox Integration

The first step is to add our application to Dropbox. Login to Dropbox and go to the Dropbox App Console. Click Create app in the upper right corner. Under step 1 choose "dropbox API", step 2 choose the first option, App folder– Access to a single folder created specifically for your app. This means the application only has access to a specific folder in Dropbox, not all of Dropbox. This works better for our app because it allows us to store all the app data in 1 place and is more secure because our app can't access all of the user's files in Dropbox. Finally, give the app a name.

Once the app is created, we need to configure the OAuth2 settings to allow us to connect from the Dropbox Javascript API. Enter a redirect url to localhost and make sure the port matches the port the angular application is running on. By default, the Angular CLI uses port 4200. Also, make sure "Allow implicit grant" is set to "Allow". Below are some sample settings.

The second step is to get the Dropbox Javascript SDK and include it in the project. I made a local copy of it from the Dropbox Javascript SDK examples on GitHub. It's also included in the GitHub repo for this project. You need to add it to the build scripts in the angular.json file.

    "build": {
              "builder": "@angular-devkit/build-angular:browser",
              "options": {
                "outputPath": "dist/angular-dropbox",
                "index": "src/index.html",
                "main": "src/main.ts",
                "polyfills": "src/polyfills.ts",
                "tsConfig": "src/tsconfig.app.json",
                "assets": [
                  "src/favicon.ico",
                  "src/assets"
                ],
                "styles": [
                  "src/styles.css"
                ],
                "scripts": [
                  "src/Dropbox-sdk.min.js"
                ],
                "es5BrowserSupport": true
              }

Stop and restart ng serve. To test if the SDK was loaded, open the developer tools in the browser and type Dropbox in the console. If a function is returned, the Dropbox Javascript SDK has been loaded. If undefined is returned, Angular is not including the Dropbox SDK in the build / serve.

Next, we're going to add the ability to authenticate to Dropbox. This requires adding a link to login to Dropbox and then be returned to the app with an authentication token returned in the query string. This authentication token let's us make API requests to Dropbox. If this were a server-side app, we could store this authentication token for future use but since this application is entirely client-side, I'm only storing the token in memory in a local variable in the app component. This means the user needs to re-authenticate to Dropbox each time they navigate to the app. If the application had multiple components we could store this token in an Angular service when the app is initialized to share it across components. Since this app is entirely client-side in the browser, this is the most secure way to manage the authentication token.

There are a couple utility functions I took from the Dropbox examples on GitHub that parses the auth token out of the query string. These are in Javascript in the examples so I converted them to typescript so I can import them into the app.component.ts file. I added them to a file called utils.ts which is shown below.

    /* This functions below are from the Dropbox SDK examples to retreive the auth token from the query string */
    export class Utils {

        private static parseQueryString(str: string): Object {
            var ret: {[k: string]: string[] | string} = Object.create(null);

            if (typeof str !== 'string') {
              return ret;
            }

            str = str.trim().replace(/^(\?|#|&)/, '');

            if (!str) {
              return ret;
            }

            str.split('&').forEach(function (param) {
              var parts = param.replace(/\+/g, ' ').split('=');
              // Firefox (pre 40) decodes `%3D` to `=`
              // https://github.com/sindresorhus/query-string/pull/37
              var key = parts.shift();
              var val = parts.length > 0 ? parts.join('=') : undefined;

              key = decodeURIComponent(key);

              // missing `=` should be `null`:
              // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
              val = val === undefined ? null : decodeURIComponent(val);

              var retVal = ret[key];
              if (ret[key] === undefined) {
                ret[key] = val;
              } else if (Array.isArray(retVal)) {
                retVal.push(val);
              } else {
                ret[key] = [<string> ret[key], val];
              }
            });

            return ret;
          }

    // Parses the url and gets the access token if it is in the urls hash
    public static getAccessTokenFromUrl(): string {
        return <string> Utils.parseQueryString(window.location.hash)['access_token'];
      }
    }

In app.component.html add the following to the top of the template. This adds a link to connect to Dropbox if we're not currently connected, or displays "Conncted to dropbox" if we are connected. I also included an optional "Loading..." text that will display while we retrieve existing books from Dropbox.

    <a href="{{authUrl}}" [hidden]="isAuthenticated">Connect to Dropbox</a>
    <p [hidden]="!isAuthenticated">Connected to dropbox</p>
    <p [hidden]="!IsLoading">Loading...</p>

When the application loads, we use the functions we added to utils.ts to pull the auth token out of the query string, if it exists. If it does exist, we assume we're connected to Dropbox. To do this, import utils into app.component.ts by adding this line to the top of the file. import { Utils } from './utils';. Directly under the import statements, add declare var Dropbox: any; to use the global Dropbox object from the Dropbox Javascript SDK.

Then add the following local variables to app.component.ts.

    CLIENT_ID: string = // App key from Dropbox;
    FILE_NAME: string = "/BookList.txt"; // Or whatever you want the file to be named where the data is stored
    authUrl: string;
    dropboxToken: string
    isAuthenticated: boolean
    static isLoading: boolean;

This is what the new constructor looks like. We initialize our new variables and use the Dropbox API to setup the authentication url. Then we try to pull an existing auth token out of the url to see if we're currently authenticated or not.

    constructor() {
        this.isAuthenticated = false;
        this.newBook = new BookEntity;
        AppComponent.books = [];
        AppComponent.isLoading = false;

        var dbx = new Dropbox({ clientId: this.CLIENT_ID });
        this.authUrl = dbx.getAuthenticationUrl('http://localhost:4200/auth');

        this.dropboxToken = Utils.getAccessTokenFromUrl();
        this.isAuthenticated = this.dropboxToken !== undefined;
      }

The next step is to preload the book list if there is an auth token available when the application loads. We do this in the ngOnInit() function. We store the books data as JSON in the text file in Dropbox. This uses the Dropbox API to download the file and then parse the JSON contents into the books array. There is a slight delay while this happens so I use the AppComponent.isLoading flag as a simple way to notify the user that the books are loading. I made it static because it needs to be accessed from within the inner scope of the file reader callback and the outer scope of the component, similar to the AppComponent.books property. They also need to be available to the template so there are getters to make them available as instance variables. Below is the full code for the ngOnInit function and the AppComponent.isLoading() getter function.

     ngOnInit() {
        if (this.dropboxToken !== undefined) {
        var dbx = new Dropbox({ accessToken: this.dropboxToken });
        AppComponent.isLoading = true;
        dbx.filesDownload({path:  this.FILE_NAME}).then(function(response) {
        let reader = new FileReader();
        let blob: Blob = response.fileBlob;
                        reader.addEventListener("loadend", function(e) {
                AppComponent.books = JSON.parse(<string>reader.result);
                AppComponent.isLoading = false;
              });
             reader.readAsText(blob);
        })
        .catch(function(error: any) {
          AppComponent.isLoading = false;
        });
      }
     }

      get IsLoading():boolean {
        return AppComponent.isLoading;
      }

The final step is to add a function to convert the AppComponent.books list into JSON text, add it to the file and send the file to Dropbox. When a new book is added or removed, I create the entire JSON string for the whole updated book list and add it to the file. The function for that is below.

    private saveToDropbox() {
        var dbx = new Dropbox({ accessToken: this.dropboxToken });
        dbx.filesUpload({contents:JSON.stringify(AppComponent.books), path: this.FILE_NAME, mode: {".tag": 'overwrite'}, autorename: false, mute: true }).then(function(response) {
        }).catch(function(error) {
          // If it errors because of a dropbox problem, reload the page so the user can re-connect to dropbox   
          alert("Failed to save to dropbox");
          console.log(JSON.stringify(error));
          window.location.href = '/';
        });
      }

The only thing left is to call this function at the end of addBook() and removeBook() to save the new book list to Dropbox.

Conclusion

If you made it this far, you should have an Angular application that persists it's data to Dropbox. Congratulations! Over this journey, we created an Angular application to add and remove books from a list and persist that list of books to Dropbox. We configured our app to connect to Dropbox using OAuth authentication. We manage the auth token in a completely client-side way and use the Dropbox API to read and write a file to Dropbox. The complete example is also available on GitHub.

Example of the Strategy Pattern

Carl Layton — Sun, 23 Feb 2020 13:18:51 +0000

In this post I explain the strategy design pattern and show an example of applying it to import data from different data sources. The strategy pattern is a behavioral design pattern that allows different implementations to be used interchangeably at runtime. An application can select the appropriate method to perform a task.

The example application lets the user import music data from a csv file source or json file source. Depending on the file type, the import strategy is chosen. The example application is part of my design patterns repository on GitHub. It requires Visual Studio 2019 and dotnet core 3.1.

Implementing the Pattern

To implement the strategy pattern we need an interface, a couple of implementations of that interface, a data object to store the imported data and a simple user interface. The object to store the imported album data is called Album and the code is below.

public class Album
{
    public string Artist { get; set; }
    public string Title { get; set; }
    public int NumberOfTracks { get; set; }
    public int ReleaseYear { get; set; }
}

The interface contains one method to import a collection of albums.

public interface IImportStrategy
{
    IEnumerable<Album> ImportAlbums(string filePath);
}

There are two implementations of the interface. One for csv formatted files and one for json formatted files. Both are below.

public class CsvStrategy : IImportStrategy
{
    public IEnumerable<Album> ImportAlbums(string filePath)
    {
        string[] lines = File.ReadAllLines(filePath);
        List<Album> result = new List<Album>();
        for (int i = 1; i < lines.Length; i++)
        {
            string l = lines[i];
            string[] parsedLine = l.Split(',');
            result.Add(new Album
            {
                Artist = parsedLine[0],
                Title = parsedLine[1],
                ReleaseYear = int.Parse(parsedLine[2]),
                NumberOfTracks = int.Parse(parsedLine[3])
            });
        }

        return result;
    }
}

public class JsonStrategy : IImportStrategy
{
    public IEnumerable<Album> ImportAlbums(string filePath)
    {
        JsonSerializerOptions options = new JsonSerializerOptions()
        {
            PropertyNameCaseInsensitive = true
        };
        string content = File.ReadAllText(filePath);
        List<Album> result = JsonSerializer.Deserialize<List<Album>>(content, options);
        return result;
    }
}

The code above is the basis of the pattern, an interface that defines a method and multiple implementations of that method. The calling code can decide which strategy it needs to use and isn't tied to one specific implementation. We're also going to create a separate class whose task it is to pick which strategy to use. This is a static class called ImportStrategyPicker. It contains one method that takes the fileType and returns the correct IImportStrategy implementation.

public static class ImportStrategyPicker
{
    public static IImportStrategy Select(string fileType)
    {
        if (fileType == ".csv")
        {
            return new CsvStrategy();
        }
        else if (fileType == ".json")
        {
            return new JsonStrategy();
        }

        throw new ApplicationException("No strategy found for file type: " + fileType);
    }
}

This can be called directly from the client code that executes the strategy. This would mean every time a strategy is required, the picker would need to be called first to find one. Sometimes finding the correct strategy can be a lot of work and it makes sense to store the strategy in an object so it can be used multiple times. This example contains the MusicManager class for this purpose. It contains the Strategy used for import and the list of albums imported.

public class MusicManager
{
    public List<Album> Albums { get; private set; }
    public IImportStrategy Importer { get; set; }

    public MusicManager()
    {
        Albums = new List<Album>();
    }
}

The code to pick a strategy based on file type is below. I'm not going to show the entire main method, just the parts that selects and executes the strategy. This can be used in multiple ways in applications.

Console.Write("File path (csv or json): ");
string filepath = Console.ReadLine();
string extension = Path.GetExtension(filepath);
manager.Importer = ImportStrategyPicker.Select(extension.ToLower());
var albums = manager.Importer.ImportAlbums(filepath);

At this point, the albums are imported from the specified file using either the csv or json import strategy. The full sample application source code is available on GitHub. It also includes sample data files.

Conclusion

In conclusion, we looked at the strategy pattern in this post. The strategy pattern allows an application to pick the appropriate strategy at runtime to perform a task. The example application can import a list of albums from either a csv or json file source.

ASP .NET Core MVC Dependency Injection Overview

Carl Layton — Sat, 22 Feb 2020 13:32:21 +0000

ASP .NET Core MVC comes with dependency injection built in and the options available will cover most use cases. In this post I will summarize what is available in the framework and how to use it.

I usually did not use dependency injection in my projects in previous versions of the MVC framework. The main reason why is previous versions didn't support dependency injection out of the box and required a 3rd party library like ninject. I thought the projects I worked on would not benefit from it enough to justify another 3rd party library to learn and dependency to keep track of. With ASP .NET Core MVC, that has all changed. Dependency injection is now built in and can be configured directly from the ConfigureServices method in the Startup class through a series of extension methods. It is also available throughout the framework. This includes custom attributes, filters, view components, etc, or POCOs that handle any custom business logic. This makes dependency management a better fit than in previous versions of the framework.

There are 3 main variations for adding dependencies: scoped, transient, and singleton. Scoped will use the same instance for a single web request, transient will create a new instance each time a dependency is needed, and singleton creates a single instance for the entire application. Each of these has several overloads.The table below details the common ones.

Extension Method	Description
`AddScoped<TImplementation>(IServiceCollection)`	Adds a scoped service of type TImplementation to the specified IServiceCollection.
`AddScoped<TService,TImplementation>(IServiceCollection)`	Adds a scoped service of type TService with an implementation of type TImplementation to the specified IServiceCollection
`AddScoped<TImplementation>(IServiceCollection, Func<IServiceProvider,TService>)`	Adds a scoped service of type TImplementation to the specified IServiceCollection. The instance is provided by the factory specified by the Func delegate argument
`AddScoped<TService,TImplementation>(IServiceCollection, Func<IServiceProvider,TImplementation>)`	Adds a scoped service of type TService with an implementation of type TImplementation to the specified IServiceCollection. The instance is provided by the factory specified by the Func delegate argument
`AddSingleton<TImplementation>(IServiceCollection)`	Adds a singleton service of type TImplementation to the specified IServiceCollection.
`AddSingleton<TService,TImplementation>(IServiceCollection)`	Adds a singleton service of type TService with an implementation of type TImplementation to the specified IServiceCollection
`AddSingleton<TImplementation>(IServiceCollection, Func<IServiceProvider,TService>)`	Adds a singleton service of type TImplementation to the specified IServiceCollection. The instance is provided by the factory specified by the Func delegate argument
`AddSingleton<TService,TImplementation>(IServiceCollection, Func<IServiceProvider,TImplementation>)`	Adds a singleton service of type TService with an implementation of type TImplementation to the specified IServiceCollection. The instance is provided by the factory specified by the Func delegate argument
`AddTransient<TImplementation>(IServiceCollection)`	Adds a transient service of type TImplementation to the specified IServiceCollection.
`AddTransient<TService,TImplementation>(IServiceCollection)`	Adds a transient service of type TService with an implementation of type TImplementation to the specified IServiceCollection
`AddTransient<TImplementation>(IServiceCollection, Func<IServiceProvider,TService>)`	Adds a transient service of type TImplementation to the specified IServiceCollection. The instance is provided by the factory specified by the Func delegate argument
`AddTransient<TService,TImplementation>(IServiceCollection, Func<IServiceProvider,TImplementation>)`	Adds a transient service of type TService with an implementation of type TImplementation to the specified IServiceCollection. The instance is provided by the factory specified by the Func delegate argument

The complete list of ServiceCollection extension methods including the ones related to dependency injection can be found on the microsoft docs.

This list covers all common use cases and will meet the requirements for most projects. I have setup a simple project that shows an example of a singleton, a transient, and a scoped dependency. The full source code can be found on GitHub.

The sample application shows a list of books with the ability to add a book. It also keeps track of the total number of pages and tracks each method visited per request.

I am not going to go through every detail of the example application but just highlight the parts that use dependency injection. The list of books is stored in memory so it will persist throughout the life of the application. If the application is restarted, the list resets. For this type of behavior, I inject a singleton. Book storage can also have multiple implementations so I defined an interface for it. public class InMemoryBookData : IBookData. The application also features a service named PagesCounter that sums the total number of pages in all books. I'm using the term "service" here to mean a generic class containing business logic. This doesn't need to persist state across requests so it is a transient dependency. The third feature tracks each method called per request titled RequestTrackerData. Because it needs to track each method in a request, it is a scoped dependency. This allows the same instance to be injected into multiple classes with a fresh instance for each request. As mentioned above, dependency injection is configured in the Startup.ConfigureServices method.

    public void ConfigureServices(IServiceCollection services)
    {
         services.AddSingleton<IBookData, InMemoryBookData>();
         services.AddScoped<RequestTrackerData>();
         services.AddTransient<ICounter, PagesCounter>();
         services.AddMvc();
    }

Dependency injection happens through constructor injection. The HomeController needs IBookData, RequestTrackerData, and ICounter for the PagesCounter so all 3 are injected and the framework manages what instance is actually passed in.

    public HomeController(IBookData b, RequestTrackerData tr, ICounter pc)
    {
         _bda = b;
         _tracker = tr;
         _pageCounter = pc;
    }

This is the basic theory of dependency injection regardless of what library or framework is used. However, the ASP .NET Core MVC framework makes managing dependencies better than previous versions. Dependency injection is supported throughout the MVC framework as well. This includes custom attributes, filters, view components, or POCOs that handle any custom business logic. It can all take advantage of the same dependency injection configuration. Browse through the example on GitHub to see a complete working project. I now use dependency injection throughout my ASP .NET Core MVC applications and find it easier to implement compared to instantiating instances directly in constructors like I used to do.

The Outbox Pattern in C#

Carl Layton — Sat, 22 Feb 2020 12:42:57 +0000

This post is part of the third annual C# Advent. Be sure to check out the other great posts as well. In this post, I'm going to implement the outbox pattern in C#. The outbox pattern can be used when one business transaction needs to happen as a result of another business transaction but it's not possible to combine them into the same database transaction. An example is when an order is placed through an online ordering system and an independent fulfillment system needs to be notified so the purchased items can be packaged and shipped. The outbox pattern can ensure the fulfillment system is updated correctly. When the order is placed, the online ordering system is updated, and at the same time, a message is placed into an outbox. A separate process comes along and processes any waiting entries in the outbox. This allows the outbox entry to be created at the same time the online ordering system is updated. It's important to note that it's possible for the outbox to process the message but then fail to update the outbox row. This means the row can be processed more than once. In a real application, the outbox processor or destination should account for this scenario.

The Example Application

For this example, I created two console applications. The first lets the user add titles and authors of their favorite books. When a new book is added, an entry is added to the outbox. The second app processes the outbox. The books and outbox are stored in a SQL database. Since there are a lot of moving parts, I won't be going over every line of code here. The full example is available on GitHub. It requires .NET Core 2.1 and SQL Server 2017 express.

Database Setup

The database consists of two tables. One to store the books and one to store the outbox. There are also some stored procedures for getting and setting data in the tables. Below are the table definitions. The GitHub repository contains a complete create script for all database objects.

    CREATE TABLE [dbo].[Outbox](
        [OutboxId] [int] IDENTITY(1,1) NOT NULL PRIMARY KEY CLUSTERED([OutboxId] ASC),
        [RequestMessage] [nvarchar](max) NOT NULL,
        [QueuedDate] [datetime] NOT NULL DEFAULT (getdate()),
        [ProcessedDate] [datetime] NULL,
        [ProcessedStatus] [nvarchar](256) NOT NULL DEFAULT ('queued'),
        [ErrorMessage] [nvarchar](max) NULL
     )
     GO

    CREATE TABLE [dbo].[Book] (
        [BookId] [int] IDENTITY(1,1) NOT NULL PRIMARY KEY CLUSTERED([BookId] ASC),
        [Title] [nvarchar](512) NOT NULL,
        [Author] [nvarchar](512) NOT NULL
    )
    GO

Adding a Book

The book manager has 3 options, add a new book, load books from the database, and display all books that are currently loaded in the application. After creating a book, a row is added to the outbox as shown below.

Menu	Save Book

Below is the code that adds a new book. Notice I add the book and outbox row as part of the same database transaction. This could also be done in the same SQL stored procedure but I'm assuming mostly C# programmers are reading this so I did the database transaction in C#.

    public static void SaveBook(Book book)
    {
        using (var connection = new SqlConnection(ConnectionString))
        {
            using (var command = connection.CreateCommand())
            {
                command.CommandType = CommandType.StoredProcedure;
                connection.Open();
                command.Transaction = command.Connection.BeginTransaction();
                command.CommandText = "SaveBook";
                command.Parameters.AddWithValue("@Title", book.Title);
                command.Parameters.AddWithValue("@Author", book.Author);
                command.ExecuteNonQuery();

                command.CommandText = "InsertOutbox";
                command.Parameters.Clear();
                command.Parameters.AddWithValue("@RequestMessage", book.Title + "," + book.Author);
                command.ExecuteNonQuery();

                command.Transaction.Commit();
            }
        }
    }

Processing the Outbox

The second application has one option to process the outbox. In this case "processing the outbox" simply means displaying the message to the console. The row in the outbox table gets updated with a timestamp of when the row was processed and a status of 'processed'.

Process Outbox	Processing Outbox

Conclusion

In conclusion, this is a simplified example of the outbox pattern in C#. The outbox pattern can be used when one business transaction needs to happen as a result of another business transaction but it's not possible to combine them into the same database transaction. In this post, I showed how adding a book, adds an entry to the outbox which can be handled by a separate process. Check out the full example on GitHub. You can run both apps side by side and insert books in one, and process them in the other. Finally, head over to this year's C# Advent for the other great posts.

Create Custom User Store for ASP .NET Core Identity

Carl Layton — Fri, 21 Feb 2020 03:03:06 +0000

In the previous post I looked at how to create a custom password hasher for ASP .NET Core Identity. In this post, I continue customizing the Identity system by creating a custom User Store. This is done by providing custom implementations to the IUserPasswordStore<applicationuser> and IUserEmailStore<applicationuser> interfaces. I'm going to create in-memory implementations of these two interfaces. This will not work in a real application because all the users are deleted when the application restarts but is good for demo purposes. This tutorial requires Visual Studio 2017 and dotnet core 2.0. The entire sample project is available on Github.

Create Starting Application

The first step is to create a new ASP .NET Core web app with individual user accounts. We're going to start with this template because a lot of the boilerplate code is created automatically and it's a good starting point to customize ASP .NET identity. Open Visual Studio 2017 and create a new ASP .NET Core Web Application project. Provide a name and location and click OK.

Choose .NET Core and ASP.NET Core 2.0 from the dropdowns at the top. Select Web Application (Model-View-Controller) for the template and select Change Authentication and pick Individual User Accounts.

After the project is created, debug it from Visual Studio to make sure the template is working. After the web app loads, stop debugging. Since we're creating a custom in-memory user store, we don't need the database so you can delete the Migrations folder out of the project's Data folder

At this point we have an ASP .NET core web app project with basic user authentication support. In the sections that follow, we will create our custom implementation.

Create the "Data Access" class

Since, we're storing users in memory, we need a place to keep them. We're going to create a custom class for this. This class has nothing to do with ASP .NET Core Identity but we need a place to perform basic CRUD operations on our list of in-memory users. Create a new C# class and name it InMemoryUserDataAccess.cs. The full class is below to copy and paste.

    public class InMemoryUserDataAccess
    {
        private List<ApplicationUser> _users;
        public InMemoryUserDataAccess()
        {
            _users = new List<ApplicationUser>();
        }
        public bool CreateUser(ApplicationUser user)
        {
            _users.Add(user);
            return true;
        }

        public ApplicationUser GetUserById(string id)
        {
            return _users.FirstOrDefault(u => u.Id == id);
        }

        public ApplicationUser GetByEmail(string email)
        {
            return _users.FirstOrDefault(u => u.NormalizedEmail == email);
        }

        public ApplicationUser GetUserByUsername(string username)
        {
           return _users.FirstOrDefault(u => u.NormalizedUserName == username);
        }

        public string GetNormalizedUsername(ApplicationUser user)
        {
            return user.NormalizedUserName;
        }

        public bool Update(ApplicationUser user)
        {
            // Since get user gets the user from the same in-memory list,
            // the user parameter is the same as the object in the list, so nothing needs to be updated here.
            return true;
        }
    }

Next, we need to add this to the ConfigureServices method in the Startup class for dependency injection. Since it's an in-memory list, we will use a singleton. Add services.AddSingleton<InMemoryUserDataAccess>();. The ConfigureServices method is below.

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

        services.AddSingleton<InMemoryUserDataAccess>();
        services.AddIdentity<ApplicationUser, IdentityRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();

        // Add application services.
        services.AddTransient<IEmailSender, EmailSender>();
        services.AddMvc();
    }

Create Custom User Store

We're finally ready to create our custom user store. The user store in ASP .NET identity can be a complex system of functionality. Luckily, this functionality is broken out into a series of interfaces so we can choose what functionality we want our user store to support. To keep it simple, we're going to implement the IUserPasswordStore and IUserEmailStore interfaces. This is enough to get us started. There are a lot of other interfaces for handling claims, phone numbers, 2 factor authentication, account lockout, etc. This microsoft doc goes into a lot more detail on all the store interfaces.

The full implementation is below. Notice the dependency to InMemoryUserDataAccess we created above. I did not implement delete. I'll leave that up to you.

    public class InMemoryUserStore : IUserPasswordStore<ApplicationUser>, IUserEmailStore<ApplicationUser>
    {
        private InMemoryUserDataAccess _dataAccess;
        public InMemoryUserStore(InMemoryUserDataAccess da)
        {
            _dataAccess = da;
        }

        public Task<IdentityResult> CreateAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<IdentityResult>.Run(() =>
            {
                IdentityResult result = IdentityResult.Failed();
                bool createResult = _dataAccess.CreateUser(user);

                if (createResult)
                {
                    result = IdentityResult.Success;
                }

                return result;
            });
        }

        public Task<IdentityResult> DeleteAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            throw new NotImplementedException();
        }

        public void Dispose()
        {

        }

        public Task<ApplicationUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken)
        {
            return Task<ApplicationUser>.Run(() =>
            {
                return _dataAccess.GetByEmail(normalizedEmail);
            });
        }

        public Task<ApplicationUser> FindByIdAsync(string userId, CancellationToken cancellationToken)
        {
            return Task<ApplicationUser>.Run(() =>
            {
                return _dataAccess.GetUserById(userId);
            });
        }

        public Task<ApplicationUser> FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken)
        {
            return Task<ApplicationUser>.Run(() =>
            {
                return _dataAccess.GetUserByUsername(normalizedUserName);
            });
        }

        public Task<string> GetEmailAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
                return Task<string>.Run(() =>
                {
                    return user.Email;
                });
        }

        public Task<bool> GetEmailConfirmedAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<bool>.Run(() =>
            {
                return user.EmailConfirmed;
            });
        }

        public Task<string> GetNormalizedEmailAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<string>.Run(() =>
            {
                return user.NormalizedEmail;
            });
        }

        public Task<string> GetNormalizedUserNameAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<string>.Run(() =>
            {
                return user.NormalizedUserName;
            });
        }

        public Task<string> GetPasswordHashAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<string>.Run(() => { return user.PasswordHash; });
        }

        public Task<string> GetUserIdAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<string>.Run(() =>
            {
                return user.Id;
            });
        }

        public Task<string> GetUserNameAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<string>.Run(() =>
            {
                return user.UserName;
            });
        }

        public Task<bool> HasPasswordAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<bool>.Run(() => { return true; });
        }

        public Task SetEmailAsync(ApplicationUser user, string email, CancellationToken cancellationToken)
        {
            return Task.Run(() => {
                user.Email = email;
            });
        }

        public Task SetEmailConfirmedAsync(ApplicationUser user, bool confirmed, CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                user.EmailConfirmed = confirmed;
            });
        }

        public Task SetNormalizedEmailAsync(ApplicationUser user, string normalizedEmail, CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                user.NormalizedEmail = normalizedEmail;
            });
        }

        public Task SetNormalizedUserNameAsync(ApplicationUser user, string normalizedName, CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                user.NormalizedUserName = normalizedName;
            });
        }

        public Task SetPasswordHashAsync(ApplicationUser user, string passwordHash, CancellationToken cancellationToken)
        {
            return Task.Run(() => { user.PasswordHash = passwordHash; });
        }

        public Task SetUserNameAsync(ApplicationUser user, string userName, CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                user.UserName = userName;
                user.NormalizedUserName = userName.ToUpper();
            });
        }

        public Task<IdentityResult> UpdateAsync(ApplicationUser user, CancellationToken cancellationToken)
        {
            return Task<IdentityResult>.Run(() =>
            {
                IdentityResult result = IdentityResult.Failed();
                bool updateResult = _dataAccess.Update(user);

                if (updateResult)
                {
                    result = IdentityResult.Success;
                }

                return result;
            });
        }
    }

The dependency injection support in ASP .NET Core MVC makes it easy to use our implementation. We need to add another line to the ConfigureServices method in the Startup class. Add this right after the singleton for InMemoryUserDataAccess. services.AddTransient<IUserStore<ApplicationUser>, InMemoryUserStore>();. The complete ConfigureServices method is below

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

        services.AddSingleton<InMemoryUserDataAccess>();
        services.AddTransient<IUserStore<ApplicationUser>, InMemoryUserStore>();
        services.AddIdentity<ApplicationUser, IdentityRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();

        // Add application services.
        services.AddTransient<IEmailSender, EmailSender>();
        services.AddMvc();
    }

Test It

Build and debug the project from Visual Studio. Click the Register button in the upper right corner. Enter an email and password and confirm password and click Register. The password requirements are still the default for ASP .NET Core Identity so you will need a lowercase letter, uppercase letter, number, and special character.

It should redirect to the home page and the Register button should be replaced with a greeting Hello ! Click the Log out link next to this greeting and it redirects to the home page with the Register and Log in buttons.

Click login and use the email and password just created. After login, you are redirected to the homepage with the same greeting.

If you stop debugging and restart the application, the user no longer exists because it's stored in memory.

Conclusion

That concludes how to setup a basic custom user store for ASP .NET Core Identity. We created a custom class implementing only the interfaces we needed and the built in dependency injection makes it easy to swap implementations. User management is a complex topic with many features available for both security and user experience. Hopefully, this is a good starting point for customizing specific features around user management in your ASP .NET Core application.

Create Custom Password Hasher for ASP .NET Core Identity

Carl Layton — Wed, 19 Feb 2020 04:51:00 +0000

In this post, I will look at how to extend the ASP .NET Core Identity membership system to use a custom class for hashing passwords. ASP .NET Core Identity is very extendable and extending it is a good way to get a better understanding of how the system works. We can customize it by providing new implementations to its interfaces. This code is not production ready and any custom security implementation should be done with care and be backed by good reasons. That being said, lets have some fun. This tutorial requires Visual Studio 2017, dotnet core 2.0, and LocalDb, which should be installed with Visual Studio depending on which components were picked at the time of install. The entire sample project is available on Github.

Start by opening Visual Studio 2017 and create a new ASP .NET Core Web Application project. I named it DotNetCoreAuthExamples but you can name it anything you like. Click OK.

After the project is created, debug it from Visual Studio. Once the website loads, click the Register link from the top menu bar. Fill in an email and password and click the Register button.

The first time an error will appear. This is because we haven’t created the database yet. Click on Apply Migrations. This will create the database using Entity Framework. All the required database stuff is defined by the template and the defaults will work for this demonstration.

Once that is done, the button text changes to Migrations Applied. Refresh the page and click yes at any browser prompts about resubmitting the form. The home page will reload and the top menu bar will show the test user logged in.

If you get an error starting with SqlException: A network-related or instance-specific error occurred while establishing a connection to SQL Server... check the server in the app settings connection string. This can be found in the appsettings.json file. The Visual Studio Sql Server Object Explorer will tell you the server path to LocalDb. Make sure the connection string matches this path. If not, change it and then stop and restart debugging.

After the page reloads with the user logged in, a record is also created in the database for this user. To see that, open the SQL Server Object Explorder in Visual Studio. It should auto-connect to LocalDb. The database name will contain the project name. Once you find it, query the AspNetUsers table like this SELECT * FROM dbo.AspNetUsers. There is 1 row with the registered user.

As this point, we have a working default MVC template with Individual User Accounts. We will now supplement this with a class to do our own password hashing. This is to demonstrate how different components of the Identity membership system can be customized. Create a new class named CustomPasswordHasher and have it implement IPasswordHasher<ApplicationUser>. There are 2 methods we need to implement, string HashPassword(TUser user, string password) and PasswordVerificationResult VerifyHashedPassword(TUser user, string hashedPassword, string providedPassword). Our custom class will reverse the original password string. This is to demonstrate how the methods will be used. In a real application, this would contain a secure, well planned, and well tested implementation. The full class is below. This should not be used in a real application.



    public class CustomPasswordHasher : IPasswordHasher<ApplicationUser>
    {
        public string HashPassword(ApplicationUser user, string password)
        {
            return ReversePassword(password);
        }

        public PasswordVerificationResult VerifyHashedPassword(ApplicationUser user, string hashedPassword, string providedPassword)
        {
            if (hashedPassword == ReversePassword(providedPassword))
            {
                return PasswordVerificationResult.Success;
            }

            return PasswordVerificationResult.Failed;
        }

        private string ReversePassword(string value)
        {
            // This is not a secure way to store a password!
            char[] charArray = value.ToCharArray();
            Array.Reverse(charArray);
            return new string(charArray);
        }
    }

The final thing to do is register our new implementation with the dependency injection system. This happens in the ConfigureServices method of the Startup class. Copy/Paste the following line as the first line of the method: services.AddTransient<IPasswordHasher<ApplicationUser>, CustomPasswordHasher>();. To learn more about Dependency injection in ASP .NET Core, check out my post "ASP .NET Core MVC Dependency Injection Overview". The full ConfigureServices method is below.



    public void ConfigureServices(IServiceCollection services)
    {
        services.AddTransient<IPasswordHasher<ApplicationUser>, CustomPasswordHasher>();

        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

        services.AddIdentity<ApplicationUser, IdentityRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();

        // Add application services.
        services.AddTransient<IEmailSender, EmailSender>();

        services.AddMvc();  
    }

The only thing left to do is test it. Place a breakpoint in both the HashPassword and VerifyHashedPassword methods. Start debugging and register a new user, like we did above. On registration, the HashPassword breakpoint will be hit and on login the VerifyHashedPassword method will be hit. In both cases, the user will be logged in. If you got this far, it means you have successfully created a custom password hasher for ASP .NET Core Identity!

In conclusion, this post shows 1 example of overriding a feature of ASP .NET Core Identity. The complete code can be found in this Github repository. This code is for educational purposes only and is not meant for production environments. Thought, planning, and good reasons need to be involved for authentication code meant for a production environment. That being said, it is possible to customize many parts of the ASP .NET Core Identity system. In my next post, I will expand on this with an example of customizing the user store component to allow user accounts to be stored in memory instead of a database.