using System;
                    
public class Program
{
    public delegate T Parse<T>(ReadOnlySpan<char> span);
    public static void Main()
    {
        Parse<DateTime> p = (ReadOnlySpan<char> c)=>DateTime.Parse(c);
        Func<ReadOnlySpan<char>, DateTime> t = p; // oops!
    }
}

public int F() =>
   (A is B b) && (b.C is C)
  ? C.D ?? 1
  :FalseToNet ;

S>>> public int F() =>
S>>>   (A is B b) && (b.C is C) ? C.D ?? 1:FalseToNet ;
S>>>

ЛЧ>простите, а выделенное что значит?

var b = A as B;
if (b!=null)
{
  ...
}

if (A is B)
{
  var b = (B)A;
  ...
}

ЛЧ>простите, а выделенное что значит?

if(A is B)
{
  var b = (B)A; 
  if (b.C is C)
  { //...}
{

public int F() =>
    A is B b && b.C is C
        ? C.D ?? 1
        : FalseToNet;

 public int F() =>
   (A is B b) && (b.C is C) ? C.D ?? 1:FalseToNet ;

S>using System;
                    
S>public class Program
S>{
S>    public delegate T Parse<T>(ReadOnlySpan<char> span);
S>    public static void Main()
S>    {
S>        Parse<DateTime> p = (ReadOnlySpan<char> c)=>DateTime.Parse(c);
S>        Func<ReadOnlySpan<char>, DateTime> t = p; // oops!
S>    }
S>}
S>

public static string Create<TState>(
  int length, TState state, SpanAction<char, TState> action);
...
public delegate void SpanAction<T, in TArg>(Span<T> span, TArg arg);

Этот метод реализован для выделения строки, а затем предоставления доступного для записи промежутка, в который вы можете писать, чтобы заполнить содержимое строки во время ее создания. Обратите внимание, что в этом случае полезна только стековая природа Span<T>, гарантирующая, что span (который относится к внутреннему хранилищу строки) перестанет существовать до завершения конструктора строки, что делает невозможным использование span для изменения строки после завершения построения:

int length = ...;
Random rand = ...;
string id = string.Create(length, rand, (Span<char> chars, Random r) =>
{
  for (int i = 0; chars.Length; i++)
  {
    chars[i] = (char)(r.Next(0, 10) + '0');
  }
});

Теперь вы не только избежали выделения, но и записываете непосредственно в память строки в куче, что означает, что вы также избегаете копирования и вас не ограничивают ограничения по размеру стека.

public int F() =>
   (A is B b) && (b.C is C)?
     C.D ??     1
   :FalseToNet ;

Ф>public int F() =>
Ф>   (A is B b) && (b.C is C)?
Ф>     C.D ??     1
Ф>   :FalseToNet ;
Ф>

public int F() =>
   (A is B b) && (b.C is C)
  ? C.D ?? 1
  :FalseToNet ;

public int F() =>
   (A is B b) && (b.C is C)
  ? C.D ?? 1
  :FalseToNet ;

public int F() =>
 A swith
{
 B b when b.C is C => C.D ?? 1,
 _=>FalseToNet;
};

package main
import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/hello", hello)
    http.ListenAndServe(":8090", nil)
}
func hello(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "hello\n")
}

T>package main
T>import (
T>    "fmt"
T>    "net/http"
T>)

T>func main() {
T>    http.HandleFunc("/hello", hello)
T>    http.ListenAndServe(":8090", nil)
T>}
T>func hello(w http.ResponseWriter, req *http.Request) {
T>    fmt.Fprintf(w, "hello\n")
T>}
T>

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();