Adding Search

https://docs.asp.net/en/latest/tutorials/first-mvc-app/search.html

In this section you’ll add search capability to the Index action method that lets you search movies by genre or name.

Update the Index action method to enable search:

public async Task<IActionResult> Index(string searchString)
        {
            var movies = _context.Movie.Select(x => x);

            if (string.IsNullOrEmpty(searchString) == false)
            {
                movies = movies.Where(x => x.Title.Contains(searchString));
            }

            return View(await movies.ToListAsync());
        }

上面第一行代码，还可以改为

 var movies = from m in _context.Movie
                 select m;

The first line of the Index action method creates a LINQ query to select the movies:

The query is only defined at this point, it has not been run against the database.

If the searchString parameter contains a string, the movies query is modified to filter on the value of the search string, using the following code:

 if (string.IsNullOrEmpty(searchString) == false)
            {
                movies = movies.Where(x => x.Title.Contains(searchString));
            }

The x => x.Title.Contains() code above is a Lambda Expression.

Lambdas are used in method-based LINQ queries as arguments to standard query operator methods such as the Where method or Contains used in the code above.

LINQ queries are not executed when they are defined or when they are modified by calling a method such as Where, Contains or OrderBy.

Instead, query execution is deferred, which means that the evaluation of an expression is delayed until its realized value is actually iterated over or the ToListAsync method is called.

For more information about deferred query execution, see Query Execution.     //延迟加载

Note:

The Contains method is run on the database, not the c# code above.

On the database, Containsmaps to SQL LIKE, which is case insensitive.  //不区分大小写

Navigate to /Movies/Index. Append a query string such as ?searchString=ghost to the URL. The filtered movies are displayed.

If you change the signature of the Index method to have a parameter named id, the idparameter will match the optional {id} placeholder for the default routes set in Startup.cs.

app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });

You can quickly rename the searchString parameter to id with the rename command.

Right click on searchString > Rename.

Change the parameter to id and all occurrences of searchString change to id.

You can now pass the search title as route data (a URL segment) instead of as a query string value.

However, you can’t expect users to modify the URL every time they want to search for a movie.

So now you’ll add UI to help them filter movies.

If you changed the signature of the Index method to test how to pass the route-bound ID parameter, change it back so that it takes a parameter named searchString:

添加一个Filter进行过滤

Open the Views/Movies/Index.cshtml file, and add the <form> markup highlighted below:

@{
    ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
    <a asp-action="Create">Create New</a>
</p>

<form asp-controller="Movies" asp-action="Index">
    <p>
        Title: <input type="text" name="SearchString">
        <input type="submit" value="Filter" />
    </p>
</form>

<table class="table">

The HTML <form> tag uses the Form Tag Helper, so when you submit the form, the filter string is posted to the Index action of the movies controller.

Save your changes and then test the filter.

There’s no [HttpPost] overload of the Index method as you might expect.

You don’t need it, because the method isn’t changing the state of the app, just filtering data.

You could add the following [HttpPost] Index method.

[HttpPost]
public string Index(string searchString, bool notUsed)
{
    return "From [HttpPost]Index: filter on " + searchString;
}

The notUsed parameter is used to create an overload for the Index method.

We’ll talk about that later in the tutorial.

If you add this method, the action invoker would match the [HttpPost] Index method, and the[HttpPost] Index method would run as shown in the image below.

[HttpPost]
        public string Index(string searchString, bool notUsed)
        {
            return "From [HttpPost]Index: filter on " + searchString;
        }

这个方法添加之后，保存。然后重新刷新界面，再用ghost进行filter过滤，会出现下图

However, even if you add this [HttpPost] version of the Index method, there’s a limitation in how this has all been implemented.

Imagine that you want to bookmark a particular search or you want to send a link to friends that they can click in order to see the same filtered list of movies.

Notice that the URL for the HTTP POST request is the same as the URL for the GET request (localhost:xxxxx/Movies/Index) – there’s no search information in the URL.

The search string information is sent to the server as a form field value.

You can verify that with the F12 Developer tools or the excellent Fiddler tool.

Start the F12 tool:

 

You can see the search parameter and XSRF token in the request body.

Note, as mentioned in the previous tutorial, the Form Tag Helper generates an XSRF anti-forgery token.

We’re not modifying data, so we don’t need to validate the token in the controller method.

Because the search parameter is in the request body and not the URL, you can’t capture that search information to bookmark or share with others.

We’ll fix this by specifying the request should be HTTP GET. Notice how intelliSense helps us update the markup.

<form asp-controller="Movies" asp-action="Index" method="get">
    <p>
        Title: <input type="text" name="SearchString">
        <input type="submit" value="Filter"/>
    </p>
</form>

Notice the distinctive font in the <form> tag. That distinctive font indicates the tag is supported byTag Helpers.

Now when you submit a search, the URL contains the search query string.

Searching will also go to the HttpGet Index action method, even if you have a HttpPost Index method.

Adding Search by Genre

Add the following MovieGenreViewModel class to the Models folder:

  public class MovieGenreViewModel
    {
        public List<Movie> Movies;

        public SelectList Genres;

        public string MovieGenre { get; set; }
    }

The move-genre view model will contain:

• a list of movies
• a SelectList containing the list of genres. This will allow the user to select a genre from the list.
• movieGenre, which contains the selected genre

Replace the Index method with the following code:

public async Task<IActionResult> Index(string movieGenre,string searchString)
        {
            var movies = _context.Movie.Select(x => x);

            var genres = movies.Select(x => x.Genre).Distinct();

            if (string.IsNullOrEmpty(searchString) == false)
            {
                movies = movies.Where(x => x.Title.Contains(searchString));
            }

            if (string.IsNullOrEmpty(movieGenre)==false)
            {
                movies = movies.Where(x => x.Genre == movieGenre);
            }

            MovieGenreViewModel movieGenreViewModel = new MovieGenreViewModel();
            movieGenreViewModel.Genres = new SelectList(await genres.ToListAsync());
            movieGenreViewModel.Movies = await movies.ToListAsync();

            return View(movieGenreViewModel);
        }

Adding search by genre to the Index view

@model MovieGenreViewModel

@{
    ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
    <a asp-action="Create">Create New</a>
</p>

<form asp-controller="Movies" asp-action="Index" method="get">
    <p>
        <select asp-for="MovieGenre" asp-items="Model.Genres">
            <option value="">All</option>
        </select>

        Title: <input type="text" name="SearchString">
        <input type="submit" value="Filter" />
    </p>
</form>

<table class="table">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.Movies[0].Genre)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Movies[0].Price)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Movies[0].ReleaseDate)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Movies[0].Title)
            </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model.Movies)
        {
            <tr>
                <td>
                    @Html.DisplayFor(modelItem => item.Genre)
                </td>
                <td>
                    @Html.DisplayFor(modelItem => item.Price)
                </td>
                <td>
                    @Html.DisplayFor(modelItem => item.ReleaseDate)
                </td>
                <td>
                    @Html.DisplayFor(modelItem => item.Title)
                </td>
                <td>
                    <a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
                    <a asp-action="Details" asp-route-id="@item.ID">Details</a> |
                    <a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Test the app by searching by genre, by movie title, and by both.