C # 8.0 में नई सुविधाएँ नियोजित

पूर्व में C # के लघु संस्करणों में शुरू किए गए सभी उपकरण भाषा को अधिक नहीं बदलने के लिए डिज़ाइन किए गए हैं। वे सी # 7.0 की नई सुविधाओं के लिए सिंटैक्स एन्हांसमेंट और छोटे परिवर्धन की तरह हैं।

यह दृष्टिकोण जानबूझकर किया गया था, और यह मान्य है।

विकास के सभी चरणों (डिजाइन, कार्यान्वयन और परीक्षण) में अधिक काम करने की आवश्यकता है और अधिक गंभीर परिवर्तन केवल मुख्य भाषा रिलीज के साथ जारी किए जाएंगे। हालांकि C # 7 का अंतिम लघु संस्करण अभी तक जारी नहीं किया गया है, टीम पहले से ही भाषा के अगले प्रमुख संस्करण पर सक्रिय रूप से काम कर रही है: # # 8.0।

इस लेख में, मैं वर्तमान में नियोजित सुविधाओं का चयन शुरू करने की योजना बना रहा हूं जो अंतिम रिलीज में होने की संभावना है। वे सभी विकास के प्रारंभिक चरण में हैं और परिवर्तन के अधीन हैं।

अशक्त संदर्भ प्रकार

यह उपकरण पहले से ही C # 7.0 विकास के शुरुआती चरणों में पेश किया गया था, लेकिन अगले प्रमुख संस्करण तक देरी हो रही थी। इसका लक्ष्य डेवलपर को अशक्त NullReferenceException से बचने में मदद करना है।

मुख्य विचार आपको यह निर्दिष्ट करने की अनुमति देता है कि चर के प्रकार का निर्धारण करते समय यह शून्य हो सकता है या नहीं।

IWeapon? canBeNull;
IWeapon cantBeNull;

null , null -null , ( , , ):

canBeNull = null;       //  
cantBeNull = null;      // 
cantBeNull = canBeNull; // 

, nullable- null:

canBeNull.Repair();       // 
cantBeNull.Repair();      //  
if (canBeNull != null) {
    cantBeNull.Repair();  //  
}

, : , null. , null- .

nullability , . , .

Visual Studio 2017 15.6 update.

Records

, - C# , -.

:

public class Sword(int Damage, int Durability);

:

public class Sword : IEquatable<Sword>
{
    public int Damage { get; }
    public int Durability { get; }

    public Sword(int Damage, int Durability)
    {
        this.Damage = Damage;
        this.Durability = Durability;
    }

    public bool Equals(Sword other)
    {
        return Equals(Damage, other.Damage) 
            && Equals(Durability, other.Durability);
    }

    public override bool Equals(object other)
    {
        return (other as Sword)?.Equals(this) == true;
    }

    public override int GetHashCode()
    {
        return (Damage.GetHashCode() * 17 + Durability.GetHashCode());
    }

    public void Deconstruct(out int Damage, out int Durability)
    {
        Damage = this.Damage;
        Durability = this.Durability;
    }

    public Sword With(int Damage = this.Damage, int Durability 
        = this.Durability) => new Sword(Damage, Durability);
}

, , . GetHashCode - Dictionary Hashtable. Deconstruct :

var (damage, durability) = sword;

, , , . , , . , , With, :

var strongerSword = sword.With(Damage: 8);

, :

var strongerSword = sword with { Damage = 8 };

Recursive Patterns

C# 7.0. 8.0 :

. Deconstruct():

if (sword is Sword(10, var durability)) {
    //  ,  Damage = 10
    // durability   sword.Durability
}

(tuple) :

switch (state, transition)
{
    case (State.Running, Transition.Suspend):
        state = State.Suspended;
        break;
}

switch , . , :

state = (state, transition) switch {
    (State.Running, Transition.Suspend) => State.Suspended,
    (State.Suspended, Transition.Resume) => State.Running,
    (State.Suspended, Transition.Terminate) => State.NotRunning,
    (State.NotRunning, Transition.Activate) => State.Running,
    _ => throw new InvalidOperationException()
};

Default Interface Methods

, C# , :

interface ISample
{
    void M1();                                    // 
    void M2() => Console.WriteLine("ISample.M2"); // 
}

, :

abstract class SampleBase
{
    public abstract void M1();
    public void M2() => Console.WriteLine("SampleBase.M2");
}

, C# 8 , . , .

. , . , . , . , .

C#, .

, . , – trait .

, , . C# 8.0 , :

• , , , .
• , , . , .

Asynchronous Streams

C# . C# 8.0, . IEnumerable IEnumerator:

public interface IAsyncEnumerable<out T>
{
    IAsyncEnumerator<T> GetAsyncEnumerator();
}

public interface IAsyncEnumerator<out T> : IAsyncDisposable
{
    Task<bool> MoveNextAsync();
    T Current { get; }
}

, IDisposable:

public interface IAsyncDisposable
{
    Task DisposeAsync();
}

:

var enumerator = enumerable.GetAsyncEnumerator();
try
{
    while (await enumerator.WaitForNextAsync())
    {
        while (true)
        {
            Use(enumerator.Current);
        }
    }
}
finally
{
    await enumerator.DisposeAsync();
}

, . , foreach. :

foreach await (var item in enumerable)
{
    Use(item);
}

, foreach , .

, yield. , :

async IAsyncEnumerable<int> AsyncIterator()
{
    try
    {
        for (int i = 0; i < 100; i++)
        {
            yield await GetValueAsync(i);
        }
    }
    finally
    {
        await HandleErrorAsync();
    }
}

LINQ.

Ranges

:

var range = 1..5;

, :

struct Range : IEnumerable<int>
{
    public Range(int start, int end);
    public int Start { get; }
    public int End { get; }
    public StructRangeEnumerator GetEnumerator();
    // overloads for Equals, GetHashCode...
}

:

• , :

Span<T> this[Range range]
{
    get
    {
        return ((Span<T>)this).Slice(start: range.Start, 
            length: range.End - range.Start);
    }
}

• IEnumerable, :

foreach (var index in min..max)
{
    //  
}

• , :

switch (value)
{
    case 1..5:
        //   
        break;
}

, , .., . , .

a[start:end] #   start  end-1
a[:end]      # items    end-1

Generic Attributes

. , , :

public class TypedAttribute : Attribute
{
    public TypedAttribute(Type type)
    {
        // ...
    }
}

, :

public class TypedAttribute<T> : Attribute
{
    public TypedAttribute()
    {
        // ...
    }
}

, , :

public TypedAttribute(T value)
{
    // ...
}

Default Literal in Deconstruction

C# 7, :

(int x, int y) = (default, default);

default, :

(int x, int y) = default;

Caller Argument Expression

C# 5, CallerMemberName, CallerFilePath CallerLineNumber) .

CallerMemberName INotifyPropertyChanged:

class ViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    private int property;

    public int Property
    {
        get { return property; }
        set
        {
            if (value != property)
            {
                property = value;
                OnPropertyChanged();
            }
        }
    }
}

C# 8 CallerArgumentExpression, , :

public Validate(int[] array, [CallerArgumentExpression("array")] string arrayExpression = null)
{
    if (array == null)
    {
        throw new ArgumentNullException(nameof(array), $"{arrayExpression} was null.");
    }
    if (array.Length == 0)
    {
        throw new ArgumentException($"{arrayExpression} was empty.", nameof(array));
    }
}

, , .

Target-typed new Expression

, var ( ) :

Dictionary<string, string> dictionary = new Dictionary<string, string>(); //  var
var dictionary = new Dictionary<string, string>(); //  var

(), , :

class DictionaryWrapper
{
    private Dictionary<string, string> dictionary = new Dictionary<string, string>();
    // ...
}

C# 8, new, :

class DictionaryWrapper
{
    private Dictionary<string, string> dictionary = new();
    // ...
}

, , . , .

Ordering of ref and partial Modifiers on Type Declarations

C# , partial struct class.

ref C# 7.2, partial , , ref struct, partial partial, .

, :

public ref struct NonPartialStruct { }
public ref partial struct PartialStruct { }

C# 8, , :

public partial ref struct PartialStruct { }

C# 8 . .
, C# 8.0, . , , . , , .

, , . .

C# 7.1, 7.2 and 7.3 — New Features (Updated).