Explain CACHE CLIENT-SIDE STRATEGIES.

 CACHE CLIENT-SIDE STRATEGIES

1)COOKIES,

2) QUERY STRINGS,

3) HIDDEN FIELDS

1) Cookies

• A small file that is stored in the user hard drive using the client's browser.

• It stores information temporarily.

• It can be changed according to requirements.

Examples

Reading Cookie

//read cookie from IHttpContext Accessor

string cookieValueFromContext = httpContextAccessor.HttpContext.Request.Cookies["key"];

//read cookie from Request object

string cookieValueFromReq = Request.Cookies[“key"];

Remove Cookie

Response.Cookies.Delete(key);

Writing cookie

• In this example, SetCookie method show how to write cookies.

• CookieOption is available to extend the cookie behavior.

public void SetCookie(string key, string value, int? expireTime) {

CookieOptions option = new CookieOptions();

if (expireTime.HasValue)

option.Expires = DateTime.Now.AddMinutes(expireTime.Value);

else

option.Expires = DateTime.Now.AddMilliseconds(10);

Response.Cookies.Append(key, value, option);

}

2) Query String

• It is generally used for holding values

• It works temporarily

• It increases the performance of the app.

Example

We can pass a limited amount of data from one request to another by adding it to the query string of the new request. This is useful for capturing the state in a persistent manner and allows the sharing of links with the embedded state.

public IActionResult GetQueryString(string name, int age) {

User newUser = new User()

{

Name = name,

Age = age

};

return View(newUser);

}

Now let’s invoke this method by passing query string parameters:

 /welcome/getquerystring?name=John&age=31

• We can retrieve both the name and age values from the query string and display it on the page.

•  As URL query strings are public, we should never use query strings for sensitive data.

• In addition to unintended sharing, including data in query strings will make our application vulnerable to Cross-Site Request Forgery (CSRF) attacks, which can trick users into visiting malicious sites while authenticated. Attackers can then steal user data or take malicious actions on behalf of the user.

 3) Hidden Fields

• We can save data in hidden form fields and send it back in the next request.

• Sometimes we require some data to be stored on the client-side without displaying it on the page. Later when the user takes some action, we’ll need that data to be passed on to the server-side. This is a common scenario in many applications and hidden fields provide a good solution for this.

• Let’s add two methods in our WelcomeController:

[HttpGet]

public IActionResult SetHiddenFieldValue() {

User newUser = new User() {

Id = 101, Name = "John", Age = 31

};

return View(newUser);

}

[HttpPost]

public IActionResult SetHiddenFieldValue(IFormCollection keyValues) {

var id = keyValues["Id"];

return View();

}

• The GET version of the theSetHiddenValue() method creates a user object and passes that into the view.

• We use the POST version of the SetHiddenValue() method to read the value of a hidden field Id from FormCollection.

• In the View, we can create a hidden field and bind the Id value from Model:

◦ @Html.HiddenFor(model =>model.Id)

• Then we can use a submit button to submit the form:

◦ <input type="submit" value="Submit" />

• Now let’s run the application and navigate to /Welcome/SetHiddenFieldValue

• On inspecting the page source, we can see that a hidden field is generated on the page with the Id as the value: <input id="Id" name="Id" type="hidden" value="101">

• Now click the submit button after putting a breakpoint in the POST method. We can retrieve the Id value from the FormCollection.