İlkay İlknur

The New Code Analyzers In .NET 6

I think code analyzers and fixers are one of the most powerful features in the .NET ecosystem. You can implement your own or use the existing ones to write more reliable and performant code.

In this post, we're going to look at the new code analyzers coming with .NET 6.

Quick reminder: By default most of the new analyzers are enabled at Info level. You can enable these analyzers at Warning level by configuring the analysis mode like this: <AnalysisMode>AllEnabledByDefault</AnalysisMode>.

Do not call Task.WhenAll with a single argument

Instead of calling Task.WhenAll method with a single argument, we can directly await the task.

var task = SomeAsyncOperation();
await Task.WhenAll(task);
//Await the task instead of Task.WhenAll
await task;

Do not call Task.WaitAll with a single argument

Instead of calling Task.WaitAll method with a single argument, we can use Task.Wait.

var task = SomeAsyncOperation();
Task.WaitAll(task);
//Use Task.Wait instead of Task.WaitAll
task.Wait();

Use the new Environment.ProcessPath property to get the process path

.NET 6 introduces a new API(Environment.ProcessPath) to get the process path. We can use it instead of Process.GetCurrentProcess().MainModule.FileName.

var pPath = Process.GetCurrentProcess().MainModule.FileName;
//Use Environment.ProcessPath instead of Process.GetCurrentProcess().MainModule.FileName 
pPath = Environment.ProcessPath;

Use Environment.CurrentManagedThreadId to get the managed thread Id

Environment.CurrentManagedThreadId is more compact and efficient replacement of Thread.CurrentThread.ManagedThreadId.

var threadId = Thread.CurrentThread.ManagedThreadId;
//Use Environment.CurrentManagedThreadId instead of Thread.CurrentThread.ManagedThreadId  
threadId = Environment.CurrentManagedThreadId;

Use String.Contains(char) instead of String.Contains(String)

It is efficient to replace calls to String.Contains(String) method with string arguments containing a single char.

var testStr = "Test";
var contains = testStr.Contains("t");
//Use String.Contains(char) instead of String.Contains(string)
var contains = testStr.Contains('t');

Replace Dictionary<,>.Keys.Contains calls to ContainsKey

Using ContainsKey or ContainsValue methods are more performant options when we want to check if a dictionary contains a key or value.

var dictionary = new Dictionary<string, string>();
var containsKey = dictionary.Keys.Contains("test");
//Use ContainsKey
containsKey = dictionary.ContainsKey("test");

var containsValue = dictionary.Values.Contains("test");
//Use ContainsKey
containsValue = dictionary.ContainsValue("test");

Use span-based string.Concat to avoid allocations

We can use the span-based string.Concat method in some string concatenation patterns and avoid unnecessary allocations.

var testStr = "Test";
var newStr = testStr + testStr.Substring(2) + testStr.Substring(2, 1);
//Use span-based String.Concat
newStr = string.Concat(testStr, testStr.AsSpan(2), testStr.AsSpan(2, 1));

Use string.AsSpan() instead of string.Substring() when parsing

We can use string.AsSpan method when calling parsing methods and avoid the allocation caused by the string.Substring method.

var str = "1234566";
var builder = new StringBuilder();
builder.Append(str.Substring(1));

//Replace Substring with AsSpan
builder.Append(str.AsSpan(1));

Call async methods when in an async method

We can use async APIs in task returning async methods.

For example,

async Task SomeAsyncOperation(FileStream str)
{
    str.Read(buffer, 0, 10);

    //Prefer ReadAsync
    await str.ReadAsync(buffer, 0, 10);
}

Prefer String.Equals instead of String.Compare for equality checks

It is more readable to use String.Equals for equality checks instead of calling String.Compare and checking the result.

Consider the following code.

var str1 = "1234566";
var str2 = "Test";

if(string.Compare(str1,str2) == 0)
{

}

We can write the same logic with string.Compare method.

var str1 = "1234566";
var str2 = "Test";

if(string.Equals(str1, str2))
{

}

var str1 = "1234566";
var str2 = "Test";

if(string.Equals(str1, str2))
{

}

Warn developers when calling Buffer.BlockCopy

Buffer.BlockCopy method expects the number of bytes to be copied for the count argument. So passing Array.Length could cause unexpected results.

Warn developers when unknown platform names are used

When developers use SupportedOSPlatform, UnsupportedOSPlatform attributes or OperatingSystem.IsPlatform(), OperatingSystem.IsPlatformVersionAtLeast() methods, they pass string literals for OS platform names. The new analyzer checks these usages and warns developers if an unknown flatform name is used.

See you next time!

CallerArgumentExpression Attribute In C# 10

Caller information attributes are one of the useful ways to obtain caller information to a method in C#. C# 10 brings a new member to the caller information attributes.

Before mentioning the new member, let's see why the team had decided to implement it.

Consider we have a Exists method with multiple assertions.

bool Exists(string[] array, int index)
{
    Debug.Assert(array != null);
    Debug.Assert(index >= 0);

    return true;
}

When we call the Exists method with an invalid argument such as a null array, the Debug.Assert throws an exception, and the exception stack trace includes file path, line number, and method name.

Process terminated. Assertion failed.
   at Program.<<Main>$>g__Exists|0_0(String[] array, Int32 findIndex) in C:\Users\ilkay\source\repos\ConsoleApp34\ConsoleApp34\Program.cs:line 11
   at Program.<Main>$(String[] args) in C:\Users\ilkay\source\repos\ConsoleApp34\ConsoleApp34\Program.cs:line 7

C:\Users\ilkay\source\repos\ConsoleApp34\ConsoleApp34\bin\Debug\net6.0\ConsoleApp34.exe (process 10336) exited with code -2146232797.
Press any key to close this window . . .

As you see, the stack trace isn't very helpful, and we need to open the source code and find the related line to see which assertion has failed. However, it would be great to see the failed expression in the exception message.

In C# 10, you can use the new CallerArgumentExpression attribute and capture the expression passed to a method. Let's write a simple Assert method using the CallerArgumentExpression attribute and use it in the Exists method.

void Assert(bool condition, [CallerArgumentExpression("condition")] string expression = default)
{
    if (!condition)
    {
        Console.WriteLine($"Condition has failed. Condition={expression}");
    }
}

bool Exists(string[] array, int index)
{
    Assert(array != null);
    Assert(index >= 0);

    return true;
}

Calling the Exists method with a null array argument will produce the following output in the console.

Condition has failed. Condition=array != null

.NET 6 introduces a new null checking API(ArgumentNullException.ThrowIfNull) that uses the CallerArgumentExpression to obtain the expression passed to the method.

Source code of the ThrowIfNull method.

public class ArgumentNullException : ArgumentException
{
    /// <summary>Throws an <see cref="ArgumentNullException"/> if <paramref name="argument"/> is null.</summary>
    /// <param name="argument">The reference type argument to validate as non-null.</param>
    /// <param name="paramName">The name of the parameter with which <paramref name="argument"/> corresponds.</param>
    public static void ThrowIfNull([NotNull] object? argument, [CallerArgumentExpression("argument")] string? paramName = null)
    {
        if (argument is null)
        {
            Throw(paramName);
        }
    }

    [DoesNotReturn]
    private static void Throw(string? paramName) =>
        throw new ArgumentNullException(paramName);
}

As you see, it is so easy to obtain the expression information passed to a method in C# 10. I think testing and validation libraries will use the CallerArgumentExpression attribute to provide more meaningful assertion messages in the coming releases.

See you next time!

How To Convert Block Scoped Namespaces To File Scoped Namespaces

One of the themes of .NET 6 is writing less boilerplate code and helping developers focus on their code instead of ceremony coming with the programming language and the framework. The file scoped namespaces feature is one of C# 10 features that we can consider under that theme.

Visual Studio offers a fix to convert a block-scoped namespace to a file scoped namespace. However, you can only apply it for the current document. Therefore, it's not possible to fix all occurrences in a project or a solution.

On the other hand, it is possible to convert a file scoped namespace to a block-scoped namespace and fix all occurrences in a project or a solution.

This is how the refactoring/fix pair works. The default namespace declaration preference is block scoped. So, Visual Studio provides refactoring for converting file scoped namespaces to block-scoped namespaces.

There are a couple of ways to change the default namespace declaration preference.

.editorconfig File

If your project or solution contains a .editorconfig file, you can add the following line and make the file scoped namespaces the default preference.

csharp_style_namespace_declarations = file_scoped

After adding the line, Visual Studio will offer the "Convert to file-scoped namespace" refactoring and you can fix all occurrences in a project or a solution.

Changing Visual Studio Code Style Preference

If your project doesn't contain a .editorconfig file or you look for an alternative way, you can change the code-style preference in Visual Studio globally so that namespace preference applies to all projects that you work on. To change the preference globally, open the Options window(Tools=>Options). Navigate to the C# code style preferences by clicking Text Editor=>C#=>Code Style and then change the related preference.

I hope this post helps you to adapt to the new features coming with C# 10.

Record Structs In C# 10

One of the most significant additions to C# 9 was records. Records help us to implement immutable types with value-based equality semantics.

Declaring a record type is pretty straightforward. First, let's declare a record type using the positional syntax.

public record Person(string Name, string Surname, int Age);

Below is how the compiler rewrites when compiling the record type declared above.

public class Person : IEquatable<Person>
{
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly string <Name>k__BackingField;

    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly string <Surname>k__BackingField;

    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly int <Age>k__BackingField;

    [System.Runtime.CompilerServices.Nullable(1)]
    protected virtual Type EqualityContract
    {
        [System.Runtime.CompilerServices.NullableContext(1)]
        [CompilerGenerated]
        get
        {
            return typeof(Person);
        }
    }

    public string Name
    {
        [CompilerGenerated]
        get
        {
            return <Name>k__BackingField;
        }
        [CompilerGenerated]
        init
        {
            <Name>k__BackingField = value;
        }
    }

    public string Surname
    {
        [CompilerGenerated]
        get
        {
            return <Surname>k__BackingField;
        }
        [CompilerGenerated]
        init
        {
            <Surname>k__BackingField = value;
        }
    }

    public int Age
    {
        [CompilerGenerated]
        get
        {
            return <Age>k__BackingField;
        }
        [CompilerGenerated]
        init
        {
            <Age>k__BackingField = value;
        }
    }

    public Person(string Name, string Surname, int Age)
    {
        <Name>k__BackingField = Name;
        <Surname>k__BackingField = Surname;
        <Age>k__BackingField = Age;
        base..ctor();
    }

    [System.Runtime.CompilerServices.NullableContext(1)]
    public override string ToString()
    {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.Append("Person");
        stringBuilder.Append(" { ");
        if (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(' ');
        }
        stringBuilder.Append('}');
        return stringBuilder.ToString();
    }

    [System.Runtime.CompilerServices.NullableContext(1)]
    protected virtual bool PrintMembers(StringBuilder builder)
    {
        RuntimeHelpers.EnsureSufficientExecutionStack();
        builder.Append("Name = ");
        builder.Append((object)Name);
        builder.Append(", Surname = ");
        builder.Append((object)Surname);
        builder.Append(", Age = ");
        builder.Append(Age.ToString());
        return true;
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    public static bool operator !=(Person left, Person right)
    {
        return !(left == right);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    public static bool operator ==(Person left, Person right)
    {
        return (object)left == right || ((object)left != null && left.Equals(right));
    }

    public override int GetHashCode()
    {
        return ((EqualityComparer<Type>.Default.GetHashCode(EqualityContract) * -1521134295 + EqualityComparer<string>.Default.GetHashCode(<Name>k__BackingField)) * -1521134295 + EqualityComparer<string>.Default.GetHashCode(<Surname>k__BackingField)) * -1521134295 + EqualityComparer<int>.Default.GetHashCode(<Age>k__BackingField);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    public override bool Equals(object obj)
    {
        return Equals(obj as Person);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    public virtual bool Equals(Person other)
    {
        return (object)this == other || ((object)other != null && EqualityContract == other.EqualityContract && EqualityComparer<string>.Default.Equals(<Name>k__BackingField, other.<Name>k__BackingField) && EqualityComparer<string>.Default.Equals(<Surname>k__BackingField, other.<Surname>k__BackingField) && EqualityComparer<int>.Default.Equals(<Age>k__BackingField, other.<Age>k__BackingField));
    }

    [System.Runtime.CompilerServices.NullableContext(1)]
    public virtual Person <Clone>$()
    {
        return new Person(this);
    }

    protected Person([System.Runtime.CompilerServices.Nullable(1)] Person original)
    {
        <Name>k__BackingField = original.<Name>k__BackingField;
        <Surname>k__BackingField = original.<Surname>k__BackingField;
        <Age>k__BackingField = original.<Age>k__BackingField;
    }

    public void Deconstruct(out string Name, out string Surname, out int Age)
    {
        Name = this.Name;
        Surname = this.Surname;
        Age = this.Age;
    }
}

In C# 9, records were reference types(class). In addition to record classes, C# 10 brings record structs and allows us to declare and use value type records(struct). Declaring a record struct is pretty similar to declaring a record class.

public record struct Person(string Name, string Surname, int Age);

Since you can declare record structs using the record struct keywords, you can also use record class in addition to record to declare record classes in C# 10.

//Record classes
public record Person(string Name, string Surname, int Age);
public record class Person(string Name, string Surname, int Age);

//Record structs
public record struct Person(string name, string surname, int age);

Let's have a look at the code compiler generates.

public struct Person : IEquatable<Person>
{
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string <Name>k__BackingField;

    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string <Surname>k__BackingField;

    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private int <Age>k__BackingField;

    public string Name
    {
        [IsReadOnly]
        [CompilerGenerated]
        get
        {
            return <Name>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            <Name>k__BackingField = value;
        }
    }

    public string Surname
    {
        [IsReadOnly]
        [CompilerGenerated]
        get
        {
            return <Surname>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            <Surname>k__BackingField = value;
        }
    }

    public int Age
    {
        [IsReadOnly]
        [CompilerGenerated]
        get
        {
            return <Age>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            <Age>k__BackingField = value;
        }
    }

    public Person(string Name, string Surname, int Age)
    {
        <Name>k__BackingField = Name;
        <Surname>k__BackingField = Surname;
        <Age>k__BackingField = Age;
    }

    [IsReadOnly]
    public override string ToString()
    {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.Append("Person");
        stringBuilder.Append(" { ");
        if (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(' ');
        }
        stringBuilder.Append('}');
        return stringBuilder.ToString();
    }

    [IsReadOnly]
    private bool PrintMembers(StringBuilder builder)
    {
        builder.Append("Name = ");
        builder.Append((object)Name);
        builder.Append(", Surname = ");
        builder.Append((object)Surname);
        builder.Append(", Age = ");
        builder.Append(Age.ToString());
        return true;
    }

    public static bool operator !=(Person left, Person right)
    {
        return !(left == right);
    }

    public static bool operator ==(Person left, Person right)
    {
        return left.Equals(right);
    }

    [IsReadOnly]
    public override int GetHashCode()
    {
        return (EqualityComparer<string>.Default.GetHashCode(<Name>k__BackingField) * -1521134295 + EqualityComparer<string>.Default.GetHashCode(<Surname>k__BackingField)) * -1521134295 + EqualityComparer<int>.Default.GetHashCode(<Age>k__BackingField);
    }

    [IsReadOnly]
    public override bool Equals(object obj)
    {
        return obj is Person && Equals((Person)obj);
    }

    [IsReadOnly]
    public bool Equals(Person other)
    {
        return EqualityComparer<string>.Default.Equals(<Name>k__BackingField, other.<Name>k__BackingField) && EqualityComparer<string>.Default.Equals(<Surname>k__BackingField, other.<Surname>k__BackingField) && EqualityComparer<int>.Default.Equals(<Age>k__BackingField, other.<Age>k__BackingField);
    }

    [IsReadOnly]
    public void Deconstruct(out string Name, out string Surname, out int Age)
    {
        Name = this.Name;
        Surname = this.Surname;
        Age = this.Age;
    }
}

Most of the generated code looks similar to the record classes. However, there is one difference between record structs and record classes. The generated properties in record structs are mutable by default. The reason behind this decision was to be consistent with tuples. Tuples are like anonymous record structs with similar features. On the other hand, struct mutability does not carry the same level of concern as class mutability does. That's why the C# team decided to make record struct properties mutable by default. However, if you need immutable record structs, you can use the readonly keyword.

public readonly record struct Person(string name, string surname, int age);

Generated code

public struct Person : IEquatable<Person>
{
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string <name>k__BackingField;

    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string <surname>k__BackingField;

    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private int <age>k__BackingField;

    public string name
    {
        [IsReadOnly]
        [CompilerGenerated]
        get
        {
            return <name>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            <name>k__BackingField = value;
        }
    }

    public string surname
    {
        [IsReadOnly]
        [CompilerGenerated]
        get
        {
            return <surname>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            <surname>k__BackingField = value;
        }
    }

    public int age
    {
        [IsReadOnly]
        [CompilerGenerated]
        get
        {
            return <age>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            <age>k__BackingField = value;
        }
    }

    public Person(string name, string surname, int age)
    {
        <name>k__BackingField = name;
        <surname>k__BackingField = surname;
        <age>k__BackingField = age;
    }

    [IsReadOnly]
    public override string ToString()
    {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.Append("Person");
        stringBuilder.Append(" { ");
        if (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(' ');
        }
        stringBuilder.Append('}');
        return stringBuilder.ToString();
    }

    [IsReadOnly]
    private bool PrintMembers(StringBuilder builder)
    {
        builder.Append("name = ");
        builder.Append((object)name);
        builder.Append(", surname = ");
        builder.Append((object)surname);
        builder.Append(", age = ");
        builder.Append(age.ToString());
        return true;
    }

    public static bool operator !=(Person left, Person right)
    {
        return !(left == right);
    }

    public static bool operator ==(Person left, Person right)
    {
        return left.Equals(right);
    }

    [IsReadOnly]
    public override int GetHashCode()
    {
        return (EqualityComparer<string>.Default.GetHashCode(<name>k__BackingField) * -1521134295 + EqualityComparer<string>.Default.GetHashCode(<surname>k__BackingField)) * -1521134295 + EqualityComparer<int>.Default.GetHashCode(<age>k__BackingField);
    }

    [IsReadOnly]
    public override bool Equals(object obj)
    {
        return obj is Person && Equals((Person)obj);
    }

    [IsReadOnly]
    public bool Equals(Person other)
    {
        return EqualityComparer<string>.Default.Equals(<name>k__BackingField, other.<name>k__BackingField) && EqualityComparer<string>.Default.Equals(<surname>k__BackingField, other.<surname>k__BackingField) && EqualityComparer<int>.Default.Equals(<age>k__BackingField, other.<age>k__BackingField);
    }

    [IsReadOnly]
    public void Deconstruct(out string name, out string surname, out int age)
    {
        name = this.name;
        surname = this.surname;
        age = this.age;
    }
}

with Expressions

Record structs support with expressions to create copies. In C# 10, we can use the with expressions with all struct types including tuples.

//with expressions - record structs
var p = new Person("Ilkay", "Ilknur", 33);
var newP = p with { Age = 50 };

public record struct Person(string Name, string Surname, int Age);

// with expressions - regular structs
var pStruct = new PersonStruct()
{
    Name = "Ilkay"
};

var pNewStruct = pStruct with { Name = "John" };

public struct PersonStruct
{
    public string Name;
}

Deconstruction

Positional record structs support deconstruction similar to positional record classes.

var p = new Person("Ilkay", "Ilknur", 33);
var (name, surname, age) = p;

public record struct Person(string Name, string Surname, int Age);

ToString Method

The synthesized ToString method prints the type name and values.

var p = new Person("Ilkay", "Ilknur", 33);
Console.WriteLine(p);
// prints : Person { Name = Ilkay, Surname = Ilknur, Age = 33 }

public record struct Person(string Name, string Surname, int Age);

Record structs are regular structs, and all struct rules apply to record structs as well. However, there are some additional limitations and rules we need to keep in mind.

Record structs cannot use ref modifier.
Record struct parameters cannot use ref, out or this modifiers (but in and params are allowed).
Record structs inherit from ValueTuple implicitly.

A New Modern Timer API In .NET 6 - PeriodicTimer

As a developer, you've probably used timers in .NET before. There are plenty of types of timers in .NET right now, and each of them serves a different purpose.

List of types of timers in .NET 5.

System.Threading.Timer
System.Timers.Timer
System.Windows.Forms.Timer
System.Web.UI.Timer
System.Windows.Threading.DispatcherTimer

.NET 6 introduces a new timer type called PeriodicTimer. The main purpose behind the PeriodicTimer is to avoid using callbacks. Avoiding callbacks can save us from dealing with memory leaks that might occur in long-lived operations, and we can write async code instead of using the sync over async approach in callbacks. Another problem that you might deal with with the current timer types is callback overlapping. If you don't write code for the callback overlap scenario, you can see unexpected behaviors in your application.

Creating a PeriodicTimer instance is pretty straightforward. The only parameter you need to provide is the period value.

var timer = new PeriodicTimer(TimeSpan.FromSeconds(10));

You can call the WaitForNextTickAsync method to wait asynchronously between ticks and, write asynchronous code without dealing with callback overlapping problems because the PeriodicTimer pauses while the business code is running and resumes when the WaitForNextTickAsync method is called.

var timer = new PeriodicTimer(TimeSpan.FromSeconds(10));

while (await timer.WaitForNextTickAsync())
{
    //Business logic
}

You can stop PeriodicTimer using the CancellationToken that you can specify while calling the WaitForNextTickAsync method. Another way to stop the PeriodicTimer is calling the Dispose method. When the Dispose method is called, WaitForNextTickAsync returns false, and you can stop executing the timer-based business logic.

Some notes about PeriodicTimer

The execution context isn't captured.
PeriodicTimer is intended to be used only by a single consumer at a time.

PeriodicTimer documentation: https://docs.microsoft.com/en-us/dotnet/api/system.threading.periodictimer

.NET 6 İle Gelecek Olan Yeni LINQ API'ları

.NET içerisinde uzun süredir varolan ve sıklıkla kullanılan özelliklerden biri de LINQ. Geçtiğimiz versiyonlarda LINQ tarafına pek yeni özellik eklenmese de performans ve memory kullanımı bakımından pek çok iyileştirme yapılmıştı. .NET 6 ile beraber ise LINQ tarafında uzun süredir istenilen bazı API'lar bu versiyonla beraber hayatımıza giriyor olacak. Şimdi lafı çok fazla uzatmadan yeni gelecek LINQ API'larını inceleyelim.

Index Ve Range Desteği

Daha önce blogda C# 8 ile beraber gelen Index ve Range desteğinden bahsetmiştim. .NET 6 ile beraber index ve range desteği çeşitli LINQ API'larına da ekleniyor.

Eklenen metotlara kısaca bir bakalım.

namespace System.Linq
{
    public static partial class Enumerable
    {
        public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, Index index);
        public static TSource ElementAtOrDefault<TSource>(this IEnumerable<TSource> source, Index index);
        public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, Range range);
    }
}

namespace System.Linq
{
    public static partial class Queryable
    {
        public static TSource ElementAt<TSource>(this IQueryable<TSource> source, Index index);
        public static TSource ElementAtOrDefault<TSource>(this IQueryable<TSource> source, Index index);
        public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source, Range range);
    }
}

Ufak bir örnek yapalım.

var list = new List<int>()
{
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
};

var elements = list.ElementAt(^2);
var elements2 = list.Take(2..);

Default Değer Belirtmeyi Sağlayan SingleOrDefault, LastOrDefault ve FirstOrDefault Metot Overloadları

.NET 6 ile beraber SingleOrDefault, LastOrDefault ve FirstOrDefault metotlarını kullandığımızda ek olarak kendi istediğimiz bir default değeri dönmesini sağlayabiliyoruz.

Eklenen API'lar şu şekilde.

namespace System.Linq
{
    public static class Enumerable
    {
        public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, TSource defaultValue);
        public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue);

        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, TSource defaultValue);
        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue);

        public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, TSource defaultValue);
        public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue);
    }

    public static class Queryable
    {
        public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue);
        public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue);

        public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue);
        public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue);

        public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue);
        public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue);
    }
}

Bir örnek yapalım.

var list = new List<int>()
{
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
};

var firstElement = list.FirstOrDefault(-1); //returns 1
var element = list.FirstOrDefault(t => t > 13, -1); //returns -1 instead of default int

Distinct, Except, Intersect, Union, Min ve Max İçin *By Metotları

.NET 6 ile beraber yeni eklenecek API'ların bir diğeri de keySelector belirtmemizi sağlayan *By metotları.

İlk olarak eklenen metotları görelim.

namespace System.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
        public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer);
        
        public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector);
        public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer);
        public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelectorFirst);
        public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelectorFirst, IEqualityComparer<TKey>? comparer);

        public static IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector);
        public static IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer);
        public static IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelectorFirst);
        public static IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TKey> second, Func<TSource, TKey> keySelectorFirst, IEqualityComparer<TKey>? comparer);
        
        public static IEnumerable<TSource> UnionBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector);
        public static IEnumerable<TSource> UnionBy<TSource, TKey>(this IEnumerable<TSource> first, IEnumerable<TSource> second, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer);
        
        public static TSource MinBy<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);
        public static TSource MinBy<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector, IComparer<TResult>? comparer);
        
        public static TSource MaxBy<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);
        public static TSource MaxBy<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector, IComparer<TResult>? comparer);
        
        // Missing min & max overloads accepting custom comparers added for completeness
        public static TResult Min<TSource, TResult>(this IEnumerable<TSource> source, IComparer<TResult>? comparer);
        public static TResult Max<TSource, TResult>(this IEnumerable<TSource> source, IComparer<TResult>? comparer);
    }

    public static class Queryable
    {
        public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
        public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer);

        public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector);
        public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer);
        public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelectorFirst);
        public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelectorFirst, IEqualityComparer<TKey>? comparer);

        public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector);
        public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer);
        public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelectorFirst);
        public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelectorFirst, IEqualityComparer<TKey>? comparer);

        public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector);
        public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer);

        public static TSource MinBy<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector);
        public static TSource MinBy<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector, IComparer<TResult>? comparer);

        public static TSource MaxBy<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector);
        public static TSource MaxBy<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector, IComparer<TResult>? comparer);

        // Missing min & max overloads accepting custom comparers added for completeness
        public static TResult Min<TSource, TResult>(this IQueryable<TSource> source, IComparer<TResult>? comparer);
        public static TResult Max<TSource, TResult>(this IQueryable<TSource> source, IComparer<TResult>? comparer);
    }
}

Bu API'ların neden geldiğini basitçe Distinct API'ı üzerinden açıklarsak, Distinct API'ını kullandığımızda bu API default equality comparer'ı kullanarak distinct elemanlı buluyor. Eğer complex bir type üzerinden bu metodu kullanmak istersek tipimizin IEquatable<T> interface'ini implemente etmesi gerekmekte. DistictBy metoduyla bu zorunluluğu ortadan kaldırıp metoda parametre olarak keySelector geçebiliyoruz.

Örnek yaparsak

var list = new List<Product>();
var distinctProducts = list.DistinctBy(t => t.SKU);
var cheapestProduct = list.MinBy(t => t.Price);

Chunk Metodu

.NET 6 ile beraber gelen en beğendiğim API'lardan biri de Chunk API'ı. Elimizde bulunan bir IEnumerable<T> veya IQueryable<T>'den belirttiğimiz uzunlukta chunklar oluşturabiliyoruz.

Eklenen API'lar

namespace System.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<T[]> Chunk(this IEnumerable<T> source, int size);
    }
    public static class Queryable
    {
        public static IQueryable<T[]> Chunk(this IQueryable<T> source, int size);
    }
}

Örnek yaparsak.

var list = new List<int>
{
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
};

IEnumerable<int[]>? chunks = list.Chunk(3);
/*
Chunks:
[1,2,3]
[4,5,6]
[7,8,9]
[10,11,12]
[13]
*/

Zip Metoduyla Üç Farklı Sequence'i Birleştirme Olanağı

.NET 6 ile beraber Zip<T> metodunu kullanarak üç farklı sequence'ı birleştirebiliyoruz.

Gelen yeni API'lar şu şekilde.

namespace System.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third);
    }

    public static class Queryable
    {
        public static IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3);
    }
}

`TryGetNonEnumeratedCount` Metodu

TryGetNonEnumeratedCount metodu elimizde bulunan sequence'in enumerate etmeye zorlamadan boyutunu almayı sağlıyor. Bu metot özellikle bir sequence'i enumerate etmeden önce buffer allocate etmek istersek önceden sequence'in büyüklüğünü bulup daha efektif bir şekilde buffer allocate etmemize yardımcı olabilir.

Eklenen API

namespace System.Linq
{
    public static class Enumerable
    {
        public static bool TryGetNonEnumeratedCount(this IEnumerable<T> source, out int count);
    }
}

Örnek kullanım.

List<T> buffer = source.TryGetNonEnumeratedCount(out int count) ? new List<T>(capacity: count) : new List<T>();
foreach (T item in source)
{
    buffer.Add(item);
}

Bu yazıda da .NET 6 ile beraber LINQ tarafında gelen yenilikleri inceledik.

Bir sonraki yazıda görüşmek üzere.

.NET 6 İle Basitleştirilmeye Çalışılan Null Argument Kontrolü

C# 10 ve .NET 6'nın en önemli temalarından biri yazdığımız kodu basitleştirmek ve azaltmak. Bu kapsamda gerek .NET içerisinde gerekse C# içerisinde pek çok yenilik geliyor. Bu yazıdaki konumuz ise metotlardaki null argument kontrolü. Build konferansında C#'ın yeni versiyonu ilk duyurulduğunda beni heyecanlandıran özelliklerden birisi basitleştirilmiş ve yükü compilerın üstlendiği null argument check özelliğiydi.

Kısaca bir null argument kontrolü yaptığımız kod yazarsak.

public void Foo(Person person)
{
     if (person == null)
        throw new ArgumentNullException(nameof(person));
}

C# 10 ile bu yazdığımız kod aşağıdaki gibi olacaktı.

public void Foo(Person person!)
{
    
}

Ancak bu özellik ne yazık ki C# 10 ile beraber gelemeyecek. Bununla beraber .NET 6 ile yazdığımız kodu biraz daha kısaltacak yeni bir metot geliyor. Bu metot ArgumentNullException.ThrowIfNull metodu. Bu metodu kullanarak en azından ekstra if statementlarından kurtulabiliriz.

Yeni gelen metotla beraber yukarıdaki kod aşağıdaki gibi olacak.

public void Foo(Person person)
{
    ArgumentNullException.ThrowIfNull(person);
}

ThrowIfNull metodunun .NET içerisindeki implementasyonu ise aşağıdaki gibi.

public static void ThrowIfNull([NotNull] object? argument, [CallerArgumentExpression("argument")] string? paramName = null)
{
   if (argument is null)
   {
       Throw(paramName);
   }
}

[DoesNotReturn]
private static void Throw(string? paramName) =>
   throw new ArgumentNullException(paramName);

https://source.dot.net/#System.Private.CoreLib/ArgumentNullException.cs,c742289497493bb8

Yukarıda gördüğünüz CallerArgumentExpression attribute'ü size yeni gelebilir. Bu da bir başka makalenin konusu olsun. 🙃

Bir sonraki yazıda görüşmek üzere.

C# 10 Global Usings ve File Scoped Namespaces Özellikleri

.NET 6'nın ilk release candidate sürümünün çıkmasıyla beraber gerek framework içerisindeki özelliklerin gerekse C# 10 içerisindeki özelliklerin daha stabil ve değişikliğe uğramasının da düşük bir olasılıkta olduğunu düşünebiliriz. Bu nedenle de artık yavaş yavaş C# 10 içerisindeki özellikleri incelemenin de vaktinin geldiğini düşünüyorum.

Bu yazıda C# 10 içerisinde bulunan ve adapte olması en kolay olan özelliklerden bahsedeceğiz. Vakit kaybetmeden incelemeye başlayalım.

Global Usings

Bu özellik kısaca bir proje içerisinde çalışırken sıklıkla kullandığımız namespaceleri global olarak tanımlamamızı sağlıyor. Global olarak tanımladığımız namespaceleri proje içerisindeki tüm dosyalar içerisinden otomatik olarak kullanabiliyoruz.

Kısaca bir örnek verirsek, diyelim ki projemizde Entity Framework kullanıyoruz ve proje içerisindeki tüm dosyalar içerisinde using Microsoft.EntityFrameworkCore; şeklinde bir tanımlama yapıyoruz. Bu kod kalabalığından ve tekrardan kurtulmak için using statementının başına global keywordünü ekleyerek bu namespace'in tüm dosyalarda otomatik importlu şekilde gelmesini sağlayabiliriz.

Global usings özelliğinin kullanımında tavsiye edilen yöntem her proje başına bir using.cs gibi bir dosya tanımlanması ve global olarak import edilecek olan namespacelerin bu dosya içerisinden eklenmesi ve yönetilmesi. Aksi takdirde farklı dosyalar içerisinde global tanımlamalar yapıldığında namespacelerin yönetimi oldukça zorlaşabilir.

.NET 6 ile beraber gelen dikkat çekici yeniliklerden biri de uygulama templatelerinin güncelleniyor olması. Bu güncelleme sonrasında farklı uygulama tiplerine göre sık kullanılan bazı namespaceler otomatik olarak global bir şekilde import edilmiş olarak geliyor. SDK tipine göre global import edilen namespaceleri aşağıda görebilirsiniz.

Microsoft.NET.SDK:
- System
- System.Collections.Generic
- System.IO
- System.Linq
- System.Net.Http
- System.Threading
- System.Threading.Tasks
Microsoft.NET.SDK.Web:
- Microsoft.NET.SDK içerisinde ekli olanlar ve aşağıdaki namespaceler.
- System.Net.Http.Json
- Microsoft.AspNetCore.Builder
- Microsoft.AspNetCore.Hosting
- Microsoft.AspNetCore.Http
- Microsoft.AspNetCore.Routing
- Microsoft.Extensions.Configuration
- Microsoft.Extensions.DependencyInjection
- Microsoft.Extensions.Hosting
- Microsoft.Extensions.Logging
Microsoft.NET.SDK.Worker
- Microsoft.NET.SDK içerisinde ekli olanlar ve aşağıdaki namespaceler.
- Microsoft.Extensions.Configuration
- Microsoft.Extensions.DependencyInjection
- Microsoft.Extensions.Hosting
- Microsoft.Extensions.Logging

Bu otomatik import özelliğinde hoşlanmadıysanız veya global olarak eklenecek olan namespaceleri kendiniz kontrol etmek isterseniz proje dosyası içerisine <ImplicitUsings>disable</ImplicitUsings> ekleyebilirsiniz.

File Scoped Namespaces

C# 10 içerisinde belki de en sevilecek özelliklerden biri olmaya aday olan bir özellik file scoped namespaces. Bu özelliği uzun uzun anlatmaya gerek yok. En basit anlatımla namespace tanımlamalarını kısaltabiliyoruz.

C# 10 öncesi

namespace MyProduct
{
    class X
    {

    }
}

C# 10 ile beraber

namespace MyProduct;
class X
{

}

Görüldüğü gibi file-scoped namespaceleri kullanarak ekstra curly brace ve indentationdan kurtulmuş oluyoruz. Bu özelliğin tabi ki bazı limitasyonları bulunmakta. Özelliğin adından da anlayabileceğiniz üzere tanımladığımız namespace dosya bazında geçerli. Bu nedenle birden fazla namespace tanımlaması yapmamız mümkün değil. Aynı zamanda bir dosya içerisinde hem file scoped hem de normal namespace kullanımı da yapamıyoruz. Ancak çoğu dosyada zaten bunlara pek ihtiyacımız olmayacağı için bence oldukça iyi bir özellik olduğunu söyleyebilirim.

Bu yazıda C# 10 ile beraber gelecek olan nispeten daha basit özellikleri inceledik.

Bir sonraki yazıda görüşmek üzere.

.NET 6 İle Beraber Gelen Yeni Bir Timer Tipi - PeriodicTimer

.NET içerisinde pek çok alternatifini bulabileceğimiz yapılardan biri de Timer yapıları. Geçmişten bugüne kadar farklı farklı noktalarda farklı ihtiyaçlara cevap veren timer yapıları framework içerisine eklendi ve aktif olarak kullanılmakta.

.NET 6 öncesinde kullanabileceğimiz timer tiplerini kısaca listelersek...

System.Threading.Timer
System.Timers.Timer
System.Windows.Forms.Timer
System.Web.UI.Timer
System.Windows.Threading.DispatcherTimer

.NET 6 ile beraber ise bu listeye bir timer tipini daha ekliyor olacağız. .NET 6 Preview 7 ile beraber bu listeye dahil olan timer tipinin adı PeriodicTimer. PeriodicTimer da tabi ki mevcut olan timer tiplerin içerisindeki bir takım problemleri çözmek amacıyla framework içerisine eklendi. Mevcut timer tiplerinde sorun yaratan konuların başında bu timer tiplerinin callback tabanlı çalışması yatmaktaydı. Bu callback yapıları bazen memory leaklere neden olabilmekte ve sorun çıkarabilmekte. Aynı zamanda bu callbackler içerisinde sync over async kod yazmamız gerekmekte. Mevcut timer tiplerinde timer ticklendiğinde çalışacak olan kodlar eğer çalışma süreleri uzun sürerse arka arkaya tetiklenebilmekte ve eğer kodumuzu buna göre yazmazsak sorunlara neden olabilmekte.

Tüm bu nedenlerden dolayı .NET 6 ile beraber kullanımı oldukça basit bir timer yapısı hayatımıza giriyor. Şimdi kod kısmına geçelim.

Bir PeriodicTimer instance'ı yaratmak oldukça basit. Sadece constructora ne kadar sürede bir tetikleneceğini bildirmemiz gerekmekte.

var timer = new PeriodicTimer(TimeSpan.FromSeconds(3));

Sonrasında da WaitForNextTickAsync metodunu çağırarak bir sonraki tetiklenmeyi async olarak bekleyebilir, ardındanda çalışacak olan kodu çalıştırabiliriz.

var timer = new PeriodicTimer(TimeSpan.FromSeconds(3));

while (await timer.WaitForNextTickAsync())
{
    Console.WriteLine("Timer tick");
}

WaitForNextTickAsync metodunu tekrar çağırmadığımız sürece timer tekrardan verilen periyot kadar bekleme operasyonunu başlatmadığı için yazdığımız kodun üst üste çalışması gibi bir durum da olmamakta.

Şimdi gelelim PeriodicTimer'ın durdurulması senaryosuna. Bunun için iki farklı yöntem bulunmakta. Bunlardan biri WaitForNextTickAsync metoduna bir CancellationToken verilmesi. Diğeri ise PeriodicTimer'ın dispose metodunun çağırılması. CancellationToken kullanımında eğer operasyon iptal edilirse exception fırlatılırken, dispose etme senaryosunda WaitForNextTickAsync metodundan false dönmekte.

Bu yazıda .NET 6 ile beraber gelen PeriodicTimer'ı inceledik. Bir sonraki yazıda görüşmek üzere.

Kaynak : https://github.com/dotnet/runtime/issues/31525

Random.Shared Propertysi İle Random Tipinin Thread-Safe Olarak Kullanılması

Developerlar olarak sıklıkla kullandığımız tiplerden biri de Random tipi. Bazen test amaçlı olarak bazen de farklı amaçlarla Random tipine sıklıkla başvuruyoruz. Random tipinin özelliklerinden biri de thread-safe olmaması. Bir Random instance'ının concurrent olarak kullanılması nadiren de olsa üretilen sayıların 0 olmasına bazen de randomizasyonun kalitesinin düşmesine neden olabilmekte.

Bu noktada kullanabileceğimiz çözümler lock kullanmak veya her bir thread içerisinde ThreadStatic field içerisinde farklı bir Random instance'ı kullanmak olabilir. Ancak her iki durumda da developerlar Random tipini thread-safe bir şekilde kullanmak için ekstra kod yazmak durumunda kalmakta. Bu senaryo .NET 6 ile beraber biraz değişiyor. .NET 6 ile beraber gelen Random.Shared propertysini kullanarak thread-safe olarak Random tipini kullanabiliyoruz.

Örnek olarak

var x = Random.Shared.Next();

Bu şekilde kullanımda arkada kullanılan implementasyon ThreadStatic field içerisinde saklandığı için concurrent kullanımlarda herhangi bir sorunla karşılaşmıyoruz ve aynı zamanda kolay ve basit bir şekilde thread-safe implementasyona da sahip olmuş oluyoruz.

Bir sonraki yazıda görüşmek üzere.

Kaynak: https://github.com/dotnet/runtime/issues/43887

İlkay İlknur

The New Code Analyzers In .NET 6

Do not call Task.WhenAll with a single argument

Do not call Task.WaitAll with a single argument

Use the new Environment.ProcessPath property to get the process path

Use Environment.CurrentManagedThreadId to get the managed thread Id

Use String.Contains(char) instead of String.Contains(String)

Replace Dictionary<,>.Keys.Contains calls to ContainsKey

Use span-based string.Concat to avoid allocations

Use string.AsSpan() instead of string.Substring() when parsing

Call async methods when in an async method

Prefer String.Equals instead of String.Compare for equality checks

Warn developers when calling Buffer.BlockCopy

Warn developers when unknown platform names are used

CallerArgumentExpression Attribute In C# 10

How To Convert Block Scoped Namespaces To File Scoped Namespaces

.editorconfig File

Changing Visual Studio Code Style Preference

Record Structs In C# 10

with Expressions

Deconstruction

ToString Method

A New Modern Timer API In .NET 6 - PeriodicTimer

.NET 6 İle Gelecek Olan Yeni LINQ API'ları

Index Ve Range Desteği

Default Değer Belirtmeyi Sağlayan SingleOrDefault, LastOrDefault ve FirstOrDefault Metot Overloadları

Distinct, Except, Intersect, Union, Min ve Max İçin *By Metotları

Chunk Metodu

Zip Metoduyla Üç Farklı Sequence'i Birleştirme Olanağı

TryGetNonEnumeratedCount Metodu

.NET 6 İle Basitleştirilmeye Çalışılan Null Argument Kontrolü

C# 10 Global Usings ve File Scoped Namespaces Özellikleri

Global Usings

File Scoped Namespaces

.NET 6 İle Beraber Gelen Yeni Bir Timer Tipi - PeriodicTimer

Random.Shared Propertysi İle Random Tipinin Thread-Safe Olarak Kullanılması

`TryGetNonEnumeratedCount` Metodu