C#

public class Foo : Foo.Port
{
    private Foo() { }
    public int FooData1 { get; set; }
    public int FooData2 { get; set; }
    public interface Port
    {
        static Port Default = new Foo();
        protected int FooData1 { get; }
        protected int FooData2 { get; }
        static (int, int) Action()
        {
            return (Default.FooData1, Default.FooData2);
        }
    }
}

var bar = Foo.Port.Default;
var foobar = (Foo)bar;
foobar.FooData1 = 10;
foobar.FooData2  = 20;
Console.WriteLine(Foo.Port.Action());

public object Clone()
{
    var (X, Y) = Foo.Port.Action();
    return new Foo()
    { 
        FooData1 = X, 
        FooData2 = Y 
    };
}

bool playing = true;
public Form1()
{
    InitializeComponent();
}
private Button[] Cells => new Button[]
{
    //top row
    button1,
    button2,
    button3,
    //middle row
    button4,
    button5,
    button6,
    //bottom row
    button7,
    button8,
    button9
};
private bool IsBoardFull
{
    get 
    {
        bool result = true;
        foreach (Button btn in Cells) 
        {
            if (btn.Enabled) { result = false; break; }
        }
        return result;
    }
}
//This tells our CheckForWinner if their is a winner
private bool IsThreeInRow
{
    get
    {
        //rows
        if (Cells[0].Text == "X" && Cells[1].Text == "X" && Cells[2].Text == "X" ||                    
         Cells[0].Text == "O" && Cells[1].Text == "O" && Cells[2].Text == "O" ||
         Cells[3].Text == "X" && Cells[4].Text == "X" && Cells[5].Text == "X" ||
         Cells[3].Text == "O" && Cells[4].Text == "O" && Cells[5].Text == "O" ||
         Cells[6].Text == "X" && Cells[7].Text == "X" && Cells[8].Text == "X" ||
         Cells[6].Text == "O" && Cells[7].Text == "O" && Cells[8].Text == "O" ||
         //columns
         Cells[0].Text == "X" && Cells[3].Text == "X" && Cells[6].Text == "X" ||
         Cells[0].Text == "O" && Cells[3].Text == "O" && Cells[6].Text == "O" ||
         Cells[1].Text == "X" && Cells[4].Text == "X" && Cells[7].Text == "X" ||
         Cells[1].Text == "O" && Cells[4].Text == "O" && Cells[7].Text == "O" ||
         Cells[2].Text == "X" && Cells[5].Text == "X" && Cells[8].Text == "X" ||
         Cells[2].Text == "O" && Cells[5].Text == "O" && Cells[8].Text == "O" ||
         //Diagional
         Cells[0].Text == "X" && Cells[4].Text == "X" && Cells[8].Text == "X" ||
         Cells[0].Text == "O" && Cells[4].Text == "O" && Cells[8].Text == "O" ||
         Cells[2].Text == "X" && Cells[4].Text == "X" && Cells[6].Text == "X" ||
         Cells[2].Text == "O" && Cells[4].Text == "O" && Cells[6].Text == "O")
            return true;
        return false;
        
    }
}
    
//This is for the computer play. It just returns all 
//the possible plays that are currently available. It
//chooses one of these at random, better computer play
//logic should be thought out.
private IEnumerable<Button> PossibleMoves()
{
    return Cells.Where((button) => button.Enabled);
}
private void CheckForWinner() 
{
    string draw = "Sorry, it was a draw.";
    string playAgain = "Another Game?";
    string sorry = "Sorry, you lost.";
    string congrats = "Congratulations, you won.";
    
    if(IsThreeInRow) 
    {
        string state = playing ? congrats : sorry;
        DialogResult dialogResult = MessageBox.Show(
            state, playAgain, MessageBoxButtons.YesNo);
        if (dialogResult == DialogResult.Yes)
        {                    
            ResetGame();                    
            return;
        }
        Close();
    }
    else if(IsBoardFull)
    {
        DialogResult dialogResult = MessageBox.Show(
            draw, playAgain, MessageBoxButtons.YesNo);
        if (dialogResult == DialogResult.Yes) 
        {
            ResetGame();                    
            return;
        }
        Close();
    }
}
//One of our buttons was choosen
private void Cell_Click(object sender, EventArgs e)
{
    if (!playing) return;
    Button btn = (Button)sender;
    if(string.IsNullOrEmpty(btn.Text)) 
    {
        PerformMove(btn);
        return;
    }           
}
private void PerformMove(Button btn)
{            
    if(playing)
    {
        btn.Text = "X";
        btn.Enabled = false;
        CheckForWinner();
        playing = false;                
        ComputerPlay();
        return;
    }
    btn.Text = "O";
    btn.Enabled = false;
    CheckForWinner();
    playing = true;            
}
private void ResetGame()
{               
    foreach(Button btn in Cells) 
    {
        btn.Text = null;
        btn.Enabled = true;
    }
}
private void ComputerPlay()
{
    if (playing) return;
    var possibleMoves = PossibleMoves();
    int index = new Random((int)DateTime.Now.
        Ticks).Next(0, possibleMoves.Count());
    Button btn = possibleMoves.ElementAt(index);
    PerformMove(btn);
}        

string listTitle = "TripLegs" ;

string listDescription = "This is a new list created using CSOM";
Microsoft.SharePoint.Client.List? newList = null;

using (var authenticationManager = new AuthenticationManager())
using (var context = authenticationManager.GetContext(site, user, password))
{
    context.Load(context.Web, p => p.Title);
    await context.ExecuteQueryAsync();
    Console.WriteLine($"Title: {context.Web.Title}");
    Web web = context.Web;

    // Create a new list
    ListCreationInformation creationInfo = new ListCreationInformation();
    creationInfo.Title = listTitle;
    creationInfo.Description = listDescription;
    creationInfo.TemplateType = (int)ListTemplateType.GenericList;
    newList = web.Lists.Add(creationInfo);

                    try
                    {
                        // Load the list and execute the query
                        context.Load(newList);
                        context.ExecuteQuery();

                        Console.WriteLine("List created successfully!");


                        FieldCollection fields = newList.Fields;

                        // set up the columns
                        #region ColumnHeaders
<pre>                        FieldCreationInformation fieldInfo_1 = new FieldCreationInformation(FieldType.Number)
                        {
                            DisplayName = "TripId",
                            InternalName = "TripId",
                            Group = "Custom Columns",
                            AddToDefaultView = true
                        };
                        // Create the field schema XML
                        string fieldSchema_1 = $"<Field Type='{fieldInfo_1.FieldType}' Name='{fieldInfo_1.InternalName}' DisplayName='{fieldInfo_1.DisplayName}' Group='{fieldInfo_1.Group}' />";
                        Field Field_1 = newList.Fields.AddFieldAsXml(fieldSchema_1, true, AddFieldOptions.DefaultValue);
                        Field_1.Update();
                        context.ExecuteQuery();

}
catch (Exception ex)
{
    // it already exists so instead of adding it, get it

Legs singleTripLeg = JsonSerializer.Deserialize<Legs>(inputLegsJSON);

// this is where we load the SharePoint List from a Record

// Create a new list item
ListItemCreationInformation itemCreateInfo = new ListItemCreationInformation();

Microsoft.SharePoint.Client.ListItem newItem = newList.AddItem(itemCreateInfo);

newItem["TripId"] = singleTripLeg.TripId;
// OK
newItem["ExternalReference"] = singleTripLeg.ExternalReference;
newItem["DepartureAirportId"] = singleTripLeg.DepartureAirportId;
newItem["ArrivalAirportId"] = singleTripLeg.ArrivalAirportId;
newItem["LandedLocal"] = singleTripLeg.LandedLocal;

newItem["LandedPinned"] = singleTripLeg.LandedPinned;


// if all goes well, then we update

newItem.Update();

// if all goes well, then we exccute query

context.ExecuteQuery();

1. The await operator here does not appear to affect the locking behaviour. It's only waiting for the Task.Run to complete.
2. Inside the Task.Run, we have a lock statement. You can think of this as running on a different thread from the caller.
3. Each call to this method will create a new task, which will attempt to acquire the lock independently.

private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

internal static async Task Lock<T>(this T lockObject, Action DoAction) where T : class
{
  try
  {
    await _semaphore.WaitAsync();
    DoAction();
  }
  finally
  {
    _semaphore.Release();
  }
}

public async Task<short[]> GetSamples()
{
    if (!ContainsAudio()) 
        throw new ArgumentException(nameof(G711.Alaw));
    short[] samples = [];
    NativePointer pointer = _nativePointer!;
    await pointer.Lock(() =>
    {
        unsafe
        {
            var sampleCount = pointer.Size >> 1;
            samples = new short[sampleCount];
            var memoryBlock = pointer.GetMemoryBlock();
            var value = (short*)memoryBlock;
            for (var i = 0; i < sampleCount; i++)
            {
                samples[i] = *value++;
            }
        }
    });
    return samples;
}