プロになるためのWeb技術入門

JavaでのWEBアプリを作成するに当たって読みました。
JSP,サーブレットといった技術はまさに理解したかった項目だったので良かったです。
過去、ネットワーク越しに文書を共有したいというニーズがあってHTTPが生まれた。

クライアントの操作によって対象を動作させたいというニーズがあってCGIが生まれた

CGIを高速に大量に動作させる為にServletが生まれた

Servletのモジュールをクライアント側とサーバ側で分離させる為にJSPが生まれた
という様に時系列に沿って各技術を説明してくれています。
結果、アプリケーションサーバ(Tomcat)、JSP、サーブレット
に多くのページを割いていますが、非Javaエンジニアに取っては分かり難くないでしょうか?
大丈夫でしょうか? PHPやRubyエンジニアに取ってもこれらは有用でしょうか?
.Net限定エンジニアに取っては難しいと思います。
ただここを理解すればIISの設定等も格段にやりやすくなるとは思いますが。
WEBの技術がPerl→Javaを経て現在に至る事の証左とも言えるでしょう。

他、以下について説明しています。
サーバ, クライアントモデル
HTTPプロトコル
IPアドレス
URL, URI
GET, POST
CGI
Cookie
Session
Web システム構成
WEB サーバ
DB サーバ
アプリケーションサーバ
Webアプリーション
フレームワーク
Web アーキテクチャ
MVC Pattern
layer Pattern

本サイトの参照記事
[JAVA]

プログラム言語 エンコード・デコード処理

エンコードとは

符号化
文字に対してコンピュータで扱う文字コード=コード(数値)を割り振る事
テキストエディタで文字データを作成・保存した際、
OS毎の割り振られる文字コードは以下の通り。
・Windows:Shift_JIS
・UNIX系:EUC
・Mac:Unicode
テキストエディタの機能によって保存時の文字コードを変更する事は可能
OSに関わらずUTF-8が国際的に標準化されつつある。
特にHTML5では推奨される。
漢字をUTF-8で保存すると容量が増えるという問題点あり
XMLでは、XML宣言でエンコードの種類を明示的に表記する
<?xml version="1.0" encoding="Shift_JIS"?>
<a>~</a>

割り振られた文字コードを解析して読み込む事をデコードと言う。
割り振られた文字コードと違う文字コードで読み込んだ場合、文字化けする。

読込

string[] s;
s = File.ReadAllLines(@"D:\~txt", Encoding.Default);
s = File.ReadAllLines(@"D:\~.txt", Encoding.GetEncoding(name: "Shift_JIS"));
s = File.ReadAllLines(@"D:\~.txt", Encoding.Unicode);
s = File.ReadAllLines(@"D:\~.txt", Encoding.UTF8);

書込

File.WriteAllLines(@"D:\~txt", @"内容", Encoding.Default);
File.WriteAllLines(@"D:\~.txt", @"内容", Encoding.GetEncoding(name: "Shift_JIS"));
File.WriteAllLines(@"D:\~.txt", @"内容", Encoding.Unicode);
File.WriteAllLines(@"D:\~.txt", @"内容", Encoding.UTF8);

BASE64エンコード・デコード

BASE64とは?
バイナリデータ→テキストデータ
への変換方式
英数字のみで構成される
暗号ではない

import java.io.IOException;
import org.apache.commons.codec.binary.Base64;

public class base64test {
 public static void main(String[] args) {
  try{
   String after = encodeBase64("~");
  }
  catch ( ~ ){
   ~
  }

 }
 
 public static String encodeBase64(String before) throws IOException {
  byte[] out = Base64.encodeBase64(before.getBytes());
  return new String(out, "shift_jis");
 }
}

Sub main
 after = encode("~")
 after = decode("~")
End Sub

'Base64文字列にエンコードする
Public Function encode(val As String) As String

 Dim objBase64 As Object
 Dim b() As Byte
 b = stringToByte(val)
 
 'Msxml2.DOMDocumentオブジェクト = XML操作オブジェクト
 Set objBase64 = CreateObject("MSXML2.DOMDocument").createElement("b64")
 objBase64.DataType = "bin.base64"
 objBase64.nodeTypedValue = b
 encode = objBase64.text
 
 Set objBase64 = Nothing

End Function

'Base64文字列をデコードする
Public Function decode(val As String) As String
 Dim objBase64 As Object
 'Msxml2.DOMDocumentオブジェクト = XML操作オブジェクト
 Set objBase64 = CreateObject("MSXML2.DOMDocument").createElement("b64")
 objBase64.DataType = "bin.base64"
 objBase64.text = val
 
 Dim b() As Byte
 b = objBase64.nodeTypedValue
 decode = byteToString(b)
 
 Set objBase64 = Nothing

End Function

'文字列バイト列に変換する
Public Function stringToByte(ByVal strData As String) As Byte()

 Dim objStream As Object
 Set objStream = CreateObject("ADODB.Stream")
 
 objStream.Open
 objStream.Type = adTypeText
 objStream.Charset = "utf-8"
 objStream.WriteText strData
 
 objStream.Position = 0
 objStream.Type = adTypeBinary
 objStream.Position = 3
 stringToByte = objStream.Read
 
 objStream.Close
 Set objStream = Nothing
 
End Function

プログラム言語 XML操作

作成

文字列指定

using System.Xml;

const string url = "http://example.com/";
var doc = new XmlDocument();

親要素・属性
var root = doc.CreateElement("root", url);
var att = doc.CreateAttribute("att");
att.AppendChild(doc.CreateTextNode("sample"));
root.Attributes.Append(att);

子要素
var child1 = doc.CreateElement("child1", url);
child1.AppendChild(doc.CreateTextNode("sample1"));
root.AppendChild(child1);

var child2 = doc.CreateElement("child2", url);
child2.AppendChild(doc.CreateTextNode("sample2"));
root.AppendChild(child2);

doc.AppendChild(root);

Console.WriteLine(doc.OuterXml());

親要素・属性・子要素をまとめて構築
doc.LoadXml("<root att='sample' xmlns='http://example.com/'><child1>sample</child1><child2>sample</child2></root>");

Console.WriteLine(doc.OuterXml());

結果
<root att="sample" xmlns="http://example.com/">
 <child1>sample</child1>
 <child2>sample</child2>
</root>

using System.Xml.Linq;

var doc = new XDocument();
XNamespace name = "http://example.com/";
var root = new XElement(name + "root");
var attRoot = new XAttribute("attRoot", "value");
var elm1 = new XElement(name: "elm1", content: "value1");
var elm2 = new XElement(name: "elm2", content: "value2");
var attElm = new XAttribute("attElm", "value");

root.Add(elm1);
root.Add(elm2);
elm2.Add(attElm);
root.Add(attRoot);
doc.Add(root);

Console.WriteLine(doc.ToString());

XNamespace name = "http://example.com/";
var root = new XElement(
 name + "root", new XAttribute("att", "valueAtt"),
 new XElement("elm1", "value1"),
 new XElement("elm2", new XAttribute("attElm", "value"), "value2"));

Console.WriteLine(root.ToString());

結果
<root attRoot="value" xmlns="http://example.com/" >
 <elm1>value</elm1>
 <elm2 attElm="value">value</elm2>
</root>

文字列→XML変換

var doc = XDocument.Parse("<root xmlns='http://office-yone.com/'><a>システム開発</a><b>ホームページ作成</b></root>");

結果
Console.WriteLine(doc.ToString());
<root xmlns='http://office-yone.com/'>
 <a>システム開発</a>
 <b>ホームページ作成</b>
</root>

読取

値で検索

var doc = XDocument.Parse("<root xmlns='http://office-yone.com/'><a>システム開発</a><b type="web">ホームページ作成</b><c><d>インフラ構築</d></c></root>");

XNamespace name = "http://office-yone.com/";
int count = doc.Descendants(name + "a").Count();
count:1

int count = doc.Descendants(name + "b").Where( x => x.Value == "ホームページ作成").Count();
count:1

int count = doc.Descendants(name + "b").Where( x => x.Attribute("type").Value == "web").Count();


<root xmlns='http://office-yone.com/'>
 <a>システム開発</a>
 <b type="web">ホームページ作成</b>
 <c>
  <d>インフラ構築</d>
 </c>
</root>

要素名で検索

var doc = XDocument.Parse("<a><b><c>WordPress</c></b></a>");
string val = doc.Element("a").Element("b").Element("c").Value;
val:WordPress

<a>
 <b>
  <c>WordPress</c>
 </b>
</a>

var doc = XDocument.Parse("<a><b><c>C#</c></b><b><c>Java</c></b></a>");
foreach (var elm in doc.Element("a").Elements("b").Elements("c"))
{
 Console.WriteLine(elm.Value);
};
→C# Java

<a>
 <b>
  <c>C#</c>
 </b>
 <b>
  <c>Java</c>
 </b>
</a>

プログラム言語 属性

概要

クラスやメンバーの付加情報
デバック中に機能するもの、コンパイル中に機能するもの、実行中に機能するものと様々。
クラス利用者へのメッセージ・指示、コンパイラへの指示等。

エントリポイント

///

/// アプリケーションのメイン エントリ ポイントです。
///

[STAThread]
static void Main()
{
Application.Run(new Form1());
}

スレッド種類

[STAThread]
メソッドがシングルスレッドアパートメントである事を明示
元々WindowsのCOMコンポーネントは、STA(SingleThreadApartment)でないとエラーになる為、
Mainメソッドにはこの属性が付与されている。

別スレッドにてActiveXコントロールを使用する際には以下の設定が必要。
Thread other = new Thread(start: new ThreadStart(非同期処理));
other.SetApartmentState(ApartmentState.STA);
other.Start();

コーディング時の警告

[Obsolete("警告:代わりに~を使って下さい。")]
public static void OldMethod(){}

[Obsolete("エラー:代わりに~を使って下さい。", true)]
public static void VeryOldMethod(){}

public static void Main()
{
  // コンパイル時:警告。「警告:代わりに~を使って下さい。」
  OldMethod();
  
  // コンパイル時:エラー。「エラー:代わりに~を使って下さい」
  VeryOldMethod();
}

プログラム言語 非同期処理

用語解説

非同期処理

複数の別の処理を同時に行う。
マルチコア環境(複数のCPUで処理する)の場合、高速化する可能性あり。

並列(並行)処理

単一の処理を複数に分割して行う。

プロセス

プログラムの実行単位
プロセスは1つ以上のスレッド、固有のヒープメモリ領域等で構成される。
起動や切り替えに時間が掛かる。
複数プロセスに対する処理時間の割り当てはOSが行う。
具体的にはプロセス内のスレッドに対して処理を割り当てる。

スレッド

CPUの利用単位
スレッド単位でスタック、CPUレジスタのコピーを持つ
ヒープメモリ領域は同一プロセス内のスレッドで共用する
起動や切り替えが速い。
複数スレッドに対する処理時間の割り当てはOSが行う。

UIスレッド
=メインスレッド
※エンド・ユーザーからの入力を受け付けたり、UIを描画したりするスレッド
ワーカースレッド
UIスレッドのバックグラウンドで動作する別スレッド

非同期処理(マルチスレッド)のメリット

プロセスA
 スレッド1
 スレッド2
プロセスB
 スレッド1
だとプロセスAの方が多くの処理時間が割り当てられる。
よってマルチスレッド処理は有用。

同期制御

複数のスレッドがタイミングを計りながらリソースに対してアクセスする事。

プリエンプティブ

マルチタスク、マルチスレッドの処理におけるスケジューリング方法の1つ。
タスク(スレッド)が動作中であろうが一定時間が経過すると強制的に処理を別タスクへ移す。

強調的(ノン・プリエンプティブ)

各タスクが自己申告で都合の良い場所まで処理を終えてから処理を別タスクへ移す。
実際にはシステムコールを呼び出すタイミングで処理が移される。
多段フィードバックキュー
・短いタスクを優先する
・FIFO(FirstInFirstOut)方式で最初にスケジューリングされたタスクを優先する
等の優先順位の重みに違いがあるプリエンプティブ方式

スレッドセーフ

1つのデータ(オブジェクト)に対して、複数のスレッドが同時にアクセスした場合、データの不整合が発生する。
排他制御を施し、この現象が発生しないクラスのこと。
スレッドセーフなクラスは継承禁止にすべき。
排他制御処理は時間が掛かる為、無用な使用は控えるべき。

スタック

FIFO方式で使用するメモリ領域。
スタックポインタ(SP)レジスタにスタックのアドレスを保持する事で、
スタックの読み込み先、書き込み先を判定する。
ローカル変数、関数の戻り先等に使用。

マルチスレッドにおけるスタック利用

スレッドを別に作成する毎にスタック領域が確保される(デフォルト:1MB)。
スレッドの切り替え時にはCPUレジスタの内容を退避/復帰する必要がある為、退避用メモリ領域も必要(デフォルト:1MB)。
容量及び、確保に時間を要するのでマルチスレッドはコストが高いと言われる。

スレッドプール

スレッド用のプログラムを保持しておくメモリ領域。
マルチスレッド用のスタック領域を破棄せずに使いまわす事で容量及び処理時間を短縮する目的で使用される。
.NET4.0以前
ThreadPool.QueueUserWorkItemメソッドを利用
(省略)
.NET4.0以降
=Taskクラスを利用したスレッド

実例

別スレッド呼び出し(引数無し)

以下の内容は現在ではメリット無し
非同期処理はスレッドプール(Taskクラス)を使う。

static void Main(string[] args)
{
  ThreadStartデリゲートにメソッドを指定
  Thread other1 = new Thread(start: new ThreadStart(OtherThread1));
  other1.Start();
  
  パラメータ用ThreadStartデリゲートにメソッドを指定
  Thread other2 = new Thread(start: OtherThread1);
  other2.Start();
  
  ラムダ式
  Thread other3 = new Thread(() => OtherThread1());
  other3.Start();
}

public static void OtherThread1()
{
  for (int i = 0; i < 10; i++)
  {
    Console.WriteLine(@”Other!”);
  }
}

var myTask = new Task(() => {
 非同期処理
});
myTask.Start();

new Task( () =>
{
 非同期処理
}).Start();

Task.Run(() =>
{
 非同期処理
});

var ret = Task.Run(() =>
{
 非同期処理
 return 5;
});

ret.Result:5

static async Task<string> myAsyncAwait()
{
 await Task.Run(() =>
 {
  非同期処理
 });
 return @"AAA";
}

var ret = myAsyncAwait().Result;
ret:AAA

Action func = async () =>
{
 await Task.Run(() =>
 {
  非同期処理
 });
};

func();

var html = Task.Run(async () => {
 return await new HttpClient().GetStringAsync(@"http://office-yone.com/");
});

html.Result:<html>~

Windowsコントロールへの非同期処理反映

SampleAsync();
Invoke等の処理は不要

public async void SampleAsync() {
 this.Windowsコントロール.~ = "実行中";
 await Task.Run( () => {
  非同期処理
 } );
 this.Windowsコントロール.~ = "完了";
}

public class ThreadA extends Thread{
 @Override
 public void run(){
  try{
   for (int i=0; i<10; i++){
    System.out.println( "A" );
    Thread.sleep(100);
   }
  }catch(InterruptedException e){
   System.out.println(e.getMessage());
  }

 }
}

public class ThreadB extends Thread{
 public void run(){
  try{
   for (int i=0; i<10; i++){
    System.out.println( "B" );
    Thread.sleep(100);
   }
  }catch(InterruptedException e){
   System.out.println(e.getMessage());
  }

 }
}

public class App{
 public static void main( String[] args )<{
  new ThreadA().start();
  new ThreadB().start();
 }
}

→A B B A A B B A A B A B B A B A B A A B

public class ThreadA implements Runnable{
 public void run(){
  try{
   for (int i=0; i<10; i++){
    System.out.println( "A" );
    Thread.sleep(100);
   }
  }catch(InterruptedException e){
   System.out.println(e.getMessage());
  }

 }
}

public class ThreadB implements Runnable{
 public void run(){
  try{
   for (int i=0; i<10; i++){
    System.out.println( "B" );
    Thread.sleep(100);
   }
  }catch(InterruptedException e){
   System.out.println(e.getMessage());
  }
 }
}

public class App{
 public static void main( String[] args ){
  new Thread(new ThreadA()).start();
  new Thread(new ThreadB()).start();
 }
}

→A B B A B A B A A B B A B A B A A B A B

別スレッド呼び出し(引数有り)

以下の内容は現在ではメリット無し
非同期処理はスレッドプール(Taskクラス)を使う。

  ラムダ式
  Thread other4 = new Thread(() => OtherThread2(@”4″));
  //other4.Start();

  匿名メソッド
  new Thread(start: delegate()
  {
    OtherThread2(“5”);
  }).Start();

  パラメータ用ThreadStartデリゲートに引数を渡す
  Thread other6 = new Thread(start: OtherThread3);
  other6.Start(parameter: @”6″);

  for (int i = 0; i < 10; i++)
  {
    Console.WriteLine(@”Main!”);
  }
}

static void OtherThread2(string msg)
{
  for (int i = 0; i < 10; i++)
  {
    Console.WriteLine(msg);
  }
  Console.ReadKey();
}

static void OtherThread3(object msg)
{
  ※ パラメータ用ThreadStartデリゲートに引数の引数は変換が必要
  string myMsg = (string)msg;
  for (int i = 0; i < 10; i++)
  {
    Console.WriteLine(myMsg);
  }
  Console.ReadKey();
}

public class MyThread extends Thread{
 private String _s;
 public MyThread(String s){
  this._s = s;
 }
 public void run(){
  System.out.println( this._s );
 }
}

public class App{
 public static void main( String[] args ){
  new MyThread("Java").run();
 }
}

public class MyThread implements Runnable{
 private String _s;
 public MyThread(String s){
  this._s = s;
 }
 public void run(){
  System.out.println( this._s );
 }
}

public class App{
 public static void main( String[] args ){
  new Thread(new MyThread("Java")).start();
 }
}

スレッドの終了を待つ

using System.Threading.Tasks;

var myTask = new Task( () =>
{
 Console.WriteLine("myTask : start");
 System.Threading.Thread.Sleep(1000);
 Console.WriteLine("myTask : end");

});

Console.WriteLine("program : start");
myTask.Start(); タスク開始
myTask.Wait(); タスクの終了を待つ
Console.WriteLine("program : end");


program : start
myTask : start
myTask : end
program : start

非同期処理が成功してから処理を開始する
var myTask = new Task(() =>
{
 Console.WriteLine("myTask1 : start");
 System.Threading.Thread.Sleep(5000);
 Console.WriteLine("myTask1 : end");

});

myTask.Start();
↑ スレッドの終了後に開始
myTask.ContinueWith(_ =>
{
 Console.WriteLine(@"myTask was finished.");
});

Console.WriteLine(@"program : end");
↑ スレッドの終了を待たずに実行される。
↑ スレッドは非同期

var myTask = new Task(() =>
{
 Console.WriteLine("myTask1 : start");
 System.Threading.Thread.Sleep(5000);
 Console.WriteLine("myTask1 : end");

});

myTask.Start();
myTask.ContinueWith(_ =>
{
 Console.WriteLine(@"myTask was finished.");
});
↑ スレッドの終了を待つ。
Task.WaitAll(myTask);
Console.WriteLine(@"program : end");

複数のスレッドの終了を待つ

var myThread1 = new Thread( () =>
{
 Console.WriteLine("myThread1 : start");
 System.Threading.Thread.Sleep(1000);
 Console.WriteLine("myThread1 : end");

});

var myThread2 = new Thread(() =>
{
 Console.WriteLine("myThread2 : start");
 System.Threading.Thread.Sleep(2000);
 Console.WriteLine("myThread2 : end");

});

Console.WriteLine("program : start");
myThread1.Start();
myThread2.Start();

myThread1.Join();
myThread2.Join();

Console.WriteLine("program : end");
スレッドが2つとも終了してから処理される

※タスククラスを使用した場合1
using System.Threading.Tasks;

var myTask1 = new Task(() =>
{
 Console.WriteLine("myTask1 : start");
 System.Threading.Thread.Sleep(1000);
 Console.WriteLine("myTask1 : end");

});

var myTask2 = new Task(() =>
{
 Console.WriteLine("myTask2 : start");
 System.Threading.Thread.Sleep(2000);
 Console.WriteLine("myTask2 : end");

});

Console.WriteLine("program : start");
myTask1.Start();
myTask2.Start();
Task.WaitAll(myTask1, myTask2);

Console.WriteLine("program : end");
スレッドが2つとも終了してから処理される

※タスククラスを使用した場合2
using System.Threading.Tasks;

Parallel.Invoke(() =>
{
 Console.WriteLine("myTask1 : start");
 System.Threading.Thread.Sleep(1000);
 Console.WriteLine("myTask1 : end");

},
() =>
{
 Console.WriteLine("myTask2 : start");
 System.Threading.Thread.Sleep(2000);
 Console.WriteLine("myTask2 : end");

});

Console.WriteLine("program : end");
スレッドが2つとも終了してから処理される

排他制御

複数のスレッドから共通のリソース(データ)にほぼ同時にアクセスする事によるデータの不整合を制御する事

using System.Threading.Tasks;

非同期処理をロックしない場合
static void myThread(int prm)
{
 Console.WriteLine(@"[");
 Thread.Sleep(prm * 1000);
 Console.WriteLine(@"]");
}

static void Main(string[] args)
{

 Parallel.Invoke(
  () => myThread(prm: 1),
  () => myThread(prm: 2)
 );
}
→ [ [ ] ]

非同期処理をロックする場合
private static object myLock = new object();
static void myThread(int prm)
{
 lock (myLock)
 {
  Console.WriteLine(@"[");
  Thread.Sleep(prm * 1000);
  Console.WriteLine(@"]");
 }
}

static void Main(string[] args)
{

 Parallel.Invoke(
  () => myThread(prm: 1),
  () => myThread(prm: 2)
 );
}
→ [ ] [ ]

public class FamilyTread extends Thread {
 private Bathroom room;
 private String name;

 public FamilyTread(Bathroom room, String name) {
  this.room = room;
  this.name = name;
 }

 public void run() {
  this.room.in(this.name);
 }
}

public class Bathroom {
 synchronized付与により、メソッドを同時呼び出し不可に
 public synchronized void in(String name) {
  System.out.println(name + ":enter");
  try {
   System.out.println(name + ":enterd");
   3秒待機
   Thread.sleep(3000);
  } catch (InterruptedException e) {
   
  }
  System.out.println(name + ":out");
 }

}

public class Main {
 public static void main(String[] args) {
  Bathroom room = new Bathroom();

  FamilyTread father = new FamilyTread(room, "父");
  FamilyTread mother = new FamilyTread(room, "母");
  FamilyTread sister = new FamilyTread(room, "姉");
  FamilyTread me = new FamilyTread(room, "自分");

  father.start();
  mother.start();
  sister.start();
  me.start();
 }
}

結果:synchronized無
母:enter
父:enter
姉:enter
自分:enter
姉:enterd
姉:out
父:enterd
父:out
母:enterd
母:out
自分:enterd
自分:out

結果:synchronized有
父:enter
父:enterd
父:out
自分:enter
自分:enterd
自分:out
姉:enter
姉:enterd
姉:out
母:enter
母:enterd
母:out

並列処理

using System.Threading;

Parallel.For(0, 10, (n) =>
{
 Console.WriteLine(n);
});
→0~9まで数字が出力されるが毎回結果が異なる
(出力に関して並列で処理が行われている)

ForEach利用
var ary = Enumerable.Range(start: 0, count: 10);
Parallel.ForEach(ary, n => {
 Console.WriteLine(n);
});

LINQの並列処理(PLINQ)
static void Main(string[] args)
{
 var oldAry = Enumerable.Range(start: 0, count: 10);
 
 var newAry1 = oldAry.Where(n => n > retNum()).Select(n => n).ToArray();
 時間は掛かるが0~9が順番通り格納される
 var newAry2 = oldAry.Where(n => n > retNum()).AsParallel().Select(n => n).ToArray();
 0~9がバラバラに格納される(並列で処理される)。
 var newAry3 = oldAry.Where(n => n > retNum()).AsParallel().AsOrdered().Select(n => n).ToArray();
 時間は掛かるが0~9が順番通り格納される(並列で処理されるがソートされる)。
}

時間を掛けて0を返すだけの関数
static int retNum()
{
 Thread.Sleep(millisecondsTimeout: 1000);
 return 0;
}

タイマー

フォームコントロールのタイマーとは別。
処理が軽い。

using System.Threading;

private delegate void _delegate();
※フォーム操作用
private System.Threading.Timer _timer();
※タイマーオブジェクトは外部に保持しておかないとガーベージコレクションの対象となる

private void MyForm_Load(object sender, EventArgs e)
{
  定期的に実行する処理を指定(callBackMethod)
  TimerCallback timerDelegate = new TimerCallback(callBackMethod);
  
  タイマー実行
  _timer = new System.Threading.Timer(
    callback: timerDelegate,  
    state: null,
    dueTime: 0,
    period: 1000);
}

定期的に実行される処理
private void callBackMethod(object o)
{
  処理
  処理
  
  フォームを操作する場合
  Invoke(method: new _delegate(method));
}

/複数行に渡る処理を行う場合
private void method()
{
  this.MyLabel.Text = “フォーム操作”;
}

IAsyncResultクラス利用による非同期処理

内部的にスレッドプールを使用している為処理が軽くなる。

基本

移譲オブジェクト
delegate string SampleDelegate(int prm1, string prm2);

static void Main(string[] args)
{
  移譲オブジェクト作成
  SampleDelegate sd = new SampleDelegate(DelegateMethod);

  非同期処理開始
  IAsyncResult ar = sd.BeginInvoke(prm1: 100, prm2: @”test”, callback: null, @object: null);

  非同期処理終了
  string result = sd.EndInvoke(result: ar);
}

非同期で実行させる(重たい)処理
static string DelegateMethod(int prm1, string prm2)
{
  return “”;
}

待ち合わせ・待機

移譲オブジェクト
delegate string SampleDelegate(int prm1, string prm2);

static void Main(string[] args)
{
  移譲オブジェクト作成
  SampleDelegate sd = new SampleDelegate(DelegateMethod);

  非同期処理開始
  IAsyncResult ar = sd.BeginInvoke(prm1: 100, prm2: @”test”, callback: null, @object: null);

  非同期処理を2秒中断
  ar.AsyncWaitHandle.WaitOne(millisecondsTimeout: 2000);

  非同期処理終了まで待機
  ar.AsyncWaitHandle.WaitOne();

  if (ar.IsCompleted)
  {
    非同期処理終了
    string result = sd.EndInvoke(result: ar);       
  }
}

非同期で実行させる(重たい)処理
static string DelegateMethod(int prm1, string prm2)
{
  return “”;
}

コールバック関数利用

移譲オブジェクト
delegate string SampleDelegate(int prm1, string prm2);

static void Main(string[] args)
{
  移譲オブジェクト作成
  SampleDelegate sd = new SampleDelegate(DelegateMethod);

  コールバック関数定義
  AsyncCallback cb = new AsyncCallback(CallBackMethod);

  非同期処理開始
  IAsyncResult ar = sd.BeginInvoke(prm1: 100, prm2: @”test”, callback: cb, @object: null);

  非同期処理終了
  string result = sd.EndInvoke(result: ar);
}

非同期で実行させる(重たい)処理
static string DelegateMethod(int prm1, string prm2)
{
  Console.WriteLine(“asynchronous”);
  Console.ReadKey();
  return “”;
}

static void CallBackMethod(IAsyncResult ar)
{
  Console.WriteLine(“callback”);
  Console.ReadKey();
}

スレッド関連メソッド/プロパティ

別スレッドを開始
Thread インスタンス = new Thread(start: new ThreadStart(メソッド名));
インスタンス.Start();

※別スレッドで起動できるのは戻り値無し、引数無しのメソッドのみ
 戻り値やパラメータを利用したいときは、後述のデリゲートを使用

バックグラウンド・スレッド
メインのスレッドが終了すると自身も終了するスレッド

フォアグラウンド・スレッド
メインのスレッドが終了しても終了しないスレッド

バックグラウンド・スレッドとする
インスタンス.IsBackground = true;

優先度変更
インスタンス.Priority = ThreadPriority.Highest;
インスタンス.Priority = ThreadPriority.Normal;
インスタンス.Priority = ThreadPriority.Lowest;

スレッドの一時停止
インスタンス.Suspend();

スレッドの再開
インスタンス.Resume();

スレッドの処理が終了するまで待つ
インスタンス.Join();

スレッドの強制終了
インスタンス.Abort();

1秒間待つ
Thread.Sleep(1000);