1. Records: C# 9 introduces a new type called records, which are lightweight classes that are designed for data modeling. Records automatically provide features such as immutability, equality and copy semantics.

Copy coderecord Person {
    public string FirstName { get; init; }
    public string LastName { get; init; }
}

2. Init-only properties: C# 9 allows you to define properties that can only be set during object initialization, making it easy to create immutable types.

Copy codeclass Point {
    public int X { get; init; }
    public int Y { get; init; }
}

3. Top-level statements: C# 9 allows you to use statements at the top level of a file, without requiring a class or method.

Copy codeusing System;

Console.WriteLine("Hello, World!");

4. Target-typed new expressions: C# 9 allows you to use the „new“ keyword without specifying the type of the object being created.

Copy codevar point = new (1, 2);

5. Improved pattern matching: C# 9 introduces several new pattern matching features, such as the „and“ pattern, the „or“ pattern, and the „not“ pattern.

Copy codeif (shape is not Circle)
{
    // Do something
}

6. Improved target-typed conditional expressions and null-coalescing expressions.
7. Support for asynchronous streams.
8. Improved support for immutable types with init setter.

C# 9 aims to simplify the language and reduce the amount of boilerplate code required, making it more productive and easier to work with. These new features should help to improve the developer experience while also increasing the expressiveness and maintainability of the code.

Der Beitrag What is new in C# 9 erschien zuerst auf NDDTs Webdevelopment.

1. Use the „using“ statement when working with resources that implement IDisposable, such as file streams and database connections.

Copy codeusing (FileStream fs = new FileStream("file.txt", FileMode.Open))
{
    // Do something with the file stream
}

2. Avoid using the „as“ operator, as it can cause significant performance overhead. Instead, use the „is“ operator to check the type of an object, and then cast it explicitly.

Copy codeobject obj = "Hello";
if (obj is string)
{
    string str = (string)obj;
    Console.WriteLine(str);
}

3. Use structs instead of classes when working with small, value-type data. Structs are stored on the stack and do not require memory allocation, while classes are stored on the heap and require memory allocation.

Copy codestruct Point
{
    public int X;
    public int Y;
}

4. Avoid using „string“ for large amounts of text, use StringBuilder instead.

Copy codeStringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++)
{
    sb.Append("Hello");
}
string result = sb.ToString();

5. Avoid using „foreach“ loops when working with large collections. Instead, use „for“ loops, as they offer better performance.

Copy codefor (int i = 0; i < list.Count; i++)
{
    Console.WriteLine(list[i]);
}

6. Use the „lock“ statement when working with shared resources to avoid race conditions.

Copy codeprivate static object _lock = new object();

public static void Add(int value)
{
    lock (_lock)
    {
        _list.Add(value);
    }
}

7. Avoid using reflection, as it can be slow. Instead, use pre-generated code or code generation tools.

Copy codeType t = typeof(MyClass);
MethodInfo method = t.GetMethod("MyMethod");
method.Invoke(null, null);

8. Use the „unsafe“ keyword when working with pointers and unmanaged code, as it allows for direct memory access and can greatly improve performance.

Copy codeunsafe static void Main()
{
    int* p = stackalloc int[100];
    for (int i = 0; i < 100; i++)
        p[i] = i;
}

9. Use the „async“ and „await“ keywords when working with asynchronous code to improve performance and responsiveness of your application.

Copy codeprivate async Task<int> GetDataAsync()
{
    HttpClient client = new HttpClient();
    var data = await client.GetStringAsync("https://www.example.com");
    return data.Length;
}

10. Profile your application to identify performance bottlenecks and optimize the code accordingly.

Example: Using Visual Studio Profiler, you can profile your application to track the execution time of methods and identify where

Der Beitrag Performance Tipps in C# erschien zuerst auf NDDTs Webdevelopment.

One of the most commonly used classes in the System.Text.RegularExpressions namespace is the Regex class. This class allows you to create a regular expression object, which can be used to match strings against a specified pattern. For example, the following code creates a regular expression object that matches strings that contain the word „hello“:

Copy codeRegex helloRegex = new Regex("hello");

You can use the IsMatch() method of the Regex class to determine if a string matches the pattern specified by the regular expression. For example, the following code checks if the string „hello world“ contains the word „hello“:

Copy codestring input = "hello world";
if (helloRegex.IsMatch(input))
{
    Console.WriteLine("The input contains the word 'hello'");
}

In addition to matching patterns, regular expressions can also be used to perform replacements. The Replace() method of the Regex class can be used to replace all occurrences of a specified pattern with another string. For example, the following code replaces all occurrences of the word „hello“ with „goodbye“ in the input string:

Copy codestring replaced = helloRegex.Replace(input, "goodbye");
Console.WriteLine(replaced); // Outputs "goodbye world"

You can use the Split() method of the Regex class to split a string into an array of substrings based on a specified pattern. For example, the following code splits the input string on spaces:

Copy codestring[] words = helloRegex.Split(input);
foreach (string word in words)
{
    Console.WriteLine(word);
}
// Outputs "hello" and "world"

Regular expressions can also be used to validate the format of strings, such as email addresses, phone numbers, and so on. The IsMatch() method can be used to check whether a string matches a specific pattern, such as the pattern for an email address.

Copy codestring email = "user@example.com";
Regex emailRegex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
if (emailRegex.IsMatch(email))
{
    Console.WriteLine("The email is valid.");
}
else
{
    Console.WriteLine("The email is not valid.");
}

TLDR: Regular expressions are a powerful tool for working with text and data in C#. The System.Text.RegularExpressions namespace provides a set of classes for working with regular expressions, including the Regex class, which can be used to match, replace, and validate strings. Regular expressions can save lot of time, and can be very handy in situations where text parsing is needed.

Der Beitrag Regular Expressions in C# erschien zuerst auf NDDTs Webdevelopment.