Darshan Lakhwani

My name is. I have 8 years of experience in IT. Currently, I am working as a senior software developer in my current organization, Amdocs. So I joined this company in 2016, and I have been working here since then. I have 7 years of knowledge in.NET, where I work with.NET Core and the.NET Framework, let's say, 4.5 or 4.7. And, I have experience with the Angular framework as well, starting from AngularJS to Angular 10. In a database side, I have worked with the SQL database. So, I have a strong background in both DB knowledge. Currently, I've had the opportunity to work with Elastic as well. With Elastic, we were trying to improve the performance of our search part of the project. And, I got the chance to work with the ELK Stack, including Kibana, where I monitored the system using open source technologies. Let's say, and I created the entire modeling solution based on that.

So in order to optimize the inquiry, I need to make sure that I am going to perform the link queue on the proper indexes. If the indexing has not been added to the particular records, Mister Paul, I will define the indexes of the project on the database column itself. In order to improve performance on the C# side, I will make sure that I'm not fetching fields that are not necessarily required. I will also consider using IIN because it will execute when it's needed. So instead of using dot2 to fetch data records from the first glance, I will make sure that it will exclude the data when you're actually going to perform something with the dataset. I will try to give as many filters as possible on that link using the where clause or any other default. I will make sure that I will use take and skip properly so that I don't fetch a bulk load of data from the database. That's what I can think of.

In order to scale the REST API, I will make sure that the proper upgrades have been done so that if I go from version 1 to version 2. There is no loss of data in a transition. There is no change in terms of 1 to 2, meaning the user can still work with the first API the way it was working. And this way, I can make sure that the new logic is available in the newer version of the APIs. I will try to make sure that I'm not exposing unnecessary parameters and fields while sending the data back to the user or to the client. We'll try to ensure that we have a proper pagination. It's implemented over the APIs so that it is not fetching a bulk load of data from the backend. It gets the data in a paginated way. If possible, we will try to implement the cache mechanism as well so that we are not fetching unnecessary data back from the database. First, we'll see if the data is available in the cache side. So let's retrieve it from the cache. Otherwise, it will fetch it from the database itself. And in order to maintain the APIs, we'll try to have a proper documentation so that we know what this API requires in order to send the parameters. If needed, we can use the draft tool so that we can bring the required fields, not all.

So parallelism, you decide how much threads will run in parallel, and the concurrency is moreover the number of threads. I can say in the transaction when you're forming certain transitions. So currently, only one is supposed to happen, one should commit, then the next will happen. I can relate this use case with the concurrency where the end user who is going to do the transaction from the portal. So they are able to work concurrently with the portal. And if certain resources are important in terms of thread-wise, the talent prism will make sure that the resources are allocated properly, meaning if I define that only one thread will partner, will execute a certain task, and others will wait until that thread is available.

So in order to avoid the various conditions from happening, I will try to implement the proper locking mechanism that if I know that a certain task requires will be completed on that certain task when it will be completed. So we'll try to put this logic in a norm so that no one will be able to execute the same code in a different thread. Thus, I will try to have a check if it is a task that I created, so I will try to wait until all the tasks that I created have been completed, then I should return. So for that, I will use the task dot then all function to wait until all the tasks that I created have got completed before executing the below logic.

So async behaves in an asynchronous behavior as the word is saying. Means when you execute, click on any button, and then let's say it is going to call us with an API, which is going to take around 10 seconds to come complete that task. So for that 10 second user doesn't have to wait. Basically, API will respond back to you when the response will be available. This is the example of async. So I will use the async where the input from the server is not required straight away. It is required when, actually, it will be ready. So the best case scenario of the async is the email. When you send an email to that particular person, we're not expecting that the email response will be sent back to you in the same second. The response from the user can be when he or she will be available. So she will respond back to me. So we'll use the async method where the response is not required from the server immediately. And I will use the async method where it is creating a catalog on the right side, meaning if a certain task is taking 1 or 2 minutes, we'll use the async there so that like, the user will not wait for that certain task to be completed. And I will inform the user that this activity is going on so that he will know that this activity data will be back to them when it will be ready.

By looking at this code, what I can see is that The item, we did not have a proper null check because the item can be null as well, if we are going to perform item ID. And if the item itself is null, it can give you an object reference error because we did not perform the null operation well. And if the first or default, let's say if the item is not null, it had a proper value. And if we did not get any value from the 1st or default, so we are going to receive in the existing item the value null because the first or default can return null as well. And now in the next line, we are initializing null equal to item. So this way, it will give you an error because it's not being initialized properly.

I'm not able to delete this question.

In order to protect the MySQL injection attack, I will try to sanitize the input that is coming to the data to the API. Means, let's say, if I have one API, let's call it get employee. And there, I have a string employee name. So attackers can possibly pass in that string the entire SQL query, so which can harm my database and can delete the data or do any manipulation with my database. You know? So I will try to sanitize that incoming parameter to the API. I will see that it's not been harmful data that's been sent to the API. Next, I will try to use the proper drivers. I will not have an inline query written so that it will not execute the queries in line. Queries will execute through the driver itself. Means, if I am using the entity framework driver in order to execute the queries on the data sales itself, not on directly writing the queries or making a plain text.

So the factory method design pattern is, can be used when I need to create, let's say, in my project, we had, like, we were using a collection in order to get the data from RabbitMQ. So I will create a factory class for my RabbitMQ connections. And, like, because I don't need to create the connection object multiple times, it should only be created once, or else if there is any distortion with the connection, meaning if it got lost, in case of reconnection, but it should not create multiple instances of that class. So I'll use the factory method there.

So considering a way it is useful to not wait in a deadlock state means considering the call on the one part button, which calls a certain API. Let's say calling it's going to take all employee data, and this is taking a much amount of time on the back end. So I will use the configure await method here so that it will not put the user in a deadlock state on the front end side, so that he can work on different tasks itself as well.