What is Google Cloud Run?

The best way to describe Cloud Run is to quote Google (almost verbatim)

In this guide, we will need to perform tasks in the Visual Studio environment as well as in the Google Cloud platform.

Setting Up Your Environment

3. Create a Google Cloud Project

The project name is up to you, but if you want to follow along with this blog, we are naming the project WeatherForecastAPI-proj

Once the project is created, note the Project ID, you will need it to interact with the platform.  Note that the ID is generated automatically, and may be different from what you expect.

4. Create an Artifact Repository

The next step is to create a repository to hold your containers (images).  On the console, search for and select Artifact Registry.

If prompted, enable the API.

The next step is to add a repository to hold your container images.  In this sample we will be hosting a docker image.

Provide the repo details as shown below and click CREATE.

If you run into an error like shown below, ignore it; it takes a few minutes for the repository to be propagated.

4 Create the Visual Studio 2022 Project

Start Visual Studio and create an ASP.Net Core WebAPI app. In this example, I am naming my project WeatherForecastAPI

When you click "Next" be sure to provide the additional information as shown in the image below.

I am using controllers, by personal preference. If you have any major arguments about my choice, see Ben Foster's insightful article ASP.NET 6.0 Minimal APIs - Why should you care?

After Visual Studio completes the setup, run the app (Ctrl-F5) to make sure it works.

For our purposes we are going to make some changes.

1) Replace the code in Program.cs with the following:

var builder = WebApplication.CreateBuilder(args);

int hostPort = Int16.Parse(builder.Configuration["Host:Port"]);

builder.WebHost.UseKestrel(options =>
{
    options.Listen(System.Net.IPAddress.Any, hostPort);

});

// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

app.UseRouting(); 

app.UseSwagger();
app.UseSwaggerUI();

app.UseEndpoints(endpoints =>
{
    endpoints.MapGet("/", async context =>
    {
         context.Response.Redirect("swagger");
    });
});


//app.UseHttpsRedirection();

//app.UseAuthorization();

app.MapControllers();

app.Run();

In the above code, note the following:

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
        }
    },
    "Host": {
        "Port": 5175
    },
    "AllowedHosts": "*"
}

I have also made some changes to the WeatherForecastController to make it a little more interesting.

using Microsoft.AspNetCore.Mvc;

namespace WebApiGCloud.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild",
        "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger _logger;

        public WeatherForecastController(ILogger logger)
        {
            _logger = logger;
        }
        private IEnumerable GetWeatherData()
        {
            return Enumerable.Range(1, 30).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            }).ToArray();
        }
        [HttpGet("/weatherforecast")]
        public IEnumerable Get()
        {
            return GetWeatherData();
        }
        [HttpGet("/weatherforecast/{code:alpha:length(3,10)}")]
        public IEnumerable Get(string code)
        {
            return GetWeatherData().ToArray().Where(p => p.Summary.ToLower() == code.ToLower());
        }
    }
}

Before testing locally, make sure your profiles section in launchSettings.json is similar to this:

    "profiles": {
        "WeatherForecastAPI": {
            "commandName": "Project",
            "launchBrowser": true,
            "environmentVariables": {
                "ASPNETCORE_ENVIRONMENT": "Development"
            },
            "applicationUrl": "http://localhost:5175",
            "dotnetRunMessages": true
        },

In the above launchSettings.json, note the following:

You can run the project  (Ctrl+F5) to make sure it is working.  You should see the Swagger UI as shown below.

You may run into an error like this when you try to run the application.

If you  do run into this error, check to make sure your application profile is set to WeatherForecastAPI as shown below

The first link will return a json that looks like:

[
    {
        "date": "2022-01-20T11:42:26.4073824-05:00",
        "temperatureC": -18,
        "temperatureF": 0,
        "summary": "Hot"
    },
    {
        "date": "2022-01-21T11:42:26.4086175-05:00",
        "temperatureC": 53,
        "temperatureF": 127,
        "summary": "Cool"
    },
    {
        "date": "2022-01-22T11:42:26.4086275-05:00",
        "temperatureC": 35,
        "temperatureF": 94,
        "summary": "Warm"
    },
    {
        "date": "2022-01-23T11:42:26.408628-05:00",
        "temperatureC": -3,
        "temperatureF": 27,
        "summary": "Scorching"
    },
    {
        "date": "2022-01-24T11:42:26.4086283-05:00",
        "temperatureC": 33,
        "temperatureF": 91,
        "summary": "Sweltering"
    },
    {
        "date": "2022-01-25T11:42:26.4086287-05:00",
        "temperatureC": -15,
        "temperatureF": 6,
        "summary": "Mild"
    },
    {
        "date": "2022-01-26T11:42:26.40863-05:00",
        "temperatureC": 30,
        "temperatureF": 85,
        "summary": "Balmy"
    },
    {
        "date": "2022-01-27T11:42:26.4086304-05:00",
        "temperatureC": -14,
        "temperatureF": 7,
        "summary": "Chilly"
    },
    {
        "date": "2022-01-28T11:42:26.4086314-05:00",
        "temperatureC": -4,
        "temperatureF": 25,
        "summary": "Freezing"
    },
    {
        "date": "2022-01-29T11:42:26.4086318-05:00",
        "temperatureC": -17,
        "temperatureF": 2,
        "summary": "Cool"
    },
    {
        "date": "2022-01-30T11:42:26.4086329-05:00",
        "temperatureC": -11,
        "temperatureF": 13,
        "summary": "Scorching"
    },
    {
        "date": "2022-01-31T11:42:26.4086332-05:00",
        "temperatureC": -15,
        "temperatureF": 6,
        "summary": "Chilly"
    },
    {
        "date": "2022-02-01T11:42:26.4086335-05:00",
        "temperatureC": -17,
        "temperatureF": 2,
        "summary": "Scorching"
    },
    {
        "date": "2022-02-02T11:42:26.4086339-05:00",
        "temperatureC": 9,
        "temperatureF": 48,
        "summary": "Warm"
    },
    {
        "date": "2022-02-03T11:42:26.4086342-05:00",
        "temperatureC": -11,
        "temperatureF": 13,
        "summary": "Freezing"
    }
]

The second will return results filtered for dates where the summary is Hot:

[
    {
        "date": "2022-01-20T12:02:53.7801378-05:00",
        "temperatureC": -4,
        "temperatureF": 25,
        "summary": "Hot"
    },
    {
        "date": "2022-01-23T12:02:53.7801469-05:00",
        "temperatureC": 37,
        "temperatureF": 98,
        "summary": "Hot"
    },
    {
        "date": "2022-02-14T12:02:53.7801519-05:00",
        "temperatureC": 25,
        "temperatureF": 76,
        "summary": "Hot"
    },
    {
        "date": "2022-02-17T12:02:53.7801526-05:00",
        "temperatureC": 7,
        "temperatureF": 44,
        "summary": "Hot"
    }
]

Preparing the App for Google CloudRun

The steps are:

• Publish the app
• Create a Docker image of the app
• Tag the image
• Push the image to Cloud Run

Publish The App

For this step, we'll use the usual Visual Studio publish steps.  I am publishing to a output folder in the application directory (C:\Sample\WeatherForecastAPI\output) and setting the target framework to linux-x64

Update your Dockerfile

FROM mcr.microsoft.com/dotnet/sdk:6.0
COPY ./output /publish
WORKDIR /publish

EXPOSE 5175
ENTRYPOINT ["dotnet", "WeatherForecastAPI.dll"]

Create the docker image

Using Powershell,  switch to the application directory, and create the docker image for the project,

cd C:\Sample\WeatherForecastAPI

docker build -t weatherforecastapi-image  -f Dockerfile .

Tag the image

docker tag weatherforecastapi-image us-east1-docker.pkg.dev/weatherforecastapi-proj/weatherforecastapi-repo/weatherforecastapi-image:v1.0

You can tag the image version according to your needs or just use latest.

Push the Image To Artifact Registry

docker push us-east1-docker.pkg.dev/weatherforecastapi-proj/weatherforecastapi-repo/weatherforecastapi-image:v1.0

Create a Service

Once the image has been pushed to the Artifact Registry, go to the cloud console and select your Project - -> Cloud Run - -> Create Service

On the Create Service screen enter the values as indicated in the sample below.  

To specify the container image for the service, click the SELECT - -> ARTIFACT REGISTRY, and then select the image version you pushed to the repo.

Enter the rest of the service parameters as shown in the sample below.

Note:  In the example, I am allowing unauthenticated traffic.  If authentication is required by your app, you'll set that up in the Kestrel pipeline in Program.cs.

Once you click the CREATE button, the process for creating and configuring the service will start.

If you are following along with this example, you will receive an error similar to this:

As of this writing, you'll always get this error unless you set your Kestrel port to 8080. To fix this error edit and re-deploy the service; changing the container port to 5175, the Kestrel listening port we used in Program.cs.

Service Deployed

Once you update the container port and re-deploy, the service deployment should be successful.  You'll see a screen similar to this:

Click on the service to take you to the details page

About the URL generated by Cloud Run

Note that Cloud Run generates a URL for the service automatically.
Cloud Run also generates a Certificate for the service and ensures only https access.  The certificate expires in a little less than 90 days. Since Cloud Run is fully managed, the Certificate will be automatically renewed prior to expiration.

Clicking on the generated URL takes you to the Swagger UI, shown earlier when the app was tested in the development environment.

You can test the service through the Swagger UI, or by appending the URL fragments (/weatherforecast, /weatherforecast/hot), as shown earlier.

Note that the redirection to https is handled by the platform, and occurs before the Kestrel pipeline.

Using a Custom Domain

In case you prefer to use your own domain instead of the generated one, click on Manage Custom Domains, and then Add Mappings as shown below.

Follow the prompts to select the service to map and the custom domain to use.  

In this example, I have elected to map the service to a new subdomain of this blog site (alumdb.com).  After clicking the continue button Cloud Run will provide you information needed to update your DNS records as shown below.

Once the service has been updated to use the custom domain the service screen will look like this:

You can now access the service using the custom domain as shown in the examples below:

Note:  Even after you setup your custom domain, the platform-generated service url is still available and functional.  If you click the information icon (Show Info on Service URL's) you'll see both urls for the service:

This blog explores use of  the RedisJSON datatype in NetCore applications. It provides sample C# code that you can modify and use in your own applications. In all the examples shown, we'll be using the .NET  client NReJSON  (courtesy, Tommy Hanks et al).

Prerequisites
The samples reference the following packages from nuget.org:

a)  StackExchange.Redis -Version 2.1.58
b)  NReJSON -Version 3.1.0
c)  Newtonsoft.Json -Version 12.0.3

The samples were developed and tested with the versions shown; I imagine they'll work with later versions.

Sample Data

For this exercise, we'll need to create a RedisJSON datatype.  We'll create a controller with a POCO object UserInfo that will provide the initial data for the app.  The controller is shown below.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;

//RejSon
using StackExchange.Redis;
using NReJSON;
using Newtonsoft.Json;
using System.Dynamic;

namespace RedisSample.Controllers
{
    public class Address
    {
        public string street { get; set; }
        public string city { get; set; }
        public string state { get; set; }
        public string zip { get; set; }
    }
    public class UserInfo
    {
        public string userId { get; set; }
        public string fullName { get; set; }
        public string email { get; set; }
        public int rank { get; set; }
        public Address address { get; set; }
    }
    [Route("api/[controller]")]
    public class RedisJsonSampleController : ControllerBase
    {
        UserInfo _userInfo;
        private readonly IConnectionMultiplexer _connectionMultiplexer;
        public RedisJsonSampleController(){
            UserInfo userInfo = new UserInfo()
            {
                userId = "AC-67292",
                fullName = "Bob James",
                email = "bobjames@sample.com",
                rank = 15,
                address = new Address()
                {
                    street = "678 Winona Street",
                    city = "New Medford",
                    state = "Delaware",
                    zip = "12345"
                }
            };

            _userInfo = userInfo;
            
            //Replace with the IP of your redis server
            string conn = "127.0.0.1:6379"; 
            _connectionMultiplexer = ConnectionMultiplexer.Connect(conn);
        }
    }
}

To keep the code simple and to the point, I am creating the data in the constructor and also hard-coding the IP address of the redis server. Included in the UserInfo is "rank".  This is just to demonstrate use of the INCR command in a later example.  Feel free to use DI and other methods to improve your implementation.

I am also using [HttpGet] for all the API endpoints, even if the method changes data,  – again this is to keep things simple.

At any point you can verify the initial (non-RedisJSON) data using this code:

        [HttpGet]
        [Route("/api/redisjsonsample/initial/person")]
        public IActionResult GetPersonData()
        {
            return Ok(_userInfo);
        }

The next section of code creates the RedisJSON record and verifies that it is correct.  Note: throughout this sample, I am using the format userprofile:useremail , in this case – "userprofile:bobjames@sample.com"  – as the key.

        //********Save UserInfo to Redis**********
        [HttpGet]
        [Route("/api/redisjsonsample/save/profile")]  //save initial data
        public async Task<IActionResult> SaveUserProfile()
        {
            IDatabase db = _connectionMultiplexer.GetDatabase();
            string key = "userprofile:" + _userInfo.email.ToLower();
            string json = JsonConvert.SerializeObject(_userInfo);
            //use try/catch to catch error
            OperationResult result = await db.JsonSetAsync(key, json);

            if (result.IsSuccess) { return Ok("SaveUserProfile Succeeded"); }

            return BadRequest("SaveUserProfile  Failed");
        }

 		//********Read UserInfo from Redis**********
        [HttpGet]
        [Route("/api/redisjsonsample/get/profile")]  
        public async Task<IActionResult> GetUserProfile()
        {
            IDatabase db = _connectionMultiplexer.GetDatabase();
            string key = "userprofile:" + _userInfo.email.ToLower();    
            string[] parms = { "." };
            RedisResult result = await db.JsonGetAsync(key, parms);
            if (result.IsNull) { return BadRequest("GetUserProfile Failed"); }
            string profile = (string)result;
            return Ok(profile);
        }

Changing Values
With the RedisJSON record created, we can try to change some properties.  The code below shows how to change the "state" and the "fullName"

        [HttpGet]
        [Route("/api/redisjsonsample/change/state_plus_fullname")]
        public async Task<IActionResult> ChangeSomeProps()
        {
            IDatabase db = _connectionMultiplexer.GetDatabase();
            string key = "userprofile:" + _userInfo.email.ToLower();
            
            //change state -- note: full path is needed .address.state 
            //use try/catch to catch error
            OperationResult result = await db.JsonSetAsync(key, JsonConvert.SerializeObject("New York"), ".address.state");
            string resultValue = result.RawResult.ToString();  //- - > OK
           
            //change fullName
            //use try/catch to catch error
            OperationResult res = await  db.JsonSetAsync(key, JsonConvert.SerializeObject("Bob T Jones"),".fullName");

            string fullNameResult = res.RawResult.ToString(); //- - > OK  

            return Ok(resultValue + "**" + fullNameResult ) ; 
        
        }

Incrementing Numeric Values
Below is a sample on how to increment a numeric value.  Here, we are incrementing the rank by 3.

       [HttpGet]
        [Route("/api/redisjsonsample/incr/rank")]
        public async Task<IActionResult> IncrementRank()
        {
            IDatabase db = _connectionMultiplexer.GetDatabase();
            string key = "userprofile:" + _userInfo.email.ToLower();

            //note the value is being incremented by 3 -- hardcoded
            //In real life you'll pass it in as a parameter
			//use try/catch to catch error
            RedisResult res = await db.JsonIncrementNumberAsync(key, ".rank", 3);           
            //returns 15 + 3   --> 18  (the first time it's used)
            return Ok((string)res);
        }

Note: in the sample above, you can use a negative number if you want to decrement the number.

NReJSON also has the JsonMultiplyNumberAsync method for multiplying a numeric value.  The code is similar to the above.

Getting Multiple Properties
Redis Records can be 512 megabytes in size.  If you have huge JSON records you may want to limit your queries to specific keys  – for the same reasons why you may not want to limit use of SELECT * in SQL queries – and instead use SELECT column1, column3... instead.

The example below illustrates how to select fullName, state and zip from the RedisJSON  record.

        [HttpGet]
        [Route("/api/redisjsonsample/mprops")]
        public async Task<IActionResult> GetMultipleProps()
        {          
            IDatabase db = _connectionMultiplexer.GetDatabase();
            string key = "userprofile:" + _userInfo.email.ToLower();
            string[] multipleKeys = { ".fullName", ".address.state" , ".address.zip" };
            RedisResult result = await db.JsonGetAsync(key, multipleKeys       

            if (result.IsNull)
            {
                return BadRequest("bad request");
            }
            return Ok( (string)result);
             //NOTE: returns {".fullName":"Bob T Jones",".address.state":"New York",".address.zip":"12345"}
        }

Important Notes
a) In this example the record is returned with preceding periods (".") for the properties because they are actually redis key/value pairs.

    {".fullName":"Bob T Jones",".address.state":"New York",".address.zip":"12345"}

b) If you include a key (eg .middleInitial ) that does not exist, you will get a RedisServerException error and no records will be returned.

Adding a New Property
In the .address.zip key on the preceding samples  we had a zip code "12345 Supposing we have to add a new field, zip+4, without changing the original zip. The example below shows how to do that.  Note this requires just adding the value to a new key, eg,  .address.zipPlusFour as shown in the example below.

   		[HttpGet]
        [Route("/api/redisjsonsample/add/addziplusfour")]
        public async Task<IActionResult> AddNewProperty()
        { 
            IDatabase db = _connectionMultiplexer.GetDatabase();
            string key = "userprofile:" + _userInfo.email.ToLower();

            string zipPlusFour = "12345-6789";
            string jsonZipPlusFour = JsonConvert.SerializeObject(zipPlusFour);
            OperationResult opResult = await db.JsonSetAsync(key, jsonZipPlusFour, ".address.zipPlusFour");

            if (opResult.IsSuccess)
            {
                string result = opResult.RawResult.ToString();
                return Ok(result); // --> OK
            }
            return BadRequest("Error - cannot create new property");
        }

Adding Whole Objects to  RedisJSON Datatype
The preceding example shows how to add a new property to the JSON record.  We can use the same approach to add entire objects. Let's say we wanted to add a shipTo address to our current .address key.  In our C# code we will create a new Address object and add it as shown below.

 		[HttpGet]
        [Route("/api/redisjsonsample/add/secondaddress")]
        public async Task<IActionResult> AddJsonObject()
        {
            Address shipTo = new Address()
            {
                 street="4592 Vacation Drive",
                 city = "Vacation City",
                 state = "New Hampshire",
                 zip ="36448"
            };
            IDatabase db = _connectionMultiplexer.GetDatabase();
            string key = "userprofile:" + _userInfo.email.ToLower();

            string jsonshipTo = JsonConvert.SerializeObject(shipTo);
            //Note the new key
            OperationResult opResult = await db.JsonSetAsync(key, jsonshipTo, ".address.shipTo");

           if (opResult.IsSuccess)
            {
                string result = opResult.RawResult.ToString();
                return Ok(result); // --> OK
            }
            return BadRequest("Error - cannot add object");
         }

With this code implemented, we can then access the original street using the key .address.street and the shipTo street as .address.shipTo.street.

Implementing New Features/Executing Direct Commands
As features are added to Redis, there may be commands that may not yet be implemented in your RedisJSON client.  For instance, as of the time of this article (8/16/2020), the JSON.STRAPPEND command had not been implemented in our redis client NReJSON.  Thanks to Marc Gravell we can use the StackExchange.Redis Execute/ExecuteAsync methods to implement this and other new or unimplemented commands.

Below is an example of how we can run the JSON.STRAPPEND command to add " Boulevard" to the key ".address.shipTo.street".

        [Route("/api/redisjsonsample/strappend/tostreet")]
        public async Task<IActionResult> AppendString()
        {
            IDatabase db = _connectionMultiplexer.GetDatabase();
            string key = "userprofile:" + _userInfo.email.ToLower();
            string jsonStrappend = JsonConvert.SerializeObject(" Boulevard");
            int result = await db.ExecuteAsync("JSON.STRAPPEND", new object[] {key, ".address.shipTo.street", jsonStrappend });  
            return Ok(result);
        }

Notes:
a) The JSON.STRAPPEND command returns an integer – the length of the updated string.
b) You are encouraged to wrap the Execute method in a try/catch because if the path is invalid, a RedisServerException will be thrown.

This blog covers how to use RediSearch in your .NETCore applications.  It provides sample C# examples using the RediSearch NetCore client NRediSearch.

The article has two main sections:  

1. Creating RedisSearch records
2. Searching for records.

Prerequisites

This examples in this blog use the following packages from nuget.org:

a)  StackExchange.Redis -Version 2.1.58
b)  NRediSearch - Version 3.1.0
c)  Newtonsoft.Json -Version 12.0.3

The RediSearch samples were developed and tested with the versions shown; I imagine they'll work with later versions.  

Sample Data

To make the examples a little more concrete, we created RediSearch records based on the SQL Server  Northwind Database, scripts for which are here on GitHub.

To make your life easier, I have created a json file  from the view Order Details Extended.  If you want to follow along by creating your own Redis records your can download the json file northwindorders.json.  There are 2155 records in the file.  The records look like the json below.

[{"customerID":"VINET","customerName":"Vins et alcools Chevalier",
    "address":"59 rue de l'Abbaye","city":"Reims", "postalCode":"51100","country":"France",
    "orderID":10248,"orderDate":"1996-07-04T00:00:00",
    "requiredDate":"1996-08-01T00:00:00","shippedDate":"1996-07-16T00:00:00",
    "shipperName":"Federal Shipping","productID":11,"productName":"Queso Cabrales",    
    "unitPrice":14.0000,"quantity":12,"extendedPrice":168.0000,"id":null,"score":0},
{"customerID":"VINET","customerName":"Vins et alcools Chevalier",
    "address":"59 rue de l'Abbaye","city":"Reims","postalCode":"51100","country":"France",
    "orderID":10248,"orderDate":"1996-07-04T00:00:00",
    "requiredDate":"1996-08-01T00:00:00","shippedDate":"1996-07-16T00:00:00",
    "shipperName":"Federal Shipping","productID":42,"productName":"Singaporean Hokkien Fried Mee",
    "unitPrice":9.8000,"quantity":10,"extendedPrice":98.0000,"id":null,"score":0}]

Creating the Data

To create the records for RediSearch we'll use the POCO class shown below.

     public class DocCommon
    {
        public string Id { get; set; }
        public double Score { get; set; }
    }
     public class CustomerOrders : DocCommon
   {
        public string customerID { get; set; }
        public string customerName { get; set; }
        public string address { get; set; }
        public string city { get; set; }
        public string postalCode { get; set; }
        public string country { get; set; }
        public int orderID { get; set; }
        public System.Nullable<System.DateTime> orderDate { get; set; }
        public System.Nullable<System.DateTime> requiredDate { get; set; }
        public System.Nullable<System.DateTime> shippedDate { get; set; }
        public string shipperName { get; set; }
        public int productID { get; set; }
        public string productName { get; set; }
        public decimal unitPrice { get; set; }
        public short quantity { get; set; }
        public System.Nullable<decimal> extendedPrice { get; set; }
    }

Note that the CustomerOrders class inherits DocCommon.  The rational for this will be explained in a later section.

The first thing is to create a controller for handling this example.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

using System.IO;
using Microsoft.AspNetCore.Routing;

using System.Dynamic;

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Cors;
using System.Reflection;
using System.Data.Common;
using System.Diagnostics;

//******** Needed for Redis Search *************
using Newtonsoft.Json;
using StackExchange.Redis;
using NRediSearch;
using static NRediSearch.Schema;
using NRediSearch.Aggregation;
using NRediSearch.QueryBuilder;


namespace RedisSearchApp.Controllers
{
    [Produces("application/json")]
    public class SearchController : ControllerBase
    {
        private readonly Microsoft.AspNetCore.Hosting.IWebHostEnvironment _hostingEnvironment;
        private readonly IConnectionMultiplexer _connectionMultiplexer;
        Client _rediSearchClient;
    public SearchController(IConfiguration config, IWebHostEnvironment hostingEnvironment)
        {
            _hostingEnvironment = hostingEnvironment;
            //In real life avoid hard-coding and use secure ways to specify
            //your redis-server IP
            string sconn = "127.0.0.1:6379";
            _connectionMultiplexer = ConnectionMultiplexer.Connect(sconn);
            IDatabase db = _connectionMultiplexer.GetDatabase();           
             _rediSearchClient = new Client("index_orders", db);
           
            Schema schema = CreateSchema();
            _rediSearchClient.CreateIndex(schema, new Client.ConfiguredIndexOptions(Client.IndexOptions.Default));
           
        }
    }

The constructor in this example is responsible for:    

1. Establishing a connection to the Redis Server, using the .Net Redis Search Client (NRediSearch, courtesy - Marc Gravell and Nick Craver, StackExchange)
2. Creating an index based on a provided schema.

Note: the index can be created only once; a RedisServerException will occur if an attempt is made to create an existing index. To avoid this, the code below is used to check for a pre-existing index.

Check if Index Exists

        private async Task<bool> IndexExistsAsync(string checkIndexName)
        {
            InfoResult resultParsed = await _rediSearchClient.GetInfoParsedAsync();
            string indexName = resultParsed.IndexName;
            return (indexName == checkIndexName);
        }

We'll then change the last 2 lines of the constructor to:

            if (!IndexExistsAsync("index_orders").Result)
            {
                Schema schema = CreateSchema();
                _rediSearchClient.CreateIndex(schema, new Client.ConfiguredIndexOptions(Client.IndexOptions.Default));
            }

The code for CreateSchema is:

     private Schema CreateSchema()
    {
        Schema schema = new Schema();
        schema.AddTextField("customerID", 1)
            .AddTextField("customerName",2)
            .AddTextField("orderID", 1)
            .AddTextField("city", 1)
            .AddTextField("postalCode", 1)
            .AddNumericField("extendedPrice")
            .AddTextField("productName", 1)                   
        };
        return schema;
    }

Performing a Basic Search

Now that we have the preliminaries out of the way, let's do a basic search. for the word "Vins"   – from the Northwind Database that we transferred to Redis.  Shown below is the code used for the search.

 		[HttpGet]
        [Route("api/search/redis/v.10/basic")]
        public async Task<List<CustomerOrders>> SearchRedisOrdersBasic()
        {
            string searchString = "Vins";
            SearchResult res = await _rediSearchClient.SearchAsync(new NRediSearch.Query(searchString) { WithPayloads = true });

            List<CustomerOrders> customerOrdersList = new List<CustomerOrders>();

            foreach (Document doc in res.Documents)
            {           
                CustomerOrders _order = new CustomerOrders()
                {
                    id = doc.Id,
                    score = doc.Score,
                    customerName = (string)doc["customerName"],
                    address = (string)doc["address"],
                    customerID = (string)doc["customerID"],
                    productName = (string)doc["productName"],
                    extendedPrice = Convert.ToDecimal(doc["extendedPrice"]),
                    //.. etc
                };
                customerOrdersList.Add(_order);   
            }
            return customerOrdersList;
        }

Notes on the above code:

1. If you have been following along with the sample data, you'll notice that 10 records are ruturned. We'll cover later how to control the number of records returned by the search query.
2. We have hard-coded the search word "Vins"; in real-life you'll pass it as a parameter.
3. Only the fields that are specified in the schema are searched for a match.
4. In line 6, note that the query parameter WithPayloads is set to true. Failure to do that results in only the document id's being returned by the redis-server.
5. All properties in the above example are cast to the appropriate types. In general you don't need to do this for string fields.

Improving the Version 1.0 api of this application to handle new properties.

Unlike a traditional relational database, Redis has no fixed schema for records. Consider the POCO class CustomerOrders in our example. The sample shown above will maintain the fixed properties we have have specified in the POCO.  Now assuming after the app is released and populated with  a vast number of records, we decide to add other fields to CustomerOders – such as ShipToAddress.  To implement this, we'll have to modify codes after line #20 ( [see Route api/search/redis/v.10/basic and CustomerOrders to accommodate the changes.  At best, this is a hassle; so let's explore how to improve on the previous approach.

The sample implementation below shows a simple way to side-step all the issues involved.  It will require modifying only CustomerOrders.  Once that is done, you'll have to save new records to include the ShipToAddress.  We can then avoid headaches by using a json client (Newtonsoft.Json) to do the heavy lifting.  The code below illustrates this.

        [Route("api/search/redis/v2.0/basic")]
        public async Task<List<CustomerOrders>> SearchRedisOrdersBasicUseJson()
        {
            string searchString = "Vins";
            SearchResult res = await _rediSearchClient.SearchAsync(new NRediSearch.Query(searchString) { WithPayloads = true });

            List<CustomerOrders> customerOrdersList = new List<CustomerOrders>();

            foreach (Document doc in res.Documents)
            {
                IEnumerable<KeyValuePair<string, RedisValue>> record = doc.GetProperties();
                string jsonRecord = JsonConvert.SerializeObject(record);
                CustomerOrders custOrders = JsonConvert.DeserializeObject<CustomerOrders>(jsonRecord);
                custOrders.id = doc.Id;
                custOrders.score = doc.Score;

                customerOrdersList.Add(custOrders);  
            }
            return customerOrdersList;
        }

Only lines 12-22 (foreach bloc) are changed.  The GetProperties method (line #11) returns a Redis KeyValuePair that we serialize and convert to CustomerOrders. This bypasses the hard coding and the casting issues of v1.0.

Wild Card Searches

The searches shown so far have been based on exact word searches.  RediSearch also supports wildcard searches.  

In the sample data used in this blog, one of the products is a product named Flotemysost, To get records for this product based on a wild card search, we can modify the example full search code to this:

//use an "*" to search for words that begin with "Flotem"
string searchString = "Flotem*";      
SearchResult res = await _rediSearchClient.SearchAsync(new NRediSearch.Query(searchString) { WithPayloads = true });

The example above will return records that have words that begin with "Flotem"

You can filter search results on the server side by applying a search filter – this is similar to the SQL where clause.

The example below demonstrates how to filter the query to return only results with the extendedPrice between 160 and 350.  It also introduces the query Limit method to return only the first 5 results – this is similar to the SELECT TOP  clause of SQL.

        [HttpGet]
        [Route("api/search/orders/filter")]
        public async Task<List<CustomerOrders>> SearchOrdersFilter()
        {
            string searchString = "Vins";
            IDatabase db = _connectionMultiplexer.GetDatabase();

            NRediSearch.Query query = new NRediSearch.Query(searchString);

            //filter results on extendedPrice between 160 and 350
            query.AddFilter(new NRediSearch.Query.NumericFilter("extendedPrice", 160, 350));            
            query.Limit(0, 5); //return only the first 5 documents
            query.WithPayloads = true;
            
            SearchResult res = await _rediSearchClient.SearchAsync(query);

		//the rest of the code(below) for processing the search results 
		//is the same as shown in the earlier example(s)

            List<CustomerOrders> customerOrdersList = new List<CustomerOrders>();
            foreach (Document doc in res.Documents)
            {
                IEnumerable<KeyValuePair<string, RedisValue>> record = doc.GetProperties();
                string jsonRecord = JsonConvert.SerializeObject(record);
                CustomerOrders custOrders = JsonConvert.DeserializeObject<CustomerOrders>(jsonRecord);
                custOrders.id = doc.Id;
                custOrders.score = doc.Score;
                customerOrdersList.Add(custOrders);
            }
            return customerOrdersList;
        }

The query above filters the query to return only results where the extendedPrice is between 160 and 350.  In addition to numeric filters, RediSearch also supports GEO filters; this is not covered here.
In line 12 we limit the returned records to the first 5.  The parameters for the Limit are the 0ffset and number of records  – the default is Limit(0,10).

Restricting Search Within Fields

The default behavior of RediSearch is to search all text properties specified in the schema.  You can restrict which fields to search as shown in the code fragment below.

         //search the customerID field for the text VINET 
          string searchString = "(@customerID:VINET)"; 
          
          //search the customerName field for wild-card text Suprê*
          string searchString = "(@customerName:Suprê*)";       
          
          //search for the above 2 texts.  -- this is a UNION operation
          string searchString = "(@customerName:Suprê*) | (@customerID:VINET)";   

RediSearch has several query examples at this link.

Redis can have a large number of elements in a RediSearch document.  You can limit your search queries to return only specific elements.  (This is similar to the SQL Select col1, col2, col3 ... from..     statement).  

In this example, we modify the code to return only the following fields:

  customerID, customerName,  address,  orderID,  productName

In this code fragment, we have hard-coded items that you will normally pass in as parameters.

 public class DynamicDoc
{
    public string id { get; set; }
    public double score { get; set; }
    public Dictionary<string, object> payload{ get; set; }
}
 //**************************************************************      
        [HttpGet]
        [Route("api/search/orders/restrictfields")]
            public async Task<List<DynamicDoc>> SearchOrdersRestrictFields()
        {
            string searchString = "Queso";
            IDatabase db = _connectionMultiplexer.GetDatabase();

            NRediSearch.Query query = new NRediSearch.Query(searchString);

            string[] returnFields = { "customerID", "customerName","address", "orderID", "productName" };
           
            query.ReturnFields(returnFields);

            query.WithPayloads = true;

            SearchResult res = await _rediSearchClient.SearchAsync(query);

            List<DynamicDoc> dynamicDocs = new List<DynamicDoc>();

            foreach (Document doc in res.Documents)
            {
                IEnumerable<KeyValuePair<string, RedisValue>> record = doc.GetProperties();
                string jsonRecord = JsonConvert.SerializeObject(record);
                Dictionary<string, object> _record = JsonConvert.DeserializeObject<Dictionary<string, object>>(jsonRecord);
 
                DynamicDoc dynamicDoc = new DynamicDoc()
                {
                     id = doc.Id,
                     score = doc.Score,
                     payload = _record
                };
                dynamicDocs.Add(dynamicDoc);
            }
            return dynamicDocs;
        }

Notes on the above code

1. We create a class DynamicDoc to hold the returned record(s)
2. Lines 17-19 specify the fields to return and add it to the query.
3. The SearchResults are NOT cast to the CustomerOrders class used in the previous examples. Doing this could result in a significantly large number of unrequested null properties being returned to the caller. Instead, we cast the document record (Payload) to a Dictionary<string,object>

The returned records show only the requested fields in the payload; it looks like this;

[
    {
        "id": "northwind:orders_temp2147",
        "score": 1,
        "payload": {
            "customerID": "RATTC",
            "customerName": "Rattlesnake Canyon Grocery",
            "address": "2817 Milton Dr.",
            "orderID": "11077",
            "productName": "Queso Manchego La Pastora"
        }
    },
    {
        "id": "northwind:orders_temp2131",
        "score": 1,
        "payload": {
            "customerID": "PERIC",
            "customerName": "Pericles Comidas clásicas",
            "address": "Calle Dr. Jorge Cash 321",
            "orderID": "11073",
            "productName": "Queso Cabrales"
        }
    }
]
    

The above query will return results for all the documents that match the the query.  To restrict the query to specific documents keys we then make the following sample modifications to the code:

	string[] returnFields = { "customerID", "customerName","address", "orderID", "productName" };
	string[] limitKeys = { "northwind:orders_temp2063", "northwind:orders_temp2147" };
           
	query.LimitKeys(limitKeys);
	query.ReturnFields(returnFields);

	query.WithPayloads = true;

Notes on above

1. lines 2-4 are added to specify the document keys (ids)
2. This query is then the equivalent of the SQL:

SELECT customerID, customerName, address, orderID, productName from tablename
where documentKey IN ('northwind:orders_temp2063', 'northwind:orders_temp2147')

The code fragment below shows how we processed the search results in earlier samples.

         foreach (Document doc in res.Documents)
            {           
                CustomerOrders _order = new CustomerOrders()
                {
                    id = doc.Id,
                    score = doc.Score,
                    customerName = (string)doc["customerName"],
                    address = (string)doc["address"],
                    customerID = (string)doc["customerID"],
                    productName = (string)doc["productName"],
                    extendedPrice = Convert.ToDecimal(doc["extendedPrice"]),
                    //.. etc
                };
                customerOrdersList.Add(_order);   
            }
            return customerOrdersList;

The disadvantage of this approach is that it is bound to the CustomerOrders class.  If you have several classes to which you cast your search results, you'll have to repeat the same kind of code for every one of those classes.

We can improve the code to handle multiple classes by using a generic method to process/cast the results.  The trick is let the POCO classes inherit from the same base as shown below for the CustomerOrders class.

public class DocCommon
    {
        public string id { get; set; }
        public double score { get; set; }
    }
     public class CustomerOrders : DocCommon
   {
        public string customerID { get; set; }
        public string customerName { get; set; }
        public string address { get; set; }
        
        //etc..
   }

Armed with this definition, we can then use the sample code below to call a generic method to cast the search results.

        [HttpGet]
        [Route("api/search/orders/redis")]
        public async Task<List<CustomerOrders>> SearchRedisOrdersData()
        {
            searchString = "Vins";
            IDatabase db =   _connectionMultiplexer.GetDatabase();

            NRediSearch.Query query = new NRediSearch.Query(searchString);
            query.WithPayloads = true;

            SearchResult res = await _rediSearchClient.SearchAsync(query);
            
            List<CustomerOrders> appDocs = (from doc in res.Documents
                  select GetDocData<CustomerOrders>(doc)).ToList();            
            return appDocs;
        }

The magic happens in lines #13-14, where we use the generic method GetDocData shown below to cast the search results.

Note: the generic method is constrained to DocCommon.

        public T GetDocData<T>(Document document) where T: DocCommon    
        {
            IEnumerable<KeyValuePair<string, RedisValue>> docRecords = document.GetProperties();
            
            string jsonDocRecord = JsonConvert.SerializeObject(docRecords);
            T record = JsonConvert.DeserializeObject<T>(jsonDocRecord);
            record.id = document.Id;
            record.score = document.Score;
            return record;
        }