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);