Optimizing C# Code: Improving Performance and Reducing Execution Time

This report focuses on optimizing C# code to enhance performance and reduce processing time, particularly within data processing workflows. It addresses key issues such as selecting appropriate collections, avoiding unnecessary function calls, and efficient memory management. The paper examines the optimization of open-source C# code, implementing strategies like using StringBuilder for string concatenation, reusing objects, leveraging Microsoft libraries, and considering asynchronous operations. Performance profiling is emphasized as a crucial tool for identifying and resolving bottlenecks. A case scenario demonstrates the impact of these optimizations on processing speed, showcasing improvements achieved through the implemented techniques. The report concludes with references to relevant research and resources in the field of C# performance optimization.

Performance in this paper alludes to two fundamental ideas. The first is making the
code run quicker so activities set aside less effort to finish. With regards to a web
application, this could result is quicker page burden times or quicker API reactions.
For administration specialist style applications which procedure some in-coming
information so as to create a yield, this identifies with the general throughput of
preparing. A second significant factor from my viewpoint is lessening memory use
and portions. These two ideas unite in my brain as "accomplishing more, with less".
A normal case of where I see execution being a concentration for our everyday work
is in information handling work processes. A great deal of our time is spent creating
usefulness which supports ingesting a few information, typically by means of an AWS
line, and playing out some work dependent on that message. Huge numbers of our
administrations have developed and created after some time and today are
preparing enormous volumes of information. One such model at work is a line
processor which handles around 17-20 million messages for every day. In the wake
of perusing the message, a work process forms the information, approving it,
advancing it and molding it prepared for capacity to S3 and an ElasticSearch bunch.
This procedure isn't gigantically intricate, however because of the volume, we have
periods where we need to on a level plane scale our holder examples to guarantee
we keep on accomplishing the ideal throughput. Would we be able to be
progressively proficient, would we be able to diminish the handling time and
memory utilization? I'm certain beyond a shadow of a doubt we can.
Frequently these two mainstays of performance are inherently connected and
influencing one, can influence the other. Lessening memory assignments in code, for
instance, can decrease GC burden and diminish delays brought about by the
accumulation procedure, which thus may improve the general speed. In this paper, I
have made a report of how the open source C# code found in the link:
https://github.com/Washi1337/Emux
can be optimized to reduce time of execution and improve its general perfprmance.
Reducing the processing time in a C# program requires a number of issues to
address. These are the problems which have to be worked on to improve the
processing time. They include;
Choosing the best collection according to purpose. .NET developers are very much
familiar with collections in C# and their use here and their purpose to store values-
they must be the best in order to reduce searching time.
Avoiding the use of functions when not necessary. In C# the more functions you
implement, the more time it will take to run the program. Inside visual studio, you

can check on any function and its CPU usage as follows:
Double tap on a function that you are keen on, and you will see an increasingly point
by point three-sheet "butterfly" view, with the chose capacity amidst the window,
the calling capacity on the left, and called works on the right. The Function Body
segment demonstrates the aggregate sum of time (and the level of time) spent in
the capacity body barring time spent in calling and called capacities. This information
can enable you to assess whether the capacity itself is a presentation bottleneck.
Result.
Get rid of new operators when creating integer variables?
Removing try-Catch within loop
Made Cache of items that result from a query:
private Item _myResult;
public Item Result
{ get
{
if (_myResult == null)
{
_myResult = Database.DoQueryForResult();
}
return _myResult;
}
}

Chose the best collection using using System.Collections.Generic; inside settings.cs
Ie;
Implicitly declaring all variables before using them. Eg:
Other simple steps to note to improve the processing time for this C# program
include;
Use StringBuilder instead of bunches of string connection. String items are nuclear,
and any change (annexing, to-upper, cushioning, and so on) really produce a totally
new string article instead of adjusting the first. Each new string must be apportioned
and in the long run trash gathered.
A speculation of the earlier explanation: Try to reuse questions as opposed to

making parts and bunches of them. Designation and trash gathering might be
anything but difficult to do, yet they hit your exhibition.
Make sure to utilize the gave Microsoft libraries to generally things. The classes given
by the Framework frequently use includes that are inaccessible or hard to access
from your own C# code (for example making shouts to the local Windows API). The
implicit libraries are not generally the most proficient, yet as a general rule.
Composing nonconcurrent applications has never been simpler. Investigate things
like the BackgroundWorker class.
Make an effort not to characterize Structs except if you truly need them. Class
example factors each hold a reference to the genuine occasion, while struct
occurrence factors each hold a different duplicate.
Moreover, We must implement a Performance profiler to monitor the program
performance in visual studio. A performance profiler is your Chef's Knife with regards
to execution. You can utilize it to distinguish execution issues and pinpoint to the
particular reason.
A performance profiler enables you to record a piece of your program runtime, spare
it as a depiction, and research it. You will almost certainly observe:
Time spent in every method
Time in requests of SQL
Time for different I/O solicitations File and Network
Time trash gathering
Time in JIT compile
Time trusting that a lock will discharge
Time in WPF/WinForms code (estimating, rendering, … )
Time in Reflection code

Case scenario and results:
Processing Speed Test
After time= 0.0173580 seconds
Processing Speed Before :0.219 seconds

References
De Luca, G., & Mian, S. (2017, March). Improving Multithreaded Performance
Algorithmically in VIPLE. In 2017 IEEE 13th International Symposium on Autonomous
Decentralized System (ISADS) (pp. 249-254). IEEE.
Kaur, R. (2018). Data Analytics for Employees Dashboard to Improve Efficiency and
Performance of Employees (Doctoral dissertation).
Quille, K., & Bergin, S. (2016, December). Does Scratch improve self-efficacy and
performance when learning to program in C#? An empirical study. In Proceedings of
the International Conference on Engaging Pedagogy, Dublin, Ireland (pp. 13-14).
Wagner, B. (2017). More Effective C# (Includes Content Update Program): 50 Specific
Ways to Improve Your C. Addison-Wesley Professional.