Konstanta interpolacja w C# 10 i .NET 6 w niecałe 10 minut

Wprowadzenie

W tym wideo Tim wyjaśnia, jak w łańcuchach interpolowanych — tych używających znanej składni z dolarem ($) — można teraz używać wyrażeń stałych, co wcześniej nie było możliwe. Ta drobna zmiana sprawia, że konstrukcja stałych ciągów znaków jest łatwiejsza, czystsza i bardziej utrzymywalna.

Badanie stałych w .NET 6

Tim otwiera aplikację konsolową .NET 6 i usuwa kod szablonowy, aby skupić się wyłącznie na definicjach stałych.

Zaczyna od najprostszej deklaracji stałej ciągu znaków:

const string companyName = "Acme";

const string companyName = "Acme";

Jest to prosty literał ciągu przypisany do stałej zmiennej typu string. Stałe takie jak te są oceniane w czasie kompilacji, co oznacza, że ich wartości są ustalone i osadzone w skompilowanym programie.

Ale Tim szybko przechodzi do kluczowego pytania: co, jeśli chcemy połączyć stałe łańcuchy znaków lub bezpośrednio osadzić wartości wewnątrz innych łańcuchów znaków, używając interpolacji?

W C# 9 i wcześniejszych wersjach nie można było tego zrobić:

const string productName = $"{companyName} Anvils"; // Not allowed before C# 10

const string productName = $"{companyName} Anvils"; // Not allowed before C# 10

Ta linia spowodowałaby błąd w czasie kompilacji, ponieważ interpolacja ciągu znaków nie była obsługiwana dla wyrażeń stałych.

Stałe interpolowane łańcuchy znaków w C# 10

Jak pokazuje Tim, w C# 10, kompilator teraz wspiera stałe ciągi interpolowane — pod warunkiem, że wszystkie wyrażenia interpolowane w środku są same stałymi.

Tak więc poniższy przykład teraz działa perfekcyjnie:

const string productName = $"{companyName} Anvils";

const string productName = $"{companyName} Anvils";

To stały łańcuch interpolowany, co oznacza, że kompilator ocenia interpolowany łańcuch w czasie kompilacji, a nie w czasie wykonywania. Podczas działania programu nie odbywa się dodatkowe łączenie łańcuchów ani formatowanie tekstu — kompilator generuje pojedynczy stały literał łańcuchowy, taki jak "Acme Anvils".

Tim wyjaśnia, że jeśli zmienimy wartość companyName z "Acme" na "ABC", kompilator automatycznie generuje "ABC Anvils" dla productName. To konstrukcja łańcucha znaków w czasie kompilacji, a nie interpolacja w czasie wykonania.

To ulepszenie znacznie ułatwia łączenie stałych ciągów bez konieczności używania konkatenacji + lub ręcznego powtarzania wartości.

Zagnieżdżone Interpolowanie Stałych

Tim idzie o krok dalej z kolejną definicją stałej:

const string productDescription = $"{productName} are the best way to crush unsuspecting roadrunners.";

const string productDescription = $"{productName} are the best way to crush unsuspecting roadrunners.";

To jest przykład zagnieżdżonej interpolacji, gdzie jeden stały interpolowany ciąg (productName) jest używany wewnątrz innego.

Kompilator traktuje je wszystkie jako wyrażenia stałe, generując jedną, niezmienną reprezentację łańcucha znaków w czasie kompilacji.

Kiedy Tim uruchamia program, wynikiem jest:

Acme Anvils are the best way to crush unsuspecting roadrunners.

Acme Anvils are the best way to crush unsuspecting roadrunners.

To potwierdza, że interpolacja stałych działa bezproblemowo, nawet w przypadku wielu stałych.

Dłączego stałe są ważne

W tym momencie Tim zatrzymuje się, aby wyjaśnić dłączego stałe — a teraz stałe interpolowane łańcuchy — są korzystne.

Wskazuje, że stałe są niezwykle efektywne pod względem pamięci, ponieważ ich wartości są przechowywane bezpośrednio w skompilowanym kodzie, a nie jako oddzielne instancje w pamięci.

W przeciwieństwie do tego, gdy programiści wcześniej potrzebowali czegoś podobnego, często używali pól readonly:

readonly string companyName = "Acme";

readonly string companyName = "Acme";

Jednak Tim zauważa, że pola readonly nie są tym samym co const — są one oceniane w czasie wykonywania, co zużywa więcej pamięci i uniemożliwia optymalizację w czasie kompilacji.

Dzięki stałym interpolowanym łańcuchom znaków możemy teraz pisać wyrażeniowe i wielokrotnego użytku sformatowane łańcuchy, które pozostają stałymi czasu kompilacji, co poprawia zarówno klarowność, jak i wydajność.

Praktyczny przykład — użycie stałych w atrybutach

Tim wprowadza następnie prawdziwy scenariusz, w którym ta nowa funkcja się wyróżnia — atrybuty.

Definiuje prostą lokalną metodę wewnątrz Main():

void SayHi() { }

void SayHi() { }

Następnie próbuje zastosować atrybut [Obsolete] z wiadomością tekstową, która odnosi się do zmiennej:

string myCompany = "Tim's Company";
[Obsolete($"This is no longer used for {myCompany}")]

string myCompany = "Tim's Company";
[Obsolete($"This is no longer used for {myCompany}")]

Niepowodzenie występuje, ponieważ atrybuty mogą przyjmować jako parametry tylko stałe wyrażenia. Kompilator generuje błąd, ponieważ myCompany jest zmienną, a nie stałą.

Tim wyjaśnia, że komunikat atrybutu musi być stałą czasu kompilacji — nie może zależeć od wartości czasu wykonania ani zmiennych instancji.

Jednak dzięki stałym interpolowanych łańcuchom w C# 10 możemy teraz to zrobić bezpiecznie:

const string productName = $"{companyName} Anvils";
[Obsolete($"This is no longer used for {productName}")]

const string productName = $"{companyName} Anvils";
[Obsolete($"This is no longer used for {productName}")]

Komilator rozpoznaje, że zarówno companyName, jak i productName są stałymi, więc cały interpolowany ciąg znaków jest wyrażeniem stałym.

Kompilator generuje sformatowany ciąg w czasie kompilacji, czyniąc go poprawnym wewnątrz atrybutu.

Ten przykład doskonale ilustruje, dłączego interpolacja stała nie jest tylko syntaktycznym upiększeniem — umożliwia nowe scenariusze, takie jak użycie sformatowanych łańcuchów znaków w czasie kompilacji bezpośrednio w atrybutach lub metadanych.

Za kulisami — jak kompilator to obsługuje

Tim nie wchodzi w szczegóły wewnętrzne kompilatora w wideo, ale koncepcja ta jest ściśle związana z działaniem interpolowanych obsługi stringów w C# 10.

Ogólnie rzecz biorąc, gdy kompilator napotyka interpolowany ciąg znaków, tworzy kod podobny do operacji z użyciem ciągu formatującego, generując wywołania takie jak AppendLiteral() i AppendFormatted() w tle.

Ale kiedy mamy do czynienia ze stałymi interpolowanymi łańcuchami, kompilator ocenia wszystko w czasie kompilacji — żaden obsługiwacz interpolowanych łańcuchów ani wywołanie metody nie jest emitowane w wygenerowanym kodzie IL.

Oznacza to, że wynikowa wartość zachowuje się dokładnie tak samo, jak dowolny literał stringa, ale nadal można ją komponować, używając osadzonych wyrażeń z innych stałych.

To elegancka równowaga między ekspresją a wydajnością — kompilator obsługuje konstrukcję ciągów znaków statycznie, zapewniając zerowy koszt wykonania.

Kiedy stosować stałe ciągi interpolowane

Tim przyznaje, że nie każdy będzie korzystał z tej funkcji na co dzień. Programiści, którzy rzadko definiują stałe lub piszą atrybuty, mogą nie odczuć natychmiastowych korzyści.

Jednak dla tych, którzy tworzą wiele definicji kompilacyjnych, komunikatów stałych lub metadanych atrybutów, ta funkcja upraszcza kod i zapobiega bałaganowi wynikającemu z łączenia ciągów znaków.

Jest to również bezpieczniejsze — ponieważ stałe są niezmienne i sprawdzane przez kompilator, eliminujesz błędy wynikające z dynamicznie łączonych ciągów znaków lub nieprawidłowo zarządzanych zmiennych.

Dzięki temu kod staje się bardziej niezawodny, czytelny i łatwiejszy w utrzymaniu.

Wnioski

Na zakończenie filmu Tim zachęca programistów do zastanowienia się, czy w swoich projektach będą korzystać z ciągów interpolowanych. Niektórzy mogą uznać je za niezbędne do uzyskania bardziej przejrzystych ciągów sformowanych w czasie kompilacji, podczas gdy inni mogą postrzegać je jako niewielką wygodę.

Tak czy inaczej, demonstracja Tima pokazuje dokładnie, jak wdrożyć tę funkcję i gdzie ją skutecznie zastosować.

Podsumowując:

• Ciąg interpolowany w stałej pozwala na stosowanie wyrażeń interpolacyjnych wewnątrz stałych.

• Są one oceniane w czasie kompilacji, tworząc wydajne literały łańcuchowe.

• Zastępują one powtarzające się łączenie ciągów znaków bardziej przejrzystą składnią.

• Są one szczególnie przydatne w atrybutach, konfiguracji opartej na stałych oraz komunikatach metadanych.

Łącząc czytelność z bezpieczeństwem w czasie kompilacji, interpolacja stałych w C# 10 stanowi kolejny krok w kierunku ekspresyjnego i wydajnego programowania w C# — co jasno pokazuje przykład Tima Coreya.