Ashish

So I'm having 8 years of experience in dot net technology. I have great exposure on dotnet core, MVC SQL Server, And, front end technologies like Angular, and, I worked on couple of projects that involves dotnetcore, WebAPI, Angular, SQL Server. And, the current project that am working with, it's using dotnetcore web API. The version that we are using It 2. And the front end that we are using Angular with 18 version. And in, like, for the back end, they are using dotnet core web APIs. Over there, they are using for data for connecting with the database, they are all using the Generate depository pattern. That is communicating with the database and to Send the data to the front end, they are using services Suppose one request is coming, it come to a service. Service is calling, different repositories as per needed requirement. And when, evaluation of all the results, we are sending the data through service to a controller, and controller is sending response to the Client. Yeah. And, yeah, I have worked on web APIs as well. For a long time, I have been working with API, the proxy 5 to 6 years, I have a better idea how to implement the authentication authorization I know the concept of for the implementation of JWT bearer tokens. And, also, I have used the concept of refresh tokens whenever you're, suppose your bearer token's validity is for 1 hour, and after 1 hour, your, token will expire. Then with the use of refresh token, we can we can create a new, bearer tokens on the behalf of that We can perform authentication authorization. And, also, I worked on web APIs that are supporting the rule based authentications as well.

Discussing strategy for ensuring the statement Yeah. For this, we can if you are using microservices, then in API gateway, we can Put some strategy, like, if frequent calling is there, then we will avoid calling off your frequent Calling And, also, we can apply the caching technique in there are couple of, caching technique like we can use in memory caching and out memory caching Like,

Single design patterns, like, if you are using a service that you are inject injecting as a as a singleton in your IOC container. So what it will do, it will create a single instance throughout whole life cycle of the application. And, whatever object you will be invoked, it will hold a single reference. All the value will be passed as a, copy. like, we cannot create different instances, in our application. And suppose if your object is being used in thread to make we have to make that object either thread safe, otherwise, there will be a memory leak in your application. And due to that, application may causes error like, it will it will be collapsed anytime. We have to use it accordingly.

Basically, middlewares are the, chain component. like, it work like a chain. whenever request is coming, to the context, so first, middleware takes, place to execute everything. Suppose you created one middleware to execute, to get your information from your header and validate your bearer token whether it is, valid or not. So to achieve this functionality, we will create one custom middleware for that. And inside that, we will use invoking method in inside that, we will get our, bearer token from the header, and we will evaluate it whether time stamp is valid or not or your if you are using a rule based authentication, if you are calling a different you are calling a specific method that should be accessible for specific kind of rules, so it will we can do it over there. And from the middleware, we will call the next middleware, It's a chain. Until unless your last middleware will be executed, it will be there. And, also, we can create custom middleware to get our, exceptions. we can log our exceptions in our in the application also. If we want to log over the exception at the database level, we can do that from exception custom exception model where we have to inject at the top of, your configure service method to make the execution first. And if your application causes any accept your application having any exceptions, so it will go inside your, custom exception model here, and it will log it. And over there, we can get to know what kind of error it is, what kind of exception it is, and it will easy to handle.

Basically, a sync method supports the concurrent or parallel execution. Whenever you are using a sync async method, we have to use await keyword. That await keyword is, supposed to hold the resource until unless your execution will be completed. And if there is any other methods or any other, executions are there, so it will take place, And all these, processes will run current concurrently, and it will gather all the information. Suppose you are getting you are fetching a data from database and that endpoint or any third party API you are calling, it is taking much time and there are other than, there are separate code is there that needs to be executed so we can make our endpoint as async method. We can use async method over there and with await keyword, we can achieve this functionality. Your resource will be waiting for the response until unless it will get executed.

How would you manage the states in dotnetcore application in different environments. Just thinking about Suppose if your application is hosted in a different environment, then we can use the concept of caching over there. Like, we can use, Redis cache as well as we can use the concept of, SQL caching. From there, we can maintain the states into different environments as well. Yeah.

How would you approach in creating a high availability REST API using dotnetcore? So the best approach we'll be creating for a rest API that will be highly available, we must have to use, microservices over there. We can, we can inside our API gateway, we can make a pinpoint for that as well as we can use the concept of caching as well as we can restrict our w v p I for so they can't calling for a specific, for a specific line. Suppose if user is calling again and again and again within so we will, to avoid this, we can, we can make our API, handleable to handle the frequent calling, and we can apply the caching technique into our web API so that it will be highly available. The most recent data will be served instead of, instead of going to the database again and again and fetching the record from the table and send a response. So the caching technique will have help to make our rest API, rest API highly available. And, also, we can use the authentication and authorization for, in our web API so that, specific rules or specific authorized users can use our web API. And, also, at the hardware level, we will we will put our microservice in a highly configured, hardware resources so that, if, it will be more feasible to process our data, and we will use a load balancer to maintain the availability as per the load for our web APIs.

To make our code as a thread safe, we can use the locking techniques, like, we can make our object with the log that make is that will make, our code as a thread safe. Like, suppose we can suppose you are using 1 singleton class inside that to make it thread safe, so we will declare one property, like, we can use one object is equal to new object. And whenever, we are calling it, we will use lock key. we will check that object with the lock function whether your code is being, your object is being used somewhere else or not. If it is being used, so it will it will it will make it easy to, you know, this it will make accessible for that resources. Otherwise, it will create a new instance. Suppose this new instance is already there that is being used, so it will pass the same object to that, calling methods. So this is the way that we can use thread safe and also and also we can use thread safe collections like, we can use concurrent queue, concurrent stacks, concurrent bags, and there are many methods that we can use. And we can make our object immutable. And to making our object immutable, we can ensure the threat safety. And also we can use mutex. Like, it's a synchronization primitive that can be used to manage access resource across multiple, threats even and even across multiple processes. And it is a more powerful, but also slower than a lock as I told you.

New features added to you in dot net core application breaks existing functional data. So we're working through an approach for integrating this feature by ensuring backward compatibility. So we have open and close principles via using this, open for extension but closed for modification. Suppose if your class having certain features and if you are, like, if you are going to extend that class, so instead of modifying, we can extend that class. Suppose, you are using to process the interest for different, type of users in a banking system. Suppose you are processing, interest for saving account, for FD accounts, for, loan accounts. So in future, there's a requirement if you want to process, different kind of, in, interest like your, mutual funds. So instead of modifying your class, it will be easy to make that class, extensible. We will create a, interface and its implementing class to apply that functionality. Suppose we will we will, create I, we will create an interface to provide the, to provide the interest rates on different users, for calculating their interest amounts. So we will create a separate interface for that, and we will implement that interface to that class so that it will be easy to calculate as per need and the requirements. So we will create a different concrete classes for that for your mutual fund customer, for your saving cost customers, for your FD customers. We will apply. We will, implement that interface to that, class, and we will, provide the logic to append that, to provide a logic to calculate the interest rate on the behalf of your customer type. If it is, type of your mutual fund kind of customer or your, saving customer or you have the customer, so it will be easy. This will be the best approach to ensure your backward compatibility.

Public class item deposit to private. So first, problem will arise if you are finding 1 any items if it is null. So we have to, check whether your existing item is null or not. So first, we will put a check whether whenever we are provide we are accessing the existing item. If it is null, then, we will return no item found or your, exceptions. If it is not null, then we will we will apply the straightforward code. Like, we will apply the item into existing item. And, also, we will check whether items have values or not items. suppose if current items or list of items doesn't have any counts. So if it is 0, then we will, return the value as it is that no item found or whatever you want to return.

You need to optimize a critical selection of your code in molecular model. It has been identified as a performance bottleneck. Explain how would you find the problems. So first, we will apply the logger in the whole application with the time stamp, and we will thoroughly test all the endpoint or all the, all the functions, with the with the proper unit testing. And, we will analyze first all these logs and identify the code portion. Suppose your x y z function is taking much time as expected. So we will make a checklist of those functions of those areas first And 1 by 1, we will optimize them. Suppose your first program first function is calling a database. Okay. It's a it is returning a record. And, then we will go to the database and check whether tables have indexes or not. So if there is no indexes, so we'll first we will apply those indexes., 1st, apply the indexes over the table and check then check we will check other we will check the performance whether it is increased or not. And after that, if your table's having so much transactions, so we will, try to avoid the transaction and get the data. And also if, and suppose your, next function is having a problem of low latency, and it is taking much time bigger time to evaluate all the results set. So instead of, calling synchronous programming, we will try to apply asynchronous programming so that if your function or your endpoint is, consuming couple of, parallel couple of resources in a in a single sort though instead of executing 1 by 1. So while using a synchronous programming, we can make our function or, a VPI to execute parallelly and get their results, parallelly. And after evaluating everything, we will segregate the data and we can evaluate all results and send the data to the client. And, also, we can use the caching techniques, and we can use the proper, make use of proper, dependency injections if you're suppose you're stand alone or where you want that, if that, function is needs to be injected at one time, then we will singleton. Otherwise, we will