gele.log()

正直こんないらないけど・・・

C#チートシート　v1.0

データ型

　
　・データ型
　　bool　true　｜　false
　　char　\u0000 ～\uffff
　　sbyte　-128 ～127
　　short　-32,768 ～ 32,767
　　int　-2,147,483,648 ～　2,147,483,647
　　long　-9,223,372,036,854,775,808 ～　9,223,372,036,854,775,807
　　byte　0 ～255
　　ushort　0 ～65,535
　　uint　0 ～4,294,967,295
　　ulong　0 ～18,446,744,073,709,551,615
　　float　-3.402823×10^38 ～ 3.402823×10^38
　　double　 -1.79769313486232×10^308 ～ 1.79769313486232×10^308
　　decimal　-79228162514264337593543950335 ～　79228162514264337593543950335
　　string　文字列
　　object　オブジェクト
　
　・宣言
　　データ型 変数名 = 初期値;
　　bool wkbl = true;
　　
　　
　　null 許容型
　　　int? num1　←Nullを入れられる値型を宣言できる
　
　・複数宣言
　　データ型 変数名 = 初期値, 変数名 = 初期値, 変数名 = 初期値;
　　int a = 100, b = 200, c = 2000;
　
　・型推論
　　var 変数名 = 初期値;
　　var wks = “test”;
　
　・定数宣言
　　const データ型 変数名 = 初期値;
　　const int CNSTTEST = 2000;
　
　・数値リテラル
　　数値セパレーター
　　　1000_0000→1000000と認識
　　型サフィックス
　　　long　L →1000L
　　　uint　U →100U
　　　ulong　UL → 100UL
　　　float　F　→1.9F
　　　double　D　→ 2.2D
　　　decimal　M　→10000M
　・型変更
　　public static bool TryParse
　　.Parse
　　
　・文字リテラル
　　エスケープシーケンス
　　　\”
　　　\t
　　　\r
　　　\n
　　　
　　通常
　　　”ここに文章を入れる”
　　　
　　逐語的リテラル
　　　@”アットマークを付けると　c:\widnows\ みたいなのをエスケープシーケンスいれなくてもいい”
　　　
　　文字列に変数を入れる
　　　$”こんなふうにかくと{wkStr}変数いれられるよ”
　　
　　・型変換
　　　integer Int32.Parse(“200”)
　　　float Single.Parse(“0.143”)
　　　double Double.Parse(“0.333”)
　
　・配列
　　int[] hoge = new int[5]
　　int[] hoge = {1,2,3,4,5}
　　Ｘ次元配列
　　int[,,] data = new int[3, 3, 3];
　　
　リスト・セット・ディクショナリ
・List 要素を順に格納したリスト
　var list = new List
・LinkedList 要素同士を双方向リンクで連結したリスト　（順々に取得しかできないが高速）
LinkedListNode First 最初の要素を取得（読み取り専用）
LinkedListNode Last 最後の要素を取得（読み取り専用）
LinkedList List* ノードが属するリスト
LinkedListNode Previous* 直前のノード
LinkedListNode Next* 直後のノード
・Stack 後入れ先出しのデータ構造
・Queue 先入れ先出しのデータ構造
・HashSet 重複しないデータの集合（順序を保証しない）
・SortedSet 重複しないデータの集合（順序を保証）
・Dictionary 基本的なディクショナリ（キーの順序を保証しない）
・SortedDictionary キーの順序を管理できるディクショナリ
・SortedList キーの順序を管理できるディクショナリ（二分探索が可能）
　
　・タプル
　　(型1 メンバー名1, 型2 メンバー名2, …)
public (int max, int min) GetMaxMin(int x, int y)
{
return x >= y ? (x, y) : (y, x);
}
void Hoge((int x, int y) tuple, string value) {…} 　引数の型
(int max, int min) t; 　変数の型
　　
　　・タプルの分解
　　　var (resultMax, resultMin) = a.GetMaxMin(5, 3);
　
　・匿名型
　　var 変数名 = new { メンバー名 = 初期値, … }
var info = new { Title = “XXXX”, Price = 1000 };
Console.WriteLine(info.Title); // 結果：XXXX
Console.WriteLine(info.Price); // 結果：1000

　・列挙型
enum Season
{
Spring,
Summer,
Autumn,
Winter,
}

修飾子
public すべてのクラスからアクセス可能
internal 同じアセンブリ内からのみアクセス可能（既定）
データ型
byte、sbyte、short、ushort、int、uint、long、ulong
enum Season : long {
Spring = 1, ←1から採番される
Summer,
Autumn,
Winter,
}

　・構造体
[修飾子] struct 構造体名 : インターフェイス名, …
{
…構造体の本体…
}

　・動的型付け（Jsonとかの時に使う）
dynamic d = 10;
d = “ほげ”;
d.Hoge();

演算子
　・算術演算子
　　+ 加算　　　　　x+y
　　- 減算 x-y
　　* 乗算 x*y
　　/ 除算 x/y
　　% 剰余（割った余り） x%y
　　++ 前置加算（代入前に加算）++x
　　++ 後置加算（代入後に加算）x++
　　– 前置減算（代入前に減算）–x
　　– 後置減算（代入後に減算）x–
　　
　・代入演算子
　　= 変数などに値を代入x = 10
　　+= 左辺と右辺を加算した結果を、左辺に代入
　　-= 左辺から右辺を減算した結果を、左辺に代入
　　*= 左辺と右辺を乗算した結果を、左辺に代入
　　/= 左辺を右辺で除算した結果を、左辺に代入
　　%= 左辺を右辺で除算した余りを、左辺に代入
　　
　・関係演算子
　　== 左辺と右辺の値が等しい場合はtrue
　　!= 左辺と右辺の値が等しくない場合にtrue
　　< 左辺が右辺より小さい場合にtrue 　　> 左辺が右辺より大きい場合にtrue
　　<= 左辺が右辺以下の場合にtrue 　　>= 左辺が右辺以上の場合にtrue
　・条件演算子
　・null 条件演算子(wkHogeがNullデモ落ちない）
　　wkHoge?.Trim()
　　
　・三項演算子
　　条件式 ? 式1 : 式2
　　(intHoge > 20 ? “OK”:”NG”)
　　
　・null合体演算子
　　式1 ?? 式2
　　strHoge ? “strHogeがNullの時はこっちが設定される”
　
　・論理演算子
　　&& 論理積。左右の式がともにtrue の場合にtrue x && y
　　|| 論理和。左右の式いずれかがtrue の場合にtrue x || y
　　^ 排他的論理和。左右の式いずれか一方だけがtrue の場合にtrue x ^ y
　　! 否定。式がtrue の場合はfalse、false の場合はtrue !x

　・sizeof演算子
　　sizeof(intHoge)
　　値型のサイズをバイト単位で取得、unsafeを利用すれば構造体も可
　
　・nameof 演算子
　　nameof(intHoge)
　　変数・クラス・メンバーなどの識別子を文字列リテラルで取得

　・is演算子
　　変数 is 型
if (p is Student)
{
Student st = (Student)p;
…正しくキャストできた場合の処理…
}

　・is演算子拡張
　　変数 is 型名 変換後の変数名
if (p is Student st)
{
…正しくキャストできた場合の処理…
}
　　
　・as演算子
　　変数 as 型名
var st = p as Student;
if (st != null)
{
…正しくキャストできた場合の処理…
}

・制御構文
　・ＩＦ条件分岐
　　if(条件式)
　　{
　　　…条件式がtrueのときに実行する処理…
　　}
　　else if(条件式2)
　　{
　　 条件式2に当てはまる（略
　　}
　　else
　　{
　　　…条件式がfalseのときに実行する処理…
　　}
　
　・switch条件分岐
　　switch(式)
　　{
　　case 値1:
　　　…「式 = 値1」の場合に実行する処理…
　　　break;
　　case 値2:
　　　…「式 = 値2」の場合に実行する処理…
　　　break;
　　default:
　　　…すべての値に合致しない場合に実行する処理…
　　　break;
　　}
　　
　・switch命令による型判定
　　switch(obj)
　　{
　　　// 変数objがint型の場合、絶対値を求める
　　case int i:
　　　Console.WriteLine(Math.Abs(i));

　・switch when 命令による型判定＋条件文
　　switch (obj)
　　{
　　case int i when i >= 15:
　　　Console.WriteLine(“15以上の数値です。”);
　　　break;
　　case int i:
　　　Console.WriteLine(“数値です。”);
　　　break;
　　case string str when str.Length < 10: 　　　Console.WriteLine("10文字未満の文字列です"); 　　　break; 　ループ 　・while 　　while(条件式) 　　{ 　　　...条件式がtrueである間、繰り返し実行する処理... 　　} 　　 　・do...while 命令 　　do 　　{ 　　　...条件式がtrueである間、繰り返し実行する処理... 　　} while(条件式); 　　 　・for 　　for (var i = 1; i < 6; i++) 　　{ 　　　Console.WriteLine($"{i}番目のループです。"); 　　} 　　 　・foreach 　　foreach (var val in data) 　　{ 　　　Console.WriteLine(val); 　　} 　　 　・ループ解除 　　break 　・次の周回へ 　　continue 　　 クラス 　・インスタンス化 　　クラス名 変数名 = new クラス名(引数, ...) 　　classmei hoge = new classmei(); 　　修飾子 public すべてのクラスからアクセス可能 internal 同じアセンブリ内からのみアクセス可能（既定） abstract 抽象メンバーを指定 static 静的メンバーを指定 sealed 他のクラスから継承できない 　・コンストラクタ 　　[修飾子] クラス名([引数の型 引数, ...]) 　 　・デストラクター 　　~クラス名() 　・フィールド [= 値] 　　・修飾子 public すべてのクラスからアクセス可能 protected internal 派生クラスと同じアセンブリ内からのみアクセス可能 protected 同じクラスと派生クラスからのみアクセス可能 internal 同じアセンブリ内からのみアクセス可能 private 同じクラスからのみアクセス可能（既定） readonly 読み取り専用のフィールドを宣言（7.5.4 項） static クラスフィールドを宣言（7.5.2 項） new 継承されたメンバーを隠蔽（8.2.2 項） volatile 複数スレッドから値が変更される可能性があることを宣言（11.1.3 項） 　　 　・メソッド(引数, ...) 　　・フィールド修飾子 public すべてのクラスからアクセス可能 protected internal 派生クラスと同じアセンブリ内からのみアクセス可能 protected 同じクラスと派生クラスからのみアクセス可能 internal 同じアセンブリ内からのみアクセス可能 private 同じクラスからのみアクセス可能（既定） abstract 抽象メソッドを宣言（8.3.2 項） static クラスメソッドを宣言（7.5.1 項） new 継承されたメソッドを隠蔽する（8.2.2 項） virtual 派生クラスでオーバーライドできるようにする（8.2.3 項） override virtual メソッドをオーバーライド（8.2.3 項） sealed 派生クラスでオーバーライドできないようにする（8.2.5 項） async 非同期メソッドを宣言（11.1.4 項） extern メソッドの本体は外部で定義されている 　・自分を参照 　　this 　　 　・ローカル関数 　　メソッド内のみで利用出来る関数 static void Main(string[] args) { double Discount(int price, double rate) { return price * (1 - rate); } Console.WriteLine(Discount(1000, 0.2)); // 結果：800 } 　・IDisposable（UsingBlockを抜けたときに呼ばれるメソッドを宣言するためのインタフェース 　 　 　・拡張メソッド 　public static 戻り値の型 拡張メソッド名(this 拡張するクラス 引数名, その他の引数, ...) { ...メソッドの本体... } ※Stringクラスの拡張 static class StringExtensions { public static string Repeat(this string str, int count) { var builder = new StringBuilder(); for (var i = 1; i <= count; i++) { builder.Append(str); } return builder.ToString(); } } 　・入れ子のクラス class MyClass { class MyHelper 　　　　　　　　　　　　　　　　　　　　　　　　　　　　 { public void Show() { Console.WriteLine("Nested Class is running!"); } } public void Run() { var helper = new MyHelper(); helper.Show(); } } class NestedBasic { static void Main(string[] args) { var c = new MyClass(); c.Run(); // 結果：Nested Class is running! var h = new MyClass.MyHelper(); // 結果：エラー } } 　・パーシャルクラス 　　partial class MyPartial　一つのクラスを分割したファイルにて定義可能 　　 　・ジェネリック 　　宣言（サンプル） 　　public class List : IList,
　　
　　型パラメタの規定値
　　T value = default(T);
　　
　　型パラメーターの制約条件
　　class MyGenerics where T : IComparable
　　
　・ラムダ式によるメンバーの定義
class LambdaMember
{
private int _value;
// コンストラクター
LambdaMember() => Console.WriteLine(“constructor”);

// プロパティ（C# 7以降）
public int Value
{
get => this._value;
set => this._value = value;
}
// get-onlyプロパティ（C# 6ではこちらだけ）
public DateTime Current => DateTime.Now;
// インデクサー
public int this[int index] => this.Value * index;
// メソッド
public int Calculate() => this.Value * this.Value;
// 演算子
public static bool operator true(LambdaMember e) => e.Value == 0;
public static bool operator false(LambdaMember e) => e.Value != 0;
}

ジェネリックメソッド
　※クラスとは違う
修飾子] 戻り値の型 メソッド名<型パラメーター, ...> (引数の型 引数名, …)
{
…メソッドの本体…
}

例外
try
{
…例外が発生する可能性があるコード…
}
catch (例外型1 変数1)
{
…例外型1が発生した場合の処理…
}
catch (例外型2 変数2)
{
…例外型2が発生した場合の処理…
}
finally
{
// 例外の有無に関わらず、実行
}

　・例外フィルター
　　catch(例外型 変数) when(条件式)
　　catch (FileNotFoundException ex) when (ex.Message.Contains(“.dat”))
　　
　　例外フィルターによるマルチキャッチ
　　catch (Exception ex) when(
　　ex is FileNotFoundException ||
ex is ArgumentException
)
　・throw(例外の発生）
　 throw 例外オブジェクト
　　・条件演算子
var i = -10;
Console.WriteLine(i > 0 ? i : throw new Exception(“iは正数でなければいけません。”));
・null 合体演算子
Console.WriteLine(str ?? throw new Exception(“変数strがnullです。”));
・式形式のラムダ式／メソッド
　void Hoge() => throw new NotSupportedException(“未実装です。”);
　
　・例外の再スローには「throw;」
　
正規表現
using System.Text.RegularExpressions;
…中略…
var tel = new[] { “080-0000-0000”, “084-000-0000”, “184-0000″ };
var rgx = new Regex(@”\d{2,4}-\d{2,4}-\d{4}”);
foreach (var t in tel)
{
Console.WriteLine(rgx.IsMatch(t) ? t : “アンマッチ” );
}

　正規表現の定義
　・Regex(string pattern [, RegexOptions options])
　　オプション
Compiled 正規表現をコンパイル（実行速度は速まるが、起動時間は遅くなる）
IgnoreCase 大文字／小文字の違いを無視
Singleline シングルラインモード
Multiline マルチラインモード

　一致するかどうか
　・IsMatch(string input [,int startat])

　一致した物を抜き出す
　・Match Match(string input [,int beginning [,int length]])
var str = “電話番号は、084-000-0000です。”;
var rgx = new Regex(@”(\d{2,4})-(\d{2,4})-(\d{4})”);
var match = rgx.Match(str);
// マッチした場合のみ出力処理
if (match.Success)
{
Console.WriteLine(
$”位置:{match.Index} マッチ文字列：{match.Value}”);
// サブマッチ文字列を順に出力
foreach (Group m in match.Groups)
{
Console.WriteLine(m.Value);
}
}
　
　一致した物を全部抜き出す
　・MatchCollection Matches(string input [,int startat])
var str = “自宅の電話番号は、084-000-0000です。携帯は、080-0000-0000です。”;
var rgx = new Regex(@”\d{2,4}-\d{2,4}-\d{4}”);
var result = rgx.Matches(str);
Console.WriteLine(result.Count);
Console.WriteLine(result[0]);
foreach (Match m in result)
{
Console.WriteLine(
$”位置:{m.Index} 長さ：{m.Length} マッチ文字列：{m.Value}”);
}

・オーバーフローのチェック
　・アプリ全体でオーバーフローをチェックする
　　［ビルドの詳細設定］ダイアログ（図9.8）が開くので、［演算のオーバーフローおよびアンダーフローのチェック］にチェック

　・特定のブロックでのみオーバーフローをチェックする
checked
{
…オーバーフローを発生するかもしれないコード…
}

　・オーバーフローのチェックを除外する
　　unchecked(++i)
　　
　　
デリゲート（メソッドの変数化）
[修飾子] delegate 戻り値の型 デリゲート名(引数の型 引数, …)

delegate void Process(string str);
class DelegateBasic
{
static void Run(string s)
{
Console.WriteLine($”{s}走ります。”);
}
static void Main(string[] args)
{
var p = new Process(Run);
p(“ちょこちょこ”); // 結果：ちょこちょこ走ります。
}
}

修飾子
public すべてのクラスからアクセス可能
internal 同じアセンブリ内からのみアクセス可能（既定）

　・マルチキャストデリゲート
delegate void Process(string str);
class DelegateBasic
{
static void Run(string s)
{
Console.WriteLine($”{s}走ります。”);
}
static void Run2(string s)
{
Console.WriteLine($”{s}メッチャ走ります。”);
}
static void Main(string[] args)
{
Process p = Run;
p += Run2;
p(“ちょこちょこ”); // 結果：ちょこちょこ走ります。
ちょこちょこメッチャ走ります。
}
}

　・匿名メソッド（渡すためダケにメソッドを宣言しない）
class DelegateAnonymous
{
void ArrayWalk(string[] data, Func output)
{
foreach (var value in data)
{
Console.WriteLine(output(value));
}
}
static void Main(string[] args)
{
var data = new[] { “あかまきがみ”, “あおまきがみ”, “きまきがみ” };
var dm = new DelegateAnonymous();
// デリゲート型の引数に匿名メソッドを渡す
dm.ArrayWalk(data, delegate(string d) { return $”［{d}］”;});
}
}
　・標準ライブラリで提供されているデリゲート
Action 値を返さないメソッド
void Action()
void Action(T arg)
void Action(T1 arg1, T2 arg2)
void Action(T1 arg1, T2 arg2, T3 arg3)
void Action(
T1 arg1, T2 arg2, T3 arg3, T4 arg4)
Func　TResult 型の値を返すメソッド
TResult Func()
TResult Func(T arg)
TResult Func(T1 arg1, T2 arg2)
TResult Func(T1 arg1, T2 arg2, T3 arg3)
TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
Comparison型が同じ2つのオブジェクトを比較するメソッド
int Comparison(T x, T y)
Converterオブジェクトを別の型に 変換するメソッド
TOutput Converter(TInput input)
Predicateオブジェクトが条件を満 たしているかを判断する メソッド
bool Predicate(T obj)

ラムダ式
デリゲートキーワードの省略
(引数の型 引数) => {
…メソッドの本体…
}
　
　　例
　　dl.ArrayWalk(data, (string d) => $”［{d}］”);
　　↓型推論を使うのが通常
　　dl.ArrayWalk(data, (d) => $”［{d}］”);
　　↓引数1個だとカッコはいらない
　　dl.ArrayWalk(data, d => $”［{d}］”);
　　
　　
　　※なれるために
　　・ラムダ式を伴うListクラスのメソッド
　　　リストの内容を順番に処理する― ForEach メソッド
　　　public void ForEach(Action action)
　　　
var list = new List { 1, 3, 6, 9 };
list.ForEach(v => Console.WriteLine(v * v)); // 結果：1、9、36、81

　リストの内容を変換する―ConvertAll メソッド
　public List ConvertAll(Converter converter)

　　　指定された条件でリストを検索する― Find ／ FindAll メソッド
　　　public T Find(Predicate match)
　　　
　　　条件に合致する要素の位置を検索する― FindIndex ／ FindLastIndex メソッド
　　　public int FindIndex([int startIndex, [int count,]] Predicate match)
　　　public int FindLastIndex([int startIndex, [int count,]] Predicate match)
　　　
　　　条件に合致した要素が存在するかを判定する― Exists ／ TrueForAll メソッド
　　　※条件にあう物がアルカ
　　　public bool Exists(Predicate match)
　　　全ての要素が条件にあっているか？
　　　public bool TrueForAll(Predicate match)
　　　
　　　指定された条件に合致する要素を削除する― RemoveAll メソッド
　　　public int RemoveAll(Predicate match)

LINQ
　・即時実行のためのメソッド
All すべての要素が条件に合致するか
Any 条件に合致した要素があるか
Average 平均値を取得
Contains 指定の要素を含むか
Count 件数を取得
ElementAt 指定したインデックスの要素を取得
ElementAtOrDefault 指定したインデックス要素を取得。存在しない場合は、既定値を返す
First 最初の要素を取得
FirstOrDefault 最初の要素を取得。要素がない場合は既定値を返す
Last 最後の要素を取得
LastOrDefault 最後の要素を取得。要素がない場合は既定値を返す
LongCount 要素数を取得（long 型）
Max 最大値を取得
Min 最小値を取得
SequenceEqual 2つのシーケンスが等しいか
Single 唯一の要素を取得
SingleOrDefault 唯一の要素を取得。空の場合は既定値を返す
Sum 合計値を取得
ToArray 配列を作成
ToDictionary ディクショナリを作成
ToList リストを作成

　・クエリ構文
var bs = from b in AppTables.Books
where b.Title.Contains(“アプリ”)
select b;
　・メソッド構文　こっちの方が一般的！！
　var bs = AppTables.Books
.Where(b => b.Title.Contains(“アプリ”))
.Select(b => b);

　・データの検索条件を指定する ―― where句／ Whereメソッド
　　・部分一致検索
var bs = AppTables.Books
.Where(b => b.Title.Contains(“アプリ”))
.Select(b => b);

　　・候補値検索
var bs = AppTables.Books
.Where(b => new int[] { 1, 4 }.Contains(b.Published.Month))
.Select(b => b);

　　・範囲検索
var bs = AppTables.Books
.Where(b => 1500 <= b.Price && b.Price <= 2000) .Select(b => b);

　　・単一の要素を取得する　※複数ヒットの場合エラー
var bs = AppTables.Books
.Single(b => b.Isbn == “978-4-7981-3547-2”);

・単一行の取得・または空の場合
var bs = AppTables.Books
.SingleOrDefault(b => b.Isbn == “978-4-7981-5104-5”);

・データを並べ替える ―― orderby句／ OrderByメソッド
var bs = AppTables.Books
.OrderBy(b => b.Isbn);
　メソッド
OrderBy 昇順に並べ替え
OrderByDescending 降順に並べ替え
ThenBy 昇順に並べ替え（第2 キー以降）
ThenByDescending 降順に並べ替え（第2 キー以降）

・特定のプロパティだけを取り出す　―― select句／ Selectメソッド
var bs = AppTables.Books メソッド構文
.Select(b => new
{
ShortTitle = b.Title.Substring(0, 5),
TaxedPrice = b.Price * 1.08,
Released = (b.Published <= DateTime.Now ? "発売中" : "発売予定") } ); ・データの重複を除去する ―― Distinctメソッド var bs = AppTables.Books .Select(b => b.Publisher)
.Distinct();

・m ～n件目のデータを取得する ―― Skip ／ Takeメソッド
var bs = AppTables.Books
.OrderBy(b => b.Published)
.Skip(2)
.Take(3)
.Select(b => b);

・先頭のデータを取得する ―― Firstメソッド
var bs = AppTables.Books
.OrderBy(b => b.Price)
.First();

・データをグループ化する ―― group句／ GroupByメソッド
var bs = AppTables.Books
.GroupBy(b => b.Publisher);

・複数のキーでグループ化する
var bs = AppTables.Books
.GroupBy(b => new {
Publisher = b.Publisher,
PublishYear = b.Published.Year
});

・グループ化した結果を絞り込む ―― into句
var bs = AppTables.Books メソッド構文
.GroupBy(b => b.Publisher)
.Where(pubs => pubs.Average(b => b.Price) <= 2500) .Select(pubs => new
{
Published = pubs.Key,
AveragePrice = pubs.Average(b => b.Price)
});

・集計メソッド
Average 平均値
Count 件数
LongCount 件数（Int64）
Max 最大値
Min 最小値
Sum 合計値

・複数のデータソースを結合する ―― join句／ Joinメソッド
var bs = AppTables.Books
.Join(
AppTables.Reviews,
b => b.Isbn,
r => r.Isbn,
(b, r) => new {
Title = b.Title,
Reviewer = r.Name,
Body = r.Body
}
);

マルチスレッド
・スレッドの生成／実行
public Thread(ThreadStart start)
public Thread(ParameterizedThreadStart start)

実行
threadObject.Start(object parameter)

・タスクの生成／実行（スレッドの使い回し）
// タスクを開始
Task t1 = Task.Run(() => Count(1));
// タスクの終了まで待機
t1.Wait();

・排他制御
lock(ロック対象のオブジェクト) { …同期すべき処理… }
// 同期処理
lock (lockobj)
{
this.Count++;
}

・async修飾子とawait 演算子
class AsyncBasic
{
static void Main(string[] args)
{
// 非同期メソッドを呼び出す
Task t = RunAsync();
Console.WriteLine(“…他の処理…”);
t.Wait();
}
// 非同期メソッドを定義
static async Task RunAsync()
{
await Task.Run(() => Count(1));
Console.WriteLine(“処理が終了しました。”);
}
static void Count(int n)
{
for(int i = 0; i < 50; i++) { Console.WriteLine($"Task{n}: {i}"); } } } ・値を返す非同期メソッド 　static async Task RunAsync()

属性
・属性の構文
[対象:属性(値, …)]
・属性を適用する対象
assembly アセンブリ
module モジュール
type クラス／インターフェイスや構造体、列挙型やデリゲートなど
field フィールド
property プロパティ／インデクサー
method メソッド（get ／ set ブロックを含む）
param メソッドの引数
return メソッドの戻り値
event イベント

・特定の条件下でのみメソッドを実行する― Conditional 属性
[Conditional(“DEBUG”)]
static void Message()
{
Console.WriteLine(“デバッグ時にだけ表示します。”);
}
static void Main(string[] args)
{
Message();
Console.WriteLine(“終了しました。”);
}