{"id":385369,"date":"2024-06-29T06:04:24","date_gmt":"2024-06-29T06:04:24","guid":{"rendered":"http:\/\/savepearlharbor.com\/?p=385369"},"modified":"-0001-11-30T00:00:00","modified_gmt":"2024-06-29T06:04:24","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=385369","title":{"rendered":"What’s new in C# 10: overview<\/span>"},"content":{"rendered":"
<\/div>\n
\n
\n
\n
\n

This article covers the new version of the C# language — C# 10. Compared to C# 9, C# 10 includes a short list of enhancements. Below we described the enhancements and added explanatory code fragments. Let’s look at them.<\/p>\n

<\/figcaption><\/figure>\n

Enhancements of structure types<\/h3>\n

Initialization of field structure<\/h4>\n

Now you can set initialization of fields and properties in structures:<\/p>\n

public struct User {     public User(string name, int age)     {         Name = name;         Age = age;     }     string Name { get; set; } = string.Empty;     int Age { get; set; } = 18; } <\/code><\/pre>\n
Parameterless constructor declaration in a structure type<\/h4>\n
Beginning with C# 10, you can declare a parameterless constructor in structures:<\/p>\n
public struct User {     public User()     {      }      public User(string name, int age)     {         Name = name;         Age = age;     }      string Name { get; set; } = string.Empty;     int Age { get; set; } = 18; } <\/code><\/pre>\n
Important.<\/strong> You can use parameterless constructors only if all fields and\/or properties have initializers. For example, if you do not set the Age<\/em> initializer, a compiler will issue an error:<\/p>\n
Error CS0843: Auto-implemented property ‘User.Age’ must be fully assigned before control is returned to the caller.<\/em><\/p>\n
Applying the with expression to a structure<\/h3>\n
Before, you could use the with<\/em> expression with records. With C#10, you can use this expression with structures. Example:<\/p>\n
public struct User {     public User()     {      }      public User(string name, int age)     {         Name = name;         Age = age;     }      public string Name { get; set; } = string.Empty;     public int Age { get; set; } = 18; }  User myUser = new(\"Chris\", 21); User otherUser = myUser with { Name = \"David\" }; <\/code><\/pre>\n
It is clear that the property that we are changing (in this case, the Name<\/em> field) must have a public access modifier.<\/p>\n
Global using<\/h3>\n
Beginning with C# 10, you can use the using<\/em> directive across an entire project. Add the global<\/em> keyword before the using<\/em> phrase:<\/p>\n
global using \"Library name\" <\/code><\/pre>\n
Thus, the using<\/em> directive allows you not to duplicate the same namespaces in different files.<\/p>\n
Important.<\/strong> Use global using<\/em> construction BEFORE code lines that include using<\/em> without global<\/em> keyword. Example:<\/p>\n
global using System.Text; using System; using System.Linq; using System.Threading.Tasks; \/\/ Correct code fragment<\/code><\/pre>\n
Otherwise:<\/p>\n
using System; using System.Linq; using System.Threading.Tasks; global using System.Text; \/\/ Error CS8915 \/\/ A global using directive must precede \/\/ all non-global using directives.<\/code><\/pre>\n
If you wrote the namespace that was previously written with the global<\/em> keyword, the IDE will warn you (IDE: 0005: Using directive is unnecessary<\/em>).<\/p>\n
File-scoped namespace<\/h3>\n
Sometimes you need to use the namespace within the entire file. This action may shift the tabs to the right. To avoid this problem, you can now use the namespace<\/em> keyword. Write the namespace<\/em> keyword without braces:<\/p>\n
using System; using System.Linq; using System.Threading.Tasks;  namespace TestC10;  public class TestClass {     .... } <\/code><\/pre>\n
Before C# 10, it was necessary to keep namespace<\/em> braces open on the entire file:<\/p>\n
using System; using System.Linq; using System.Threading.Tasks;  namespace TestC10 {     public class TestClass     {         ....     } } <\/code><\/pre>\n
Clearly, you can declare only one namespace<\/em> in the file. Accordingly, the following code fragment is incorrect:<\/p>\n
namespace TestC10; namespace MyDir; \/\/ Error CS8954 \/\/ Source file can only contain \/\/ one file-scoped namespace declaration <\/code><\/pre>\n
as well as the following piece of code:<\/p>\n
namespace TestC10; namespace MyDir {     .... } \/\/ Error CS8955 \/\/ Source file can not contain both \/\/ file-scoped and normal namespace declarations.<\/code><\/pre>\n
Record enhancements<\/h3>\n
The class keyword<\/h4>\n
C# 10.0 introduces the optional keyword — class<\/em>. The class keyword helps understand whether a record is of a reference type.<\/p>\n
Therefore, the two following records are identical:<\/p>\n
public record class Test(string Name, string Surname); public record Test(string Name, string Surname);<\/code><\/pre>\n
Record structs<\/h4>\n
Now it’s possible to create record structs:<\/p>\n
record struct Test(string Name, string Surname)<\/code><\/pre>\n
By default, the properties of the record struct<\/em> are mutable, unlike the standard record<\/em> that have init<\/em> modifier.<\/p>\n
string Name { get; set; } string Surname { get; set; }<\/code><\/pre>\n
We can set the readonly<\/em> property to the record struct. Then access to the fields will be equivalent to the standard record:<\/p>\n
readonly record struct Test(string Name, string Surname);<\/code><\/pre>\n
where the properties are written as:<\/p>\n
string Name { get; init; } string Surname { get; init; }<\/code><\/pre>\n
The equality of two record struct objects is similar to the equality of two structs. Equality is true if these two objects store the same values:<\/p>\n
var firstRecord = new Person(\"Nick\", \"Smith\"); var secondRecord = new Person(\"Robert\", \"Smith\"); var thirdRecord = new Person(\"Nick\", \"Smith\");  Console.WriteLine(firstRecord == secondRecord); \/\/ False Console.WriteLine(firstRecord == thirdRecord); \/\/ True<\/code><\/pre>\n
Note that the compiler doesn’t synthesize a copy constructor for record struct types. If we create a copy constructor and use the with<\/em> keyword when initializing a new object, then the assignment operator will be called instead of the copy constructor (as it happens when working with the record class<\/em>).<\/p>\n
Seal the ToString() method on records<\/h4>\n
As my colleague wrote in the article on the enhancements for C# 9<\/a> , records have the overridden toString<\/em> method. There is an interesting point about inheritance as related to this method. The child objects cannot inherit the overriden toString<\/em> method from the parent record. C# 10 introduces the sealed<\/em> keyword so that the child objects can inherit the ToString<\/em> method. This keyword prevents the compiler from synthesizing the ToString<\/em> implementation for any derived records. Use the following keyword to override the ToString<\/em> method:<\/p>\n
public sealed override string ToString() {     .... }<\/code><\/pre>\n
Let’s create a record that tries to override the toString<\/em> method:<\/p>\n
public record TestRec(string name, string surname) {     public override string ToString()     {         return $\"{name} {surname}\";     } }<\/code><\/pre>\n
Now let’s inherit the second record:<\/p>\n
public record InheritedRecord : TestRec {     public InheritedRecord(string name, string surname)     :base(name, surname)     {      } }<\/code><\/pre>\n
Now let’s create an instance of each record and type the result to the console:<\/p>\n
TestRec myObj = new(\"Alex\", \"Johnson\"); Console.WriteLine(myObj.ToString()); \/\/ Alex Johnson  InheritedRecord mySecObj = new(\"Thomas\", \"Brown\"); Console.WriteLine(mySecObj.ToString()); \/\/ inheritedRecord { name = Thomas, surname = Brown}<\/code><\/pre>\n
As we can see, the InheritedRecord<\/em> did not inherit the toString<\/em> method.<\/p>\n
Let’s slightly change the TestRec<\/em> record and add the sealed<\/em> keyword:<\/p>\n
public record TestRec(string name, string surname) {     public sealed override string ToString()     {         return $\"{name} {surname}\";     } }<\/code><\/pre>\n
Now let’s re-create two instances of the records and type the result to the console:<\/p>\n
TestRec myObj = new(\"Alex\", \"Johnson\"); Console.WriteLine(myObj.ToString()); \/\/ Alex Johnson  InheritedRecord mySecObj = new(\"Thomas\", \"Brown\"); Console.WriteLine(mySecObj.ToString()); \/\/ Thomas Brown<\/code><\/pre>\n
And.. woohoo! The InheritedRecord<\/em> inherited the toString<\/em> method from the TestRec<\/em>.<\/p>\n
Easier access to nested fields and properties of property patterns<\/h3>\n
C# 8.0 introduced the property pattern that allows you to easily match on fields and\/or properties of an object with the necessary expressions.<\/p>\n
Before, if you needed to check any nested property, the code could look too cumbersome: <\/p>\n
....{property: {subProperty: pattern}}....<\/code><\/pre>\n
With C#10, you just need to add the dots between the properties:<\/p>\n
....{property.subProperty: pattern}....<\/code><\/pre>\n
Let’s see the change using the example of the method of taking the first 4 symbols of the name.<\/p>\n
public record TestRec(string name, string surname);  string TakeFourSymbols(TestRec obj) => obj switch {     \/\/ old way:     \/\/TestRec { name: {Length: > 4} } rec => rec.name.Substring(0,4),      \/\/ new way:     TestRec { name.Length: > 4 } rec => rec.name.Substring(0,4),     TestRec rec => rec.name, };<\/code><\/pre>\n
The example above shows that the new type of property access is simpler and clearer than before.<\/p>\n
Constant interpolated strings<\/h3>\n
Before, this feature was not supported. C# 10 allows you to use string interpolation for constant strings:<\/p>\n
const string constStrFirst = \"FirstStr\"; const string summaryConstStr = $\"SecondStr {constStrFirst}\";<\/code><\/pre>\n
Interesting fact.<\/strong> This change relates only to string interpolation for constant strings, i.e the addition of a constant character is not allowed:<\/p>\n
const char a = 'a'; const string constStrFirst = \"FirstStr\"; const string summaryConstStr = $\"SecondStr {constStrFirst} {a}\"; \/\/ Error CS0133 \/\/ The expression being assigned to \/\/ 'summaryConstStr' must be constant<\/code><\/pre>\n
Assignment and declaration in same deconstruction<\/h3>\n
In earlier versions of C#, a deconstruction could assign values to EITHER declared variables (all are declared), OR variables that we initialize during calling (all are NOT declared):<\/p>\n
Car car = new(\"VAZ 2114\", \"Blue\");  var (model, color) = car; \/\/ Initialization  string model = string.Empty; string color = string.Empty; (model, color) = car; \/\/ Assignment<\/code><\/pre>\n
The new version of the language allows simultaneous use of both previously declared and undeclared variables in deconstruction:<\/p>\n
string model = string.Empty; (model, var color) = car; \/\/ Initialization and assignment <\/code><\/pre>\n
The following error occurred in the C#9 version:<\/p>\n
Error CS8184: A deconstruction cannot mix declarations and expressions on the left-hand-side.<\/em><\/p>\n
Conclusion<\/h3>\n
As mentioned earlier, the list of changes is not as large as in the C#9 version. Some changes simplify the work, while others provide previously unavailable features. The C# is still evolving. We’re looking forward for new updates of the C# language.<\/p>\n
Haven’t read about new C# 9 features yet? Check them out in our separate article<\/a>.<\/p>\n
If you want to see the original source, you can read the Microsoft documentation<\/a>.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n

 \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438  https:\/\/habr.com\/ru\/articles\/584486\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
<\/div>\n
\n
\n
\n
\n
This article covers the new version of the C# language — C# 10. Compared to C# 9, C# 10 includes a short list of enhancements. Below we described the enhancements and added explanatory code fragments. Let’s look at them.<\/p>\n
<\/figcaption><\/figure>\n
Enhancements of structure types<\/h3>\n
Initialization of field structure<\/h4>\n
Now you can set initialization of fields and properties in structures:<\/p>\n
public struct User {     public User(string name, int age)     {         Name = name;         Age = age;     }     string Name { get; set; } = string.Empty;     int Age { get; set; } = 18; } <\/code><\/pre>\n
Parameterless constructor declaration in a structure type<\/h4>\n
Beginning with C# 10, you can declare a parameterless constructor in structures:<\/p>\n
public struct User {     public User()     {      }      public User(string name, int age)     {         Name = name;         Age = age;     }      string Name { get; set; } = string.Empty;     int Age { get; set; } = 18; } <\/code><\/pre>\n
Important.<\/strong> You can use parameterless constructors only if all fields and\/or properties have initializers. For example, if you do not set the Age<\/em> initializer, a compiler will issue an error:<\/p>\n
Error CS0843: Auto-implemented property ‘User.Age’ must be fully assigned before control is returned to the caller.<\/em><\/p>\n
Applying the with expression to a structure<\/h3>\n
Before, you could use the with<\/em> expression with records. With C#10, you can use this expression with structures. Example:<\/p>\n
public struct User {     public User()     {      }      public User(string name, int age)     {         Name = name;         Age = age;     }      public string Name { get; set; } = string.Empty;     public int Age { get; set; } = 18; }  User myUser = new(\"Chris\", 21); User otherUser = myUser with { Name = \"David\" }; <\/code><\/pre>\n
It is clear that the property that we are changing (in this case, the Name<\/em> field) must have a public access modifier.<\/p>\n
Global using<\/h3>\n
Beginning with C# 10, you can use the using<\/em> directive across an entire project. Add the global<\/em> keyword before the using<\/em> phrase:<\/p>\n
global using \"Library name\" <\/code><\/pre>\n
Thus, the using<\/em> directive allows you not to duplicate the same namespaces in different files.<\/p>\n
Important.<\/strong> Use global using<\/em> construction BEFORE code lines that include using<\/em> without global<\/em> keyword. Example:<\/p>\n
global using System.Text; using System; using System.Linq; using System.Threading.Tasks; \/\/ Correct code fragment<\/code><\/pre>\n
Otherwise:<\/p>\n
using System; using System.Linq; using System.Threading.Tasks; global using System.Text; \/\/ Error CS8915 \/\/ A global using directive must precede \/\/ all non-global using directives.<\/code><\/pre>\n
If you wrote the namespace that was previously written with the global<\/em> keyword, the IDE will warn you (IDE: 0005: Using directive is unnecessary<\/em>).<\/p>\n
File-scoped namespace<\/h3>\n
Sometimes you need to use the namespace within the entire file. This action may shift the tabs to the right. To avoid this problem, you can now use the namespace<\/em> keyword. Write the namespace<\/em> keyword without braces:<\/p>\n
using System; using System.Linq; using System.Threading.Tasks;  namespace TestC10;  public class TestClass {     .... } <\/code><\/pre>\n
Before C# 10, it was necessary to keep namespace<\/em> braces open on the entire file:<\/p>\n
using System; using System.Linq; using System.Threading.Tasks;  namespace TestC10 {     public class TestClass     {         ....     } } <\/code><\/pre>\n
Clearly, you can declare only one namespace<\/em> in the file. Accordingly, the following code fragment is incorrect:<\/p>\n
namespace TestC10; namespace MyDir; \/\/ Error CS8954 \/\/ Source file can only contain \/\/ one file-scoped namespace declaration <\/code><\/pre>\n
as well as the following piece of code:<\/p>\n
namespace TestC10; namespace MyDir {     .... } \/\/ Error CS8955 \/\/ Source file can not contain both \/\/ file-scoped and normal namespace declarations.<\/code><\/pre>\n
Record enhancements<\/h3>\n
The class keyword<\/h4>\n
C# 10.0 introduces the optional keyword — class<\/em>. The class keyword helps understand whether a record is of a reference type.<\/p>\n
Therefore, the two following records are identical:<\/p>\n
public record class Test(string Name, string Surname); public record Test(string Name, string Surname);<\/code><\/pre>\n
Record structs<\/h4>\n
Now it’s possible to create record structs:<\/p>\n
record struct Test(string Name, string Surname)<\/code><\/pre>\n
By default, the properties of the record struct<\/em> are mutable, unlike the standard record<\/em> that have init<\/em> modifier.<\/p>\n
string Name { get; set; } string Surname { get; set; }<\/code><\/pre>\n
We can set the readonly<\/em> property to the record struct. Then access to the fields will be equivalent to the standard record:<\/p>\n
readonly record struct Test(string Name, string Surname);<\/code><\/pre>\n
where the properties are written as:<\/p>\n
string Name { get; init; } string Surname { get; init; }<\/code><\/pre>\n
The equality of two record struct objects is similar to the equality of two structs. Equality is true if these two objects store the same values:<\/p>\n
var firstRecord = new Person(\"Nick\", \"Smith\"); var secondRecord = new Person(\"Robert\", \"Smith\"); var thirdRecord = new Person(\"Nick\", \"Smith\");  Console.WriteLine(firstRecord == secondRecord); \/\/ False Console.WriteLine(firstRecord == thirdRecord); \/\/ True<\/code><\/pre>\n
Note that the compiler doesn’t synthesize a copy constructor for record struct types. If we create a copy constructor and use the with<\/em> keyword when initializing a new object, then the assignment operator will be called instead of the copy constructor (as it happens when working with the record class<\/em>).<\/p>\n
Seal the ToString() method on records<\/h4>\n
As my colleague wrote in the article on the enhancements for C# 9<\/a> , records have the overridden toString<\/em> method. There is an interesting point about inheritance as related to this method. The child objects cannot inherit the overriden toString<\/em> method from the parent record. C# 10 introduces the sealed<\/em> keyword so that the child objects can inherit the ToString<\/em> method. This keyword prevents the compiler from synthesizing the ToString<\/em> implementation for any derived records. Use the following keyword to override the ToString<\/em> method:<\/p>\n
public sealed override string ToString() {     .... }<\/code><\/pre>\n
Let’s create a record that tries to override the toString<\/em> method:<\/p>\n
public record TestRec(string name, string surname) {     public override string ToString()     {         return $\"{name} {surname}\";     } }<\/code><\/pre>\n
Now let’s inherit the second record:<\/p>\n
public record InheritedRecord : TestRec {     public InheritedRecord(string name, string surname)     :base(name, surname)     {      } }<\/code><\/pre>\n
Now let’s create an instance of each record and type the result to the console:<\/p>\n
TestRec myObj = new(\"Alex\", \"Johnson\"); Console.WriteLine(myObj.ToString()); \/\/ Alex Johnson  InheritedRecord mySecObj = new(\"Thomas\", \"Brown\"); Console.WriteLine(mySecObj.ToString()); \/\/ inheritedRecord { name = Thomas, surname = Brown}<\/code><\/pre>\n
As we can see, the InheritedRecord<\/em> did not inherit the toString<\/em> method.<\/p>\n
Let’s slightly change the TestRec<\/em> record and add the sealed<\/em> keyword:<\/p>\n
public record TestRec(string name, string surname) {     public sealed override string ToString()     {         return $\"{name} {surname}\";     } }<\/code><\/pre>\n
Now let’s re-create two instances of the records and type the result to the console:<\/p>\n
TestRec myObj = new(\"Alex\", \"Johnson\"); Console.WriteLine(myObj.ToString()); \/\/ Alex Johnson  InheritedRecord mySecObj = new(\"Thomas\", \"Brown\"); Console.WriteLine(mySecObj.ToString()); \/\/ Thomas Brown<\/code><\/pre>\n
And.. woohoo! The InheritedRecord<\/em> inherited the toString<\/em> method from the TestRec<\/em>.<\/p>\n
Easier access to nested fields and properties of property patterns<\/h3>\n
C# 8.0 introduced the property pattern that allows you to easily match on fields and\/or properties of an object with the necessary expressions.<\/p>\n
Before, if you needed to check any nested property, the code could look too cumbersome: <\/p>\n
....{property: {subProperty: pattern}}....<\/code><\/pre>\n
With C#10, you just need to add the dots between the properties:<\/p>\n
....{property.subProperty: pattern}....<\/code><\/pre>\n
Let’s see the change using the example of the method of taking the first 4 symbols of the name.<\/p>\n
public record TestRec(string name, string surname);  string TakeFourSymbols(TestRec obj) => obj switch {     \/\/ old way:     \/\/TestRec { name: {Length: > 4} } rec => rec.name.Substring(0,4),      \/\/ new way:     TestRec { name.Length: > 4 } rec => rec.name.Substring(0,4),     TestRec rec => rec.name, };<\/code><\/pre>\n
The example above shows that the new type of property access is simpler and clearer than before.<\/p>\n
Constant interpolated strings<\/h3>\n
Before, this feature was not supported. C# 10 allows you to use string interpolation for constant strings:<\/p>\n
const string constStrFirst = \"FirstStr\"; const string summaryConstStr = $\"SecondStr {constStrFirst}\";<\/code><\/pre>\n
Interesting fact.<\/strong> This change relates only to string interpolation for constant strings, i.e the addition of a constant character is not allowed:<\/p>\n
const char a = 'a'; const string constStrFirst = \"FirstStr\"; const string summaryConstStr = $\"SecondStr {constStrFirst} {a}\"; \/\/ Error CS0133 \/\/ The expression being assigned to \/\/ 'summaryConstStr' must be constant<\/code><\/pre>\n
Assignment and declaration in same deconstruction<\/h3>\n
In earlier versions of C#, a deconstruction could assign values to EITHER declared variables (all are declared), OR variables that we initialize during calling (all are NOT declared):<\/p>\n
Car car = new(\"VAZ 2114\", \"Blue\");  var (model, color) = car; \/\/ Initialization  string model = string.Empty; string color = string.Empty; (model, color) = car; \/\/ Assignment<\/code><\/pre>\n
The new version of the language allows simultaneous use of both previously declared and undeclared variables in deconstruction:<\/p>\n
string model = string.Empty; (model, var color) = car; \/\/ Initialization and assignment <\/code><\/pre>\n
The following error occurred in the C#9 version:<\/p>\n
Error CS8184: A deconstruction cannot mix declarations and expressions on the left-hand-side.<\/em><\/p>\n
Conclusion<\/h3>\n
As mentioned earlier, the list of changes is not as large as in the C#9 version. Some changes simplify the work, while others provide previously unavailable features. The C# is still evolving. We’re looking forward for new updates of the C# language.<\/p>\n
Haven’t read about new C# 9 features yet? Check them out in our separate article<\/a>.<\/p>\n
If you want to see the original source, you can read the Microsoft documentation<\/a>.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n

 \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438  https:\/\/habr.com\/ru\/articles\/584486\/<\/a>
<\/br><\/br><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-385369","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/385369","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=385369"}],"version-history":[{"count":0,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/385369\/revisions"}],"wp:attachment":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=385369"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=385369"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=385369"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}