Tips and tricks in C# .NET
August 2, 2017 Leave a comment
The CultureInfo class has a static method to retrieve the supported locales on the user’s machine:
CultureInfo[] supportedCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
The GetCultures method accepts a CultureTypes enumeration:
August 1, 2017 Leave a comment
Performance counters in Windows can help you with finding bottlenecks in your application. There’s a long range of built-in performance counters in Windows which you can view in the Performance Monitor window:
Right-click anywhere on the larger screen to the right and select Add Counters to add your counters to the graph. The Add Counters window will show the categories first. You can then open a category and select one or more specific counters within that category. The graph will show the real-time data immediately:
July 31, 2017 Leave a comment
The Process object in the System.Diagnostics namespace refers to an operating-system process. This object is the entry point into enumerating the processes currently running on the OS.
This is how you can find the currently active process:
Process current = Process.GetCurrentProcess(); Console.WriteLine(current);
…which will yield the name of the process running this short test code.
July 30, 2017 Leave a comment
ES6 comes with a syntactic enhancement of declaring functions using the => operator. It’s commonly called the fat arrow operator. In fact it’s not only syntactic sugar that saves us a number of characters. Instead, it helps us avoid the “TypeError: Cannot read property ‘propertyName’ of undefined” error.
Here’s a traditional JavaScript function:
July 29, 2017 Leave a comment
ES6 comes with a number of helper methods that can be applied to arrays. One of these is called some which returns true if at least one element in an array fulfils the specified condition and false otherwise. If you’re familiar with C# and LINQ then the some function is very similar to the Any LINQ extension method.
Let’s see an example.
July 28, 2017 Leave a comment
It happens that we have a LINQ statement where we want to refer to partial results by variable names while expressing some computation. The “let” keyword lets us do that. Those who are familiar for the F# language already know that “let” is an important keyword to bind some value to a variable.
Suppose we have the following list of integers:
List<int> integers = new List<int>()
{
5, 7, 4, 6, 10, 4, 6, 4, 5, 12
};
July 27, 2017 Leave a comment
In this post we saw a basic hashing technique using a password and a salt. We added an extra random set of bytes to the password and hashed the combined byte array instead of just the password bytes. We can store the salt along with the hash in our database. The main purpose of adding a salt to the password is to increase its entropy which more or less means randomness.
Hashing the password with an extra salt like that may still not be as secure as we think it is. The processing power of today’s fast computers and the increasing size of available rainbow tables keep pushing the limits of what’s available to crack with brute force attacks. One way to increase the difficulty of cracking a password is to keep hashing its hash in an iterative manner. Password-based key derivation functions help us achieve that and we’ll see an example of their usage in this post.
July 26, 2017 Leave a comment
As you know primitive numeric types in C# – and other modern programming languages – have maximum and minimum values that can be stored in memory. If you’re trying to store a larger number in the variable then you’ll get an overflow with unexpected results.
Let’s see an example with the “byte” type. It is actually not one of the primitive types, like int or long, but simply a keyword for an integral type to store the numbers 0-255. Why 255? 1 byte consists of 8 bits and 8 bits in the computer’s memory allows us to store 255 as the highest number. 255 in binary is all 1’s for all 8 bits:
11111111
What happens if we add 1 to that? On paper we can easily solve it by some basic binary maths:
11111111
+ 00000001
===========
100000000
July 25, 2017 Leave a comment
The Array class has a number of useful static methods. A group of them is used for searching purposes. The method names are generally quite descriptive. Here are some them with comments in the code:
string[] bands = new string[6] { "Queen", "ACDC", "Metallica", "Genesis", "INXS", "Motörhead" };
//find the first entry in the array which starts with Q, finds "Queen"
string firstBandStartingWithQ = Array.Find<string>(bands, s => s.StartsWith("Q"));
//finds last entry start with M, finds Motörhead
string lastBandStartingWithM = Array.FindLast<string>(bands, s => s.StartsWith("M"));
//finds Metallica and Motörhead and puts them in an array
string[] allWithM = Array.FindAll<string>(bands, s => s.StartsWith("M"));
//index will be 0 as Queen is the first item in the array
int queenIndex = Array.FindIndex<string>(bands, s => s == "Queen");
//yields true as ACDC figures in the array
bool acdIsThere = Array.Exists<string>(bands, s => s == "ACDC");
View all various C# language feature related posts here.
July 24, 2017 1 Comment
Introduction
Extension methods in C# allow you to extend the functionality of types that you didn’t write and don’t have direct access to. They look like integral parts of any built-in classes in .NET, e.g.:
DateTime.Now.ToMyCustomDate(); string.ToThreeLetterAbbreviation();
You can extend the following types in C#:
You can extend public types of 3rd party libraries. You can also extend generic types, such as List of T and IEnumerable of T. You cannot extend sealed classes.
A directory of wonderful thoughts
Web development
Various tidbits
WEB APPLICATION DEVELOPMENT TUTORIALS WITH OPEN-SOURCE PROJECTS
ARCHIVED: Bite-size insight on Cyber Security for the not too technical.
Exercises in .NET with Andras Nemes 