Programming-Idioms.org

Console.WriteLine("Hello, World!");

for (int i = 0; i < 10; i++)
{
    Console.WriteLine("Hello");
}

Console.WriteLine(string.Join(Environment.NewLine, Enumerable.Repeat("Hello", 10)));

Console.WriteLine( string.Concat(Enumerable.Repeat("Hello\n", 10)) );

void Finish(string name)
{
    System.Console.WriteLine($"My job here is done. Goodbye, {name}");
}

void Finish(string name) 
    => System.Console.WriteLine($"My job here is done. Goodbye, {name}");

int Square(int x)
{
    return x * x;
}

int Square(int x) => (int)Math.Pow(x, 2);

double Square(int value) => System.Math.Pow(value, 2);

void Square(ref int x)
{
    x = x * x;
}

struct Point
{
    public double x;
    public double y;
};

record Point(double x, double y);

(double x, double y)

foreach (var x in items)
{
    DoSomething(x);
}

for (int i = 0; i < items.Length; i++)
{
    Console.WriteLine($"{i} {items[i]}");
}

foreach (var (i, x) in items.AsIndexed())
{
    System.Console.WriteLine($"{i}: {x}");
}

public static class Extensions
{
    public static IEnumerable<(int, T)> AsIndexed<T>(
        this IEnumerable<T> source)
    {
        var index = 0;
        foreach (var item in source)
        {
            yield return (index++, item);
        }
    }
}

foreach (var (x, i) in items.Select((x, i)=>(x, i)))
{
    System.Console.WriteLine($"{i}: {x}");
}

var x = new Dictionary<string, int> {
   {"year", 2019}, {"month", 12}
};

var x = new Dictionary<string, int> {
   ["year"] = 2019,
   ["month"] = 12
};

class BinaryTree<T>:IComparable<T>
{
 T value;
 BinaryTree<T> leftChild;
 BinaryTree<T> rightChild;
}

private static Random rng = new Random();  

public static void Shuffle<T>(this IList<T> x)  
{  
    int n = x.Count;  
    while (n > 1) {  
        n--;  
        int k = rng.Next(n + 1);  
        T value = x[k];  
        x[k] = x[n];  
        x[n] = value;  
    }  
}

public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> input)
    => input.OrderBy(_ => Guid.NewGuid());

x[new Random().Next(x.Count)]

x[Random.Shared.Next(x.Count)]

list.Contains(item);

foreach(var entry in map)
{
    Console.WriteLine("Key=" + entry.Key + ", Value=" + entry.Value);
}

Random rng = new();
double pick(double a, double b)
{
    return rng.NextDouble() * (b - a) + a;
}

Random r = new Random();
return r.Next(a, b + 1);

Random.Shared.Next(a, b + 1)

void Dfs(BinaryTree bt)
{
    if (bt.Left != null) 
        Dfs(bt.Left);

    f(bt);

    if (bt.right != null) 
        Dfs(bt.Right);
}

class Node<T>
{
 T value;
 List<Node<T>> childNodes;
}

public static void Dfs(Action<Tree> f, Tree root) {
    f(root);
    foreach(var child in root.Children)
        Dfs(f, child);
} 

x.Reverse();

(int, int) Search(int[,] m, int x)
{
    for (var i = 0; i <= m.GetUpperBound(0); i++)
        for (var j = 0; j <= m.GetUpperBound(1); j++)
            if (m[i, j] == x)
                return (i, j);

    return (-1, -1);
}

var tmp = a;
a = b;
b = tmp;

(a, b) = (b, a);

long i = Convert.ToInt64(s);

int i = int.Parse(s);

string s = $"{x:F2}";

string s = "ネコ";

ConcurrentQueue<int> coll = new ConcurrentQueue<int>();
var ts = new CancellationTokenSource();
CancellationToken ct = ts.Token;

Task t2 = Task.Factory.StartNew(() => {
	while (true) {
		Thread.Sleep(250);
		if (ct.IsCancellationRequested) break;
			bool isDequeued = coll.TryDequeue(out int result);
			if (isDequeued) Console.WriteLine(result);
	}});
while (true) {
	int val = Convert.ToInt32(Console.ReadLine());
	if (val == -1) break;
	coll.Enqueue(val);
}
ts.Cancel();

using(var readyEvent = new ManualResetEvent(false))
{
    var thread = new Thread(() =>
    {
        readyEvent.WaitOne();
        Console.WriteLine(value);
    });

    thread.Start();

    value = "Alan";
    readyEvent.Set();

    thread.Join();
}

var x = new double[m, n];

var x = new double[m, n, p];

System.Array.Sort(items, Comparer<Item>.Create((a, b) => a.p - b.p));

items.OrderBy(x => x.p)

items.RemoveAt(i);

Parallel.For(1, 1001, f);

int f(int i)
{
    if (i == 0) return 1;
    return i * f(i - 1);
}

int f(int i) => i == 0 ? 1 : i * f(i - 1)

long exp(long x, long n){
    if (n == 0)
        return 1;
    if (n == 1)
        return x;
    if (n % 2 == 0)
        return exp(x * x, n / 2);
    else
        return x * exp(x * x, (n - 1) / 2);
}

long exp(long x, long n) {
    return (long) Math.Pow(x, n);
}

lock (x) {
  x = f(x);	
}

private readonly object m_Sync = new object();

lock(m_Sync)
{
    x = f(x);
}

HashSet<T> x = new HashSet<T>();

Func<A, C> compose(Func<A, B> f, Func<B, C> g) => a => g(f(a));

Func<T1, T3> compose<T1, T2, T3>(Func<T1, T2> f, Func<T2, T3> g) => x => g(f(x));

Func<A, C> curry<A, B, C>(Func<A, B, C> f, B b) => (A a) => f(a, b);

var t = s.Substring(i, j - i);

var ok = s.Contains(word);

char[] charArray = s.ToCharArray();
Array.Reverse(charArray);
string t = new string(charArray);

string t = string.Create(s.Length, s, static (span, s) =>
{
    s.AsSpan().CopyTo(span);
    span.Reverse();
});

int gb = 0;
foreach (int v in a)
{
  foreach (int w in b)
  {
    gb = w;
    if (w == v)
      break;
  }
  if (gb == v)
    continue;
  System.Console.WriteLine(v);
}

bool keepLooping = true;

for(int i = 0; i < m.length && keepLooping; i++)
{
	for(int j = 0; j < m[i].length && keepLooping; j++)
	{
		if(m[i][j] < 0)
		{
			Console.WriteLine(m[i][j]);
			keepLooping = false;
		}
	}
}

foreach (int v in m)
{
    if (v < 0)
    {
        Console.WriteLine(v);
        break;
    }
}

foreach (int[] row in m)
{
    foreach (int v in row)
    {
        if (v < 0)
        {
            Console.WriteLine(v);
            goto DONE;
        }
    }
}
DONE: ;

for (
        int i = 0,
        rows = m.GetLength(0),
        cols = m.GetLength(1); i < rows; i++)
{
    for (int j = 0; j < cols; j++)
    {
        if (m[i, j] < 0)
        {
            Console.WriteLine(m[i, j]);
            i = int.MaxValue - 1; // Break outer loop.
            break;
        }
    }
}

s.Insert(i, x);

Thread.Sleep(5000);

Task.Delay(5000);

string t = s.Substring(0, 5);

var t = s.Substring(s.Length - 5);

string s = @"Huey
Dewey
Louie";

string[] chunks = s.Split(' ');

while (true)
{
    // Do something
}

bool keyExists = m.ContainsKey(key)

m.ContainsValue(v)

string y = string.Join(", ", x);

var s = x.Sum();

string s = i.ToString()

int numTasks = 1000;
Task<int>[] output = new System.Threading.Tasks.Task<int>[numTasks];
for (int i = 0; i < numTasks; i++)
{
  output[i] = Task.Factory.StartNew(
                   new Func <object, int>(LongRunningOperation), 2000);
}
Task.WaitAll(output);

int LongRunningOperation(object objMs)
{
  int ms = (int)objMs;
  Thread.Sleep(ms);
  return ms;
}

await Task.WhenAll(Enumerable.Range(0, 1000).Select(i => Task.Run(() => f(i))));
Console.WriteLine("Finished");

static async Task f(int value)
{
    // Do something with value. Delay to simulate work
    await Task.Delay(500);
}

var y = x.FindAll(p);

var y = x.Where(p).ToList();

string lines = File.ReadAllText(f);

Console.Error.WriteLine($"{x} is negative");

static void Main(string[] args)
{
    string x = args[0];
}

DateTime d = DateTime.Now;

var i = x.IndexOf(y);

string x2 = x.Replace(y, z, StringComparison.Ordinal);

var x = BigInteger.Pow(3, 247);

string s = $"{x:p1}";

var z = BigInteger.Pow(x, n);

public BigInteger binom(int n, int k)
{
	return factorial(n)/(factorial(k) * factorial(n-k));
}

public BigInteger factorial(int x)
{
	BigInteger result = 1;
	for(int i=1;i<=x;i++)
	{
	result = result * i;
	}
	return result;
}

new BitArray(n);

var random = new Random(s);

Random rng = new Random(DateTime.Now.Day);

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine(string.Join(" ", args));
    }
}

int gcd(int a, int b)
{
  while (b != 0)
  {
    int t = b;
    b = a % t;
    a = t;
  }
  return a;
}

int gcd(int a, int b)
{
  if (b == 0) 
    return a;
  else 
    return gcd(b, a % b);
}

int gcd(int a, int b)
{
  while (b != 0)
  {
    int t = b;
    b = a % t;
    a = t;
  }
  return a;
}

int lcm(int a, int b)
{
  if (a == 0 || b == 0)
    return 0;
  return (a * b) / gcd(a, b);
}

int x = lcm(140, 72);

String s = Convert.ToString(x,2);

String s = Convert.ToString(x,2).PadLeft(16, '0');

var x = new Complex(-2, 3);
x *= Complex.ImaginaryOne;

do
{
    stuff();
} while(c);

float y = x;

int y = (int)x;

long y = (long)Math.Round(x);

int SubstringCount(string s, string t, bool allowOverlap = false)
{
  int p = 0;
  int tl = allowOverlap ? 1 : t.Length;
  int cnt = 0;

  while (1 == 1)
  {
    p = s.IndexOf(t, p);
    if (p == -1) break;
    p += tl;
    cnt++;
  }
  return cnt;
}

var r = new Regex("htt+p");

var c = BitOperations.PopCount((uint)i);

public static int BitCount(int i)
{
    var c = 0;
    while (n != 0)
    {
        c++;
        n &= (n - 1); //walking through all the bits which are set to one
    }

    return c;
}

bool addingWillOverflow(int x, int y)
{
  bool willOverflow = false;

  if (x > 0 && y > 0)
    if (y > (int.MaxValue - x)) willOverflow = true;

  if (x < 0 && y < 0)
    if (y < (int.MinValue - x)) willOverflow = true;

  return willOverflow;
}

public bool WillOverwflow(int x, int y) => int.MaxValue / x < y;

public bool multiplyWillOverflow(int x, int y) 
{
	if (x == 0)
		return false;

	if (y > int.MaxValue / x)
		return true;

	if (y < int.MinValue / x)
		return true;

	return false;
}

Environment.Exit(0)

var buf = new byte[1000000];

throw new ArgumentException(nameof(×));

class Foo
{
	public int x { get; private set; }
}

JObject x = JObject.Parse(File.ReadAllText("data.json"));

await File.WriteAllTextAsync("data.json", JsonSerializer.Serialize(x));	

T control(Func<T> f) {
	return f();
}

System.Console.WriteLine( x.GetType() );

var filePath = "Sample.txt";
var fileInfo = new FileInfo(filePath);
var _x = fileInfo.Length;

long? FileSize(string path) {
    if (!File.Exists(path)) {
        return null;
    }
    return (new FileInfo(filePath)).Length;
}

bool b = s.StartsWith(prefix);

bool b = s.EndsWith(suffix);

var _b = _s.EndsWith(_suffix);

var d = DateTimeOffset.FromUnixTimeSeconds(ts).UtcDateTime;

string x = d.ToString("yyyy-MM-dd");

var orderdEnumerable = x.OrderBy(y => y, c);

Array.Sort(items, c);

items.Sort(c);

var client = new HttpClient();
s = await client.GetStringAsync(u);

XDocument x = XDocument.Load("data.xml");

var path=Environment.CommandLine;
var s=Path.GetFileName(path);

string path = Directory.GetCurrentDirectory();

dir = AppDomain.CurrentDomain.BaseDirectory;

int n = sizeof(T);

int n;
unsafe
{
    n = sizeof(T);
}

int n = Marshal.SizeOf(t);

bool blank = string.IsNullOrWhiteSpace(s);

bool blank = string.IsNullOrWhiteSpace(s);

string[] args = { "a", "b"};
Process.Start(x, string.Join(" ", args));

SortedDictionary<string, string> myMap;
foreach (var item in myMap)
{
  Console.WriteLine($"{item.Key}={item.Value}");
}
	

Dictionary<String, String> mymap = new Dictionary<String, String>();
  
foreach(KeyValuePair<string, string> a in mymap.OrderBy(x => x.Value))
{
  Console.WriteLine("Key = {0}, Value = {1}", a.Key, a.Value);
}

bool b = d1 < d2;

string s2 = s1.Replace(w, string.Empty);

int n = x.Count;

int n = x.Length;

var y = new HashSet<T>(x);

var uniques = x.Distinct().ToList();

n = int.Parse(Console.ReadLine());

enum Suit
{
	Spades,
	Hearts,
	Diamonds,
	Clubs
}

var result = isConsistent();
Debug.Assert(result);

var result = isConsistent();
Trace.Assert(result);

public static int binarySearch<T>(List<T> a, T x)
{
    var result = a.BinarySearch(x);
    return result >= 0 ? result : -1;
}

public static int binarySearch<T>(T[] a, T x)
{
    var result = Array.BinarySearch<T>(a, x);
    return result >= 0 ? result : -1;
}

var stopwatch = new Stopwatch();
stopwatch.Start();
foo();
stopwatch.Stop();
var t = stopwatch.ElapsedMilliseconds;

public Tuple<string, bool> foo_PreCSharp7()
{
    // Only accessed via .Item1 and .Item2
    return new Tuple<string, bool>("string", true);
}

public (string, bool) foo_CSharp7UnnamedTuples()
{
    // Only accessed via .Item1 and .Item2
    return ("string", true);
}

public (string NamedStringArg, bool NamedBooleanArg) foo_CSharp7()
{
    // Can be accessed via .NamedStringArg or .NamedBooleanArg
    return ("string", true);
}

if (c1)
{
    f1();
}
else if (c2)
{
    f2();
}
else if (c3)
{
    f3();
}

var sw=new Stopwatch();
sw.Start();
f();
sw.Stop();
var duration=sw.Elapsed;

bool ok = s.ToLower().Contains(word.ToLower());

ok = s.Contains(word, StringComparison.CurrentCultureIgnoreCase);

var items = new List<T>{a,b,c};

T[] items = new T[] { a, b, c };

items.Remove(x);

items.RemoveAll(r => r == x);

bool b = s.All(char.IsDigit);

string file = Path.GetTempFileName();

string newDir = Path.GetTempPath() + Guid.NewGuid();
Directory.CreateDirectory(newDir);

map.Remove(key);

items1.ForEach(Console.WriteLine);
items2.ForEach(Console.WriteLine);

foreach (var item in items1.Concat(items2))
{
    Console.WriteLine(item);
}

String s = x.ToString("x")

for(int i = 0; i < Math.Max(items1.Count, items2.Count); i++)
{
  if (i < items1.Count) Console.WriteLine(items1[i]);
  if (i < items2.Count) Console.WriteLine(items2[i]);
}

bool b = File.Exists(fp);

Console.WriteLine($"[{DateTime.Now}] {msg}");

var f=float.Parse(s);

string t = Regex.Replace(s, @"[^\u0000-\u007F]+", string.Empty);

string input = Console.ReadLine();
string[] intlist = input.Split(new char[] {',', ' '});
	
foreach(string item in intlist)
{
  Console.WriteLine(Convert.ToInt32(item));
}

p = p.TrimEnd('/');

p.TrimEnd(Path.DirectorySeparatorChar);

string s = c.ToString();

var s = new string(c, 1);

var t = $"{s} {i}";

Color color1 = ColorTranslator.FromHtml(c1);
Color color2 = ColorTranslator.FromHtml(c2);
c = string.Format($"#{((color1.R + color2.R) / 2):X2}{((color1.G + color2.G) / 2):X2}{((color1.B + color2.B) / 2):X2}");

File.Delete(filepath);

string s = string.Format("{0:000}",i);

const string _planet = "Earth";

Random rnd = new Random();
List<int> y = x.OrderBy(r => rnd.Next()).Take(k).ToList();

if(Environment.Is64BitOperatingSystem)
{
    f64();
}
else
{
    f32();
}

elements.Select(x => x*c)

void Main(string[] args)
{
  if (args.Contains("b")) bat();
  else if (args.Contains("f")) fox();
}

for(int i = 0; i < list.Count; i += 2) {
  Console.WriteLine(string.Format("{0}, {1}", list[i], list[i + 1]));
}

foreach (var chunk in list.Chunk(2))
{
    Console.WriteLine(string.Join(' ', chunk));
}

var b = true;
try
{
    Process.Start(new ProcessStartInfo()
    {
        FileName = s,
        UseShellExecute = true,
    });
}
catch { b = false; }

var x = items.LastOrDefault();

var x = items[items.Count-1];

var x = items[^1];

var list1 = new List<int>(){1,2,3};
var list2 = new List<int>(){4,5,6};

var list3 = list1.Concat(list2);

var t = s.TrimStart(p);

string t = s.TrimEnd(w);

int n = s.Length;

n = mymap.Count;

s.Add(x);

m[k] = v;

$"{1000:n}"

new HttpClient().PostAsync(u, content);

Int32 s = BitConverter.ToInt32(sampleBuffer, 0);
s = s.Replace("-", string.Empty);

var s = Convert.ToHexString(a);

byte[] a = new byte[s.Length/2];
for (int i = 0, h = 0; h < s.Length; i++, h += 2)
{
  a[i] = (byte) Int32.Parse(s.Substring(h, 2), System.Globalization.NumberStyles.HexNumber);
}

string D = @"C:\The\Search\Path";

// Assumes that the file system is case insensitive
HashSet<string> exts = new HashSet<string>(StringComparer.CurrentCultureIgnoreCase) { "jpg", "jpeg", "png" };
IEnumerable<string> L =
Directory
    .EnumerateFiles(D, "*", SearchOption.AllDirectories)
    .Where(currentFile => exts.Contains(Path.GetExtension(currentFile)));

b = new Rect(new Point(x1, y1), new Point(x2, y2)).Contains(x, y);

class Point
{
	public float X { get; }
	public float Y { get; }

	public Point(float x, float y)
	{
		X = x;
		Y = y;
	}
}

class Rectangle
{
	Point Point1;
	Point Point2;

	public Rectangle(Point point1, Point point2)
	{
		Point1 = point1;
		Point2 = point2;
	}

	public Point GetCenter()
	{
		return new Point(
		(Point1.X + Point2.X) / 2,
		(Point1.Y + Point2.Y) / 2
		);
	}
}

var files = Directory.GetFiles(dirPath);

public class Quine{public static void Main(){var s="public class Quine{{public static void Main(){{var s={0}{1}{0};System.Console.Write(s,(char)34,s);}}}}";System.Console.Write(s,(char)34,s);}}

new HttpClient().PutAsync(u, content);

var t = DateTime.Today.AddDays(1).ToShortDateString();

Task.Delay(TimeSpan.FromSeconds(30))
    .ContinueWith(_ => f(42));

Environment.Exit(0);

var y = x.Where(P).Select(T).ToList();

if (a.Any(e => e > x))
    f();

decimal a = 1234567890.12345678901m;

void Foo(out int element)
{
    element = 42;
}

for (int i = 0; i < m; i += 2)
{
    Foo(out a[i]);
}

        public List<string> GetLines(string _path)
        {
            return File.ReadAllLines(_path).ToList();
        }

System.Environment.Exit(x);

var F = new FileStream("F", FileMode.Open)
// advance into F here
F.SetLength(F.Position);

double hypo(double x, double y)
{
    return Math.Sqrt(Math.Pow(x, 2) + Math.Pow(y, 2));
}

var s = data.Sum(x => x * x);

var m = data.Average();
var s = CalculateStdDev(data);

float CalculateStdDev(IEnumerable<float> values)
{
	double ret = 0;

	if (values.Count() > 0)
	{
		double avg = values.Average();
	      	double sum = values.Sum(d => Math.Pow(d - avg, 2));
	      	ret = Math.Sqrt((sum) / values.Count()-1);
	}
	return (float)ret;
}

static void Frexp(double value, out double mantissa, out int exponent)
{
    var bits = BitConverter.DoubleToInt64Bits(value);
    var negative = (bits & (1L << 63)) != 0;
    exponent = (int)((bits >> 52) & 0x7FFL);
         Console.WriteLine("nt2: " + exponent);
    var mantissaLong = bits & 0xFFFFFFFFFFFFFL;

    if (exponent == 0)
    {
        exponent++;
    }
    else
    {
        mantissaLong |= 1L << 52;
    }

    exponent -= 1075;

    if (mantissaLong == 0)
    {
        mantissa = 

string foo = Environment.GetEnvironmentVariable("FOO");
if (string.IsNullOrEmpty(foo)) foo = "none";

switch (str)
{
    case nameof(Foo):
        Foo();
        break;
    case nameof(Bar):
        Bar();
        break;
    case nameof(Baz):
        Baz();
        break;
    case nameof(Barfl):
        Barfl();
        break;
}

Directory.CreateDirectory(path)

bool b = Directory.Exists(path);

s = s.PadRight(m, c);

s = s.PadLeft(m, c);

c = a.Intersect(b).ToList();

string t = Regex.Replace(s, " +", " ");

string t = Regex.Replace(s, @"\s+", " ");

var t = (2.5f, "foo", true);

var t = string.Concat(s.Where(c => char.IsDigit(c)));

var i = items.IndexOf(x)

if (!items.Any(i => MatchesCondition(i)))
{
	DoSomethingElse();
}

items.Insert(0, x);

items = items.Prepend(x).ToList();

void f(int? x = null)
{
    Console.WriteLine(x.HasValue ? $"Present {x}" : "Not Present");
}

items.RemoveAt(items.Count - 1);

List<T> y = x.ToList();

List<Int32> y = new List<Int32>(x);

File.Copy(src, dst, true); 

var encoding = new UTF8Encoding(false, true);
bool b;
try
{
    encoding.GetCharCount(s);
    b = true;
}
catch (DecoderFallbackException)
{
    b = false;
}

string s = Convert.ToBase64String(data);

byte[] bytes = Convert.FromBase64String(s);

int c = a ^ b;

var c = a.Zip(b, (l, r) => (byte)(l ^ r)).ToArray();

string x = Regex.Match(s, @"\b\d\d\d\b").Value;

var re = new Regex(@"\b\d\d\d\b");
string x = re.Match(s).Value;

Thread.Yield();
busywork();

foreach(var e in x)
    f(e);

a.ForEach(Console.WriteLine);

Console.WriteLine( string.Join(", ", a) );

Console.WriteLine(string.Join(Environment.NewLine, m));

int c = items.Distinct().Count();

x.RemoveAll(item => !p(item));

d = (s?-1:1) * m * double.Exp10(e);

var (a, b, c) = (42, "hello", 5.0);

x = condition() ? "a" : "b";

int i;
while ((i = x.IndexOf("foo")) != -1)
    x[i] = "bar";

foreach (var el in x)
{
    Console.WriteLine(el);
}

Console.WriteLine(string.Join(Environment.NewLine, x));

for (int i = 5; i >= 0; i--)
{
    Console.WriteLine(i);
}

for(int i = items.Count - 1; i >= 0; i--)
{
    Console.WriteLine($"Index = {i}, Item = {items[i]}");
}

var b = a.Select(i => int.Parse(i)).ToList();

var parts = Regex.Split(s, "[,_-]");

var parts = s.Split(',', '-', '_');

var items = new List<string>();

var items = Enumerable.Empty<string>();

var x = date.ToString("HH:mm:ss");

var t = Convert.ToString(n, 2)
    .Reverse()
    .TakeWhile(i => i == '0')
    .Count();

int t = 0;

if(n != 0)
{
    while((n & 1) == 0)
    {
        t++;
        n >>= 1;
    }
}
else
{
    t = 8 * sizeof(int);
}

var sb = new StringBuilder();
for(var i = 0; i < n; i++)
	sb.Append(v);

var s = sb.ToString();

var s = string.Concat(Enumerable.Repeat(v, n));

string s = string.Create(v.Length * n, (v, n), static (span, state) =>
{
    var (v, n) = state;
    var originSpan = v.AsSpan();
    for (var i = 0; i < n; i++)
    {
        var subSpan = span[(i * originSpan.Length)..];
        originSpan.CopyTo(subSpan);
    }
});

void foo(object x)
{
    if (x is string s)
    {
        Console.WriteLine(s);
    }
    else
    {
        Console.WriteLine("Nothing.");
    }
}

foo("Hello, world!");
foo(42);

void foo<T>(T x)
{
    if (x is string s)
    {
        Console.WriteLine(s);
    }
    else
    {
        Console.WriteLine("Nothing.");
    }
}

foo("Hello, world!");
foo(42);

record Vector(double X, double Y, double Z)
{
    public static Vector operator *(Vector a, Vector b)
    {
        return new(
            a.Y*b.Z - a.Z*b.Y,
            a.Z*b.X - a.X*b.Z,
            a.X*b.Y - a.Y*b.X
        );
    }
}

T e = T.Horse;
string s = e.ToString();
Console.WriteLine(s);

public static void tst(Object x) {
  if (x.GetType() == typeof(foo))
    Console.WriteLine("Same type.");
  else if (x.GetType().IsAssignableTo(typeof(foo)))
    Console.WriteLine("Extends type.");
  else
    Console.WriteLine("Not related.");			
}

string FizzBuzzOrNumber(int number) => number switch {
    var n when n % 15 == 0 => "FizzBuzz",
    var n when n % 3 == 0 => "Fizz",
    var n when n % 5 == 0 => "Buzz",
    var n => n.ToString()
};

for (var i = 1; i <= 100; i++)
{
    Console.WriteLine(FizzBuzzOrNumber(i));
}

var t = new string(s.Where(c => !Char.IsWhiteSpace(c)).ToArray());

var a = Enumerable.Range(0, s.Length / 8)
        .Select(i => s.Substring(i * 8, 8).ToCharArray())
        .Select(block => (byte)block.Aggregate(0, (acc, c) => (acc << 1) + (c - '0')))
        .ToArray();

var line = Console.ReadLine();

var a = new int[n];

b = x.Contains(e);

string s = a + b;

string s = String.Concat(a,b);

// This is a comment

var s = $"Our sun has {x} planets";

byte[] data = Encoding.UTF8.GetBytes(s);

var b = string.IsNullOrEmpty(s);

var a = m.Values.ToList();

char c = s[^1];